随着云计算规模持续扩张,CPU 在基础设施管理上的开销("数据中心税")已占据服务器算力的 25%-35%。DPU(Data Processing Unit,数据处理单元)作为继 CPU、GPU 之后的第三颗主力芯片,正在从根本上改变数据中心的架构范式。本文深入剖析 DPU 的硬件架构、编程模型、典型用例,以及从 SmartNIC 到完全卸载数据面的工程演进路径,帮助工程师理解并驾驭这一基础设施变革。


一、为什么需要 DPU:数据中心税的终结者

1.1 问题的本质

现代云服务器的 CPU 周期中,相当一部分被非业务逻辑消耗:

基础设施任务 占 CPU 比例
网络虚拟化(OVS/VXLAN 封装) 10%-15%
存储协议栈(NVMe-oF、压缩、加密) 5%-10%
安全(TLS/IPsec、防火墙、访问控制) 3%-7%
虚拟化开销(Hypervisor/KVM) 5%-10%
分布式协调(共识协议、一致性哈希) 2%-5%

当一台 128 核服务器有近三分之一算力消耗在基础设施上时,这是不可接受的浪费。DPU 的核心理念是:将基础设施任务从主机 CPU 卸载到专用芯片上,让主机 CPU 100% 服务于业务应用。

1.2 DPU 的演进路径

NIC (1G) → SmartNIC (10G) → ASIC SmartNIC (25G) → DPU (100G+) → DPU+ (400G+)
   ↓              ↓                    ↓                  ↓              ↓
 纯数据转发    简单流表卸载        固定功能卸载         可编程SoC          异构计算融合
  • 第一代 SmartNIC(2015 前后):基于 ASIC,支持流表卸载、SR-IOV,但编程能力有限
  • 第二代 DPU(2019+):集成 ARM Core、可编程网络加速器、存储加速器,支持运行完整 Linux 操作系统
  • 第三代 DPU+(2023+):加入 AI 推理引擎、RISC-V 控制平面、Chiplet 架构,向 "Infrastructure-on-a-Chip" 演进

1.3 市场格局与主要玩家

厂商 产品 架构特点 目标场景
NVIDIA/Mellanox BlueField-2/3 ARM Cortex-A72 + ConnectX 超级通道 通用 DPU 基础设施
Broadcom Stingray PS225 ARM A72 + NetXtreme 企业级 SmartNIC
Marvell OCTEON 10 ARM CN96xx + 硬件加速器 5G + 云
Intel IPU C5000x XScale + FPGA 超大规模云
中科驭数 K2 RISC-V + 定制数据面 国内金融/云
阿里云 XDR/XDMA 自研架构 神龙架构

二、DPU 硬件架构深度解析

2.1 BlueField-2 架构剖析

以 NVIDIA BlueField-2 为例,现代 DPU SoC 通常包含以下核心组件:

┌─────────────────────────────────────────────────────────┐
│                    DPU SoC 架构图                        │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │  ARM Cortex   │  │  网络加速器   │  │  存储加速器   │  │
│  │  A72 x8      │  │  (ConnectX)   │  │  (NVMe/Virtio)│  │
│  │              │  │              │  │              │  │
│  │  - Linux OS  │  │  - RDMA/RoCE │  │  - crypto    │  │
│  │  - DPDK/App  │  │  - OVS 卸载  │  │  - compress  │  │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  │
│         │                 │                 │          │
│         └────────────┬────┴─────────────┬───┘          │
│                      │                  │              │
│              ┌───────┴───────┐  ┌──────┴───────┐      │
│              │  PCIe Gen4 x16 │  │  DDR4/5 内存  │      │
│              │  主机接口       │  │  8-32GB      │      │
│              └───────────────┘  └───────────────┘      │
│                                                         │
│  ┌──────────────┐  ┌──────────────┐                    │
│  │  硬件安全模块  │  │  Management  │                    │
│  │  (Root of    │  │  Processor   │                    │
│  │   Trust)     │  │  (BMC 兼容)  │                    │
│  └──────────────┘  └──────────────┘                    │
└─────────────────────────────────────────────────────────┘

2.2 关键硬件加速器模块

