随着云计算规模持续扩张,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 编程意味着:
- 理解硬件卸载的边界:哪些可以卸载,哪些必须由 CPU 处理
- 掌握 DPDK/DOCA 工具链:它们是与 DPU 硬件对话的语言
- 设计软硬件协同架构:首包软件 + 快路径硬件的黄金组合
- 拥抱安全默认的理念:DPU 天然提供了隔离执行环境
DPU 的成熟将使"无基础设施感知"(Infrastructure-Agnostic)的计算成为可能,而理解并驾驭这一变革的工程师,将在下一代云计算平台建设中占据先机。
参考资料:NVIDIA DOCA SDK Documentation、DPDK Programming Guide、Linux Kernel Documentation/driver-api/dpu、Marvell OCTEON SDK、Broadcom Stingray Developer Guide

发表评论 取消回复