网络加速器(Network Accelerator):

  • 包解析/分类/重写引擎(Header Parser)
  • 流表匹配引擎(TCAM/MEM 结构)
  • 加密引擎(AES-GCM/ChaCha20,线速处理)
  • 校验和/CRC 卸载引擎
  • 精确时间戳(PTP/gPTP,纳秒级精度)

存储加速器(Storage Accelerator):

  • NVMe 控制器虚拟化(支持数百个 VF)
  • 硬件 RAID/XOR 引擎
  • 压缩/解压(LZ4/ZSTD 硬件实现)
  • 加密引擎(AES-256-XTS 自加密驱动器支持)

DMA 引擎:

  • 多通道 Scatter-Gather DMA
  • 地址转换服务(ATS/PRI 支持)
  • Peer-to-Peer 传输(GPU Direct Storage 支持)

2.3 主机与 DPU 的通信通道

DPU 与主机之间通过多种机制进行通信:

/* 1. PCIe BAR 映射 - 控制通道 */
#define BAR0_CTRL_REG    0x0000    /* 控制寄存器 */
#define BAR1_DB_REG      0x1000    /* 门铃寄存器 (Doorbell) */
#define BAR2_DMA_DESC    0x2000    /* DMA 描述符环 */

/* 2. 共享内存邮箱 (Mailbox) */
struct mbox_msg {
    uint32_t cmd;
    uint32_t flags;
    uint64_t addr;    /* 主机物理地址 */
    uint32_t len;
    uint32_t status;
} __attribute__((packed));

/* 3. VirtIO 半虚拟化队列 */
struct vq_desc {
    uint64_t addr;
    uint32_t len;
    uint16_t flags;
    uint16_t next;
};

三、DPU 软件栈与编程模型

3.1 DOCA:NVIDIA 的 DPU 编程框架

DOCA(Data-center Infrastructure-on-a-Chip Architecture)是 NVIDIA 提供的 DPU 软件开发框架:

┌─────────────────────────────────────────────────────────┐
│                     应用层                                │
│   分布式存储 | NFV | 安全 | AI 推理服务                   │
├─────────────────────────────────────────────────────────┤
│                     DOCA 库层                             │
│                                                         │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │
│  │DOCA Flow│ │DOCA GPUNetIO │ │DOCA RDMA│ │DOCA DMA│   │
│  │(流处理) │ │(GPU直连) │ │(远程访问)│ │(内存拷贝)│    │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐       │
│  │DOCA DPI │ │DOCA RegEx│ │DOCA SSL │ │DOCA Arch │      │
│  │(深度包检)│ │(正则匹配)│ │(TLS卸载)│ │(框架管理)│     │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘       │
├─────────────────────────────────────────────────────────┤
│                     DPDK / Kernel 层                     │
│    Linux内核驱动 | DPDK PMD | SPDK NVMe                  │
├─────────────────────────────────────────────────────────┤
│                     硬件抽象层 (BSP)                      │
│    BlueField SoC | ConnectX 网络适配器 | 加速器             │
└─────────────────────────────────────────────────────────┘

3.2 流处理编程模型:DOCA Flow 实战

DOCA Flow 提供声明式的流匹配API,允许开发者定义数据包处理流水线:

#include <doca_flow.h>

/*
 * 示例:构建 OVS 硬件卸载流水线
 * 功能:将匹配的流引流到 VF,否则送主机
 */

static doca_error_t create_ovs_pipeline(void)
{
    struct doca_flow_port *port;
    struct doca_flow_pipe *pipe;
    struct doca_flow_match match = {0};
    struct doca_flow_actions actions = {0};
    struct doca_flow_monitor monitor = {0};
    struct doca_flow_fwd fwd = {0};
    struct doca_flow_error err = {0};

    /* 1. 初始化端口 */
    doca_flow_port_start(&(struct doca_flow_port_cfg){
        .port_id = 0,
        .port_type = DOCA_FLOW_PORT_DPDK_BY_ID,
        .devargs = "0000:03:00.0",
    }, &port);

    /* 2. 创建基础匹配流 - 按 VLAN + 五元组 */
    match.outer.eth.type = RTE_BE16(RTE_ETHER_TYPE_IPV4);
    match.outer.ipv4.next_proto = IPPROTO_TCP;
    match.outer.l4_type_ext = DOCA_FLOW_L4_TYPE_EXT_TCP;
    match.outer.tcp.src_port = RTE_BE16(80);  /* HTTP */

    /* 3. 定义动作:修改 MAC 并转发到 VF */
    actions.rewrite.src_ip4.s_addr = RTE_IPV4(10, 0, 0, 1);
    actions.rewrite.dst_ip4.s_addr = RTE_IPV4(10, 0, 0, 2);

    /* 4. 配置监控(计数器 + 老化) */
    monitor.counter_type = DOCA_FLOW_RESOURCE_TYPE_SHARED;

    /* 5. 定义转发行为:硬件转发到 VF */
    fwd.type = DOCA_FLOW_FWD_PORT;
    fwd.port_id = 1;  /* VF 端口 */

    /* 6. 创建管道 */
    pipe = doca_flow_pipe_add_default(port,
        &(struct doca_flow_pipe_cfg){
            .attr = {
                .name = "OVS_HTTP_BYPASS",
                .is_root = true,
                .type = DOCA_FLOW_PIPE_BASIC,
                .match = &match,
                .actions = &actions,
                .monitor = &monitor,
                .fwd = &fwd,
            },
        }, NULL, NULL, &err);

    return DOCA_SUCCESS;
}

3.3 DPDK 编程:DPU 上的用户态网络处理

DPU 完全兼容 DPDK,开发者可以直接使用熟悉的 DPDK API:

#include <rte_ethdev.h>
#include <rte_mbuf.h>
#include <rte_eal.h>

/*
 * DPU 上的高性能网络数据包处理示例
 * 说明:DPU 的 ARM 核心 + DPDK 可达 100Gbps 全双工线速
 */

#define RX_RING_SIZE  1024
#define TX_RING_SIZE  1024
#define NUM_MBUFS     8191
#define MBUF_CACHE    250
#define BURST_SIZE    32

struct packet_stats {
    uint64_t rx_packets;
    uint64_t tx_packets;
    uint64_t rx_bytes;
    uint64_t filtered_packets;
    uint64_t hw_offloaded;  /* 硬件卸载计数 */
};

static inline void process_packet(struct rte_mbuf *pkt,
                                   struct packet_stats *stats)
{
    struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(pkt, struct rte_ether_hdr *);
    stats->rx_bytes += pkt->pkt_len;

    /*
     * 在 DPU 上,大部分数据包处理可以通过硬件完成
     * 软件仅需处理"首包"(建立流表规则)
     */
    if (unlikely(pktx_pkt_classify(pkt) == FLOW_TYPE_NEW)) {
        /* 首包处理:建立硬件流表规则 */
        hw_flow_insert(pkt);
        stats->hw_offloaded++;
    }
}

static int pktio_loop(void *arg)
{
    struct packet_stats stats = {0};
    struct rte_mbuf *bufs[BURST_SIZE];
    uint16_t nb_rx, nb_tx;
    uint16_t port_id = *(uint16_t *)arg;

    while (1) {
        /* 批量接收数据包 */
        nb_rx = rte_eth_rx_burst(port_id, 0, bufs, BURST_SIZE);

        if (likely(nb_rx == 0))
            continue;

        stats.rx_packets += nb_rx;

        for (int i = 0; i < nb_rx; i++)
            process_packet(bufs[i], &stats);

        /* 批量发送处理后的数据包 */
        nb_tx = rte_eth_tx_burst(port_id ^ 1, 0, bufs, nb_rx);
        stats->tx_packets += nb_tx;

        /* 释放未发送的 mbuf */
        for (uint16_t i = nb_tx; i < nb_rx; i++)
            rte_pktmbuf_free(bufs[i]);
    }
    return 0;
}

int main(int argc, char *argv[])
{
    /* EAL 初始化 - DPU 上的 ARM 核心 */
    int ret = rte_eal_init(argc, argv);

    uint16_t nb_ports = rte_eth_dev_count_avail();
    printf("Found %u DPU network ports\n", nb_ports);

    /* 配置端口 - 支持多队列 RSS */
    struct rte_eth_conf port_conf = {
        .rxmode = {
            .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
            .mq_mode = ETH_MQ_RX_RSS,
        },
        .rx_adv_conf = {
            .rss_conf = {
                .rss_key = NULL,
                .rss_hf = ETH_RSS_TCP | ETH_RSS_UDP |
                          ETH_RSS_IP,
            },
        },
    };

    for (uint16_t i = 0; i < nb_ports; i++) {
        rte_eth_dev_configure(i, 4, 4, &port_conf); /* 4 RX/TX queues */
        rte_eth_rx_queue_setup(i, 0, RX_RX_RING_SIZE,
                              rte_eth_dev_socket_id(i), NULL, mbuf_pool);
        rte_eth_tx_queue_setup(i, 0, TX_RING_SIZE,
                              rte_eth_dev_socket_id(i), NULL);
        rte_eth_dev_start(i);
    }

    /* 在各 lcore 上启动处理循环 */
    uint16_t port = 0;
    rte_eal_remote_launch(pktio_loop, &port, 1);

    rte_eal_mp_wait_lcore();
    return 0;
}

3.4 安全编程:可信执行环境与加密卸载

DPU 通常集成硬件信任根(Root of Trust),支持安全启动和远程证明:

#include <doca_telemetry.h>
#include <doca_aes_gcm.h>

/*
 * DPU 上的安全数据处理示例
 * 特性:TLS 1.3 完全硬件卸载,密钥不出 DPU
 */

struct secure_channel {
    uint8_t master_secret[48];    /* TLS 1.3 主密钥 */
    uint32_t seq_num;             /* 加密序列数 */
    void *aes_hw_ctx;             /* 硬件加密上下文 */
};

/* 初始化安全通道 - 由 DPU 硬件生成密钥 */
int secure_channel_init(struct secure_channel *ch)
{
    /* 在安全世界里生成随机密钥,主机无法访问 */
    return doca_aes_gcm_create(&ch->aes_hw_ctx,
                                DOCA_AES_GCM_KEY_LEN_256,
                                DOCA_AES_GCM_IV_LEN_12);
}

/* 处理加密流量 - 全程硬件,明文不暴露给主机 */
int process_encrypted_io(struct secure_channel *ch,
                         const void *plaintext,
                         size_t len,
                         void *output)
{
    /* DPU 硬件执行 AES-256-GCM 加密 */
    /* 明文始终在 DPU 的隔离安全内存中 */
    return doca_aes_gcm_encrypt(ch->aes_hw_ctx,
                                 plaintext, len,
                                 output,
                                 NULL,  /* tag */
                                 &ch->seq_num);
}

/* 远程证明:向远程验证者证明 DPU 固件完整性 */
int remote_attestation_report(uint8_t *report, size_t *report_len)
{
    /* 使用 DPU 硬件信任根签名生成证明报告 */
    return doca_telemetry_attestation_report(report, report_len);
}

四、典型应用场景深度解析

4.1 云原生网络:硬件级 OVS 卸载

传统 OVS 在主机 CPU 上运行,每个数据包需要穿越用户态/内核态边界:

传统 OVS 路径(主机 CPU):
  网卡 → 驱动 → 内核 → OVS userspace → 内核 → 网卡
  (约 1500 CPU cycles/packet)

DPU 卸载路径:
  网卡 → DPU 硬件流表 → 内部转发 → 网卡
  (约 50 CPU cycles/packet,且不影响主机 CPU)

实际性能对比测试(BlueField-2 100Gbps):

指标 主机 OVS DPU 卸载 OVS 提升
小包吞吐量 (64B) 25 Mpps 150 Mpps 6x
平均延迟 (64B μs) 15 μs 2.8 μs 5.4x
CPU 开销(万兆) 3-4 核 0 核 ∞
流表容量 受内存限制 硬件 100万+ 10x+

4.2 分布式存储加速:NVMe-oF 端到端卸载

DPU 在存储领域的核心价值是 NVMe over Fabrics 的端到端卸载:

┌─────────────┐         ┌─────────────┐         ┌─────────────┐
│  计算节点    │         │   DPU 网络   │         │  存储节点    │
│  (主机 CPU)  │ ←RDMA→ │   交换层     │ ←RDMA→ │  (NVMe SSD)  │
│             │         │             │         │             │
│  应用直接看到│  RoCEv2 │  DPU 处理    │  RoCEv2 │  本地 NVMe  │
│  远程盘块设备│  零拷贝  │  协议转换    │  零拷贝 │  语义      │
└─────────────┘         └─────────────┘         └─────────────┘
         │                                               │
         └──────────── 数据路径绕过主机 CPU ──────────────┘

编程实现示例(SPDK + DPU 卸载):

#include <spdk/nvme.h>
#include <spdk/env.h>

/*
 * DPU 上的 SPDK NVMe-oF 目标端
 * 提供远程块存储服务,完全绕过主机 CPU
 */

static void attach_controller(struct spdk_nvme_ctrlr *ctrlr)
{
    struct spdk_nvme_ns *ns = spdk_nvme_ctrlr_get_ns(ctrlr, 1);
    uint64_t sector_size = spdk_nvme_ns_get_sector_size(ns);
    uint64_t num_sectors = spdk_nvme_ns_get_num_sectors(ns);

    printf("Attaching NVMe SSD on DPU\n");
    printf("  Capacity: %.2f GB\n",
           (double)(num_sectors * sector_size) / (1ULL << 30));

    /* 在 DPU 上创建子系统并暴露给主机 */
    create_nvmf_subsystem("nqn.2024-01.com.vendor:dpu-ssd-0",
                          ctrlr, ns);
}

static int bdev_offload_init(void)
{
    /* SPDK 环境初始化 - 在 DPU ARM 核心上运行 */
    struct spdk_env_opts opts = {};
    spdk_env_init(&opts);

    /* 扫描 NVMe 设备(DPU 直连的 PCIe SSD) */
    spdk_nvme_probe(NULL, NULL,
                    attach_controller,   /* 探测回调 */
                    NULL, NULL);

    /* 设置 NVMe-oF 传输层 (RDMA) */
    start_nvmf_target(&(struct spdk_nvmf_target_opts){
        .name = "DPU Storage Target",
        .max_subsystems = 128,
        .acceptor_poll_rate = 10000,  /* 10 μs 轮询周期 */
    });

    return 0;
}

4.3 安全与合规:硬件级微隔离

DPU 可以实现零信任架构中的"微分段"(Micro-segmentation),且不影响主机 CPU:

                     ┌─────────────────────────────┐
                     │        DPU 安全引擎         │
     主机 A          │  ┌─────────────────────┐    │
     ┌───┐   ┌────┐ │  │   L4-L7 防火墙     │    │
     │App│←──│VF_A│←─→ │   - ACL 规则匹配     │    │
     └───┘   └────┘ │  │   - TLS 拦截/重加密   │    │
                    │  │   - DPI 深度包检测    │    │
     主机 B          │  │   - 流量镜像/审计     │    │
     ┌───┐   ┌────┐ │  └─────────────────────┘    │
     │App│←──│VF_B│←─→                             │
     └───┘   └────┘ │  安全策略由 DPU 管理         │
                     │  主机 CPU 无法绕过             │
                     └─────────────────────────────┘

4.4 AI 推理:GPUDirect 全速数据传输

在 AI 训练中,DPU 通过 GPUDirect RDMA 实现 GPU-to-GPU 直传:

传统数据路径(100GB 模型加载):
  SSD → 主机 CPU 内存 → PCIe → GPU 内存   延迟:~30 秒
  GPU → 主机 CPU 内存 → 网卡 → 远端 GPU   带宽:~25 Gbps

DPU 卸载路径(GPUDirect):
  SSD → DPU → GPU 内存  (GDS GPUDirect Storage)
  本地 GPU → 网卡 → 远端 GPU (GPUDirect RDMA)   带宽:200 Gbps+

五、DPU 编程挑战与最佳实践

5.1 调试复杂性

DPU 编程面临独特的调试挑战:

挑战 原因 解决方案
跨域调试 DPU 运行独立 Linux,主机难窥视 DPU TRIAGE: 统一日志聚合
时序问题 硬件加速路径难以插入探针 使用 DPU 流计数器 + 硬件镜像
流表不同步 软件规则 vs 硬件规则状态分离 定期一致性校验 + 状态快照
内存泄漏 DPU 有限的 DDR 内存(8-32GB) 使用 DOCA 内存跟踪器

5.2 性能优化要点

/*
 * DPU 编程关键优化技巧
 */

/* 1. 使用页对齐内存 - 充分利用 DMA 带宽 */
void *buf = rte_malloc(NULL, BUF_SIZE, 2 * 1024 * 1024); /* 2MB 大页 */

/* 2. 批量操作减少 PCIe 事务 */
#define BATCH_SIZE 64  /* DPU 最佳突发长度 */

/* 3. 利用硬件原子操作 - 避免软件锁 */
rte_atomic32_inc(&hw_stats->flow_miss);

/* 4. 数据预取 - 隐藏内存延迟 */
rte_prefetch0(next_desc);

/* 5. 控制跨域流量 - 减少主机<DPU 通信 */
/* 首包上 CPU,后续包硬件快速路径 */

5.3 架构设计建议

┌─────────────────────────────────────────────────────────────┐
│                   DPU 应用设计黄金原则                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ① 首包慢路径 + 快路径劫持                                    │
│     - 首包走 ARM CPU 处理,建立流规则                          │
│     - 匹配流直接硬件转发(不经过 CPU)                          │
│                                                             │
│  ② 控制平面在 DPU,数据平面在硬件                               │
│     - 状态管理、规则编排使用 ARM                                │
│     - 高速数据流转由固定功能硬件处理                            │
│                                                             │
│  ③ 隔离优先:DPU 是比主机更安全的信任域                         │
│     - 密钥、证书、策略存 DPU 安全存储                           │
│     - 即使主机被入侵,DPU 可强制执行安全策略                    │
│                                                             │
│  ④ 渐进式卸载:不要试图卸载一切                                 │
│     - 先卸载 OVS 网络虚拟化                                     │
│     - 再卸载存储协议栈                                          │
│     - 最后卸载安全功能                                          │
│                                                             │
│  ⑤ 可观测性先行:部署前务必建立完整监控                         │
│     - 硬件计数器:每流丢包/计数                                 │
│     - DPU 资源:CPU/内存/PCIe 带宽                              │
│     - 主机视角:延迟/吞吐/CPU 利用率                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

六、未来展望:从 DPU 到 Infrastructure-on-a-Chip

6.1 技术演进趋势

2023-2024 (现在)              2025-2026                 2027+
──────────────────────       ──────────────────────   ──────────────────────
BlueField-3 / IPU C5000x      BlueField-4 / IPU C7000   DPU+ 第三代
- 100Gbps                  - 200-400Gbps              - 800Gbps+ 每端口
- 首包 CPU 处理             - AI 推理引擎集成          - 自学习流分类
- 部分功能卸载              - 完全无状态卸载            - 自治基础设施
- DOCA 1.x                 - DOCA 2.x                 - DOCA/InfrastructureOS

6.2 RISC-V:DPU 架构的下一个变量

新一代 DPU 开始采用 RISC-V 作为控制平面核心:

  • 开放指令集:避免 ARM 授权限制和出口管制
  • 自定义扩展:可以添加特定领域的指令(NVMe 命令处理、加密原语)
  • 定制 SoC:厂商可以裁剪 CPU 数量、定制加速器接口
  • 开源软件栈:自由度高,不受制于特定厂商的 BSP

6.3 DPU 对系统架构的深远影响

对谁的影响 变化
云服务商 基础设施变为 "黑盒",客户只看到计算/存储/网络资源
开发者 从 "管理服务器" 到 "消费算力",看不见底层基础设施
运维 基础设施监控下移到 DPU,运维工具链需要更新
安全 信任边界从主机下移到 DPU 硬件信任根
硬件 服务器形态变化:DPU 成为必选项而非可选项

七、总结

DPU 不是简单的 "更快的网卡",而是一场数据中心架构范式的转变。它代表了一种思路:将基础设施功能下沉到专用芯片,让通用处理器聚焦于业务价值创造。

对于工程师而言,掌握 DPU 编程意味着:

  1. 理解硬件卸载的边界:哪些可以卸载,哪些必须由 CPU 处理
  2. 掌握 DPDK/DOCA 工具链:它们是与 DPU 硬件对话的语言
  3. 设计软硬件协同架构:首包软件 + 快路径硬件的黄金组合
  4. 拥抱安全默认的理念:DPU 天然提供了隔离执行环境

DPU 的成熟将使"无基础设施感知"(Infrastructure-Agnostic)的计算成为可能,而理解并驾驭这一变革的工程师,将在下一代云计算平台建设中占据先机。


参考资料:NVIDIA DOCA SDK Documentation、DPDK Programming Guide、Linux Kernel Documentation/driver-api/dpu、Marvell OCTEON SDK、Broadcom Stingray Developer Guide

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部