网络数据包的处理一般是由内核网络协议栈完成。但是，对于要极高吞吐量和低延迟的应用，内核的上下文切换、中断处理以及数据拷贝等开销会成为性能瓶颈。

把网络数据处理从内核空间转移到用户空间

。DPDK 接管网卡 (NIC) ，绕过内核，直接从网卡接收原始数据包。应用程序自行实现协议栈的解析和封装逻辑。DPDK 也提供了一套丰富的 API 完成这些底层操作。

一个完整的 UDP 数据包在网络传输中是分层封装的。从最外层到内层：

：属于数据链路层，共 14 字节。

    6 bytes      6 bytes   2 bytes
+------------+------------+--------+
|  SMAC      |   DMAC     |  Type  |
+------------+------------+--------+

：属于网络层，对于 IPv4 ，标准头部长度是 20 字节（不包含可选字段）。包括数据包的路由信息。

DPDK 应用程序直接访问这些原始数据包的内存地址，利用 DPDK 提供的 API 进行字段的读取、修改和校验，实现高效的协议解析和封装。

DPDK相比NIC，它可以最大程度的使用网卡的性能。DPDK 的设计目标是最大限度榨取网卡的性能潜力。

所以，DPDK可以使网卡性能最大，而NIC不可以的原因：NIC不支持huge page，以4K的页利用中断的方式触发接收数据，数据传输时需要CPU参与拷贝，这是比不上DPDK的。

普通 NIC不支持巨页，主要使用 4KB 大小的标准内存页。所以操作系统在进行内存管理时产生大量的 TLB (Translation Lookaside Buffer) 缓存未命中，增加内存访问开销。而DPDK 全面支持巨页，最高可支持 1GB 或 2MB 的大内存页。使用巨页可以显著减少 TLB 未命中次数，提高内存访问效率，并减少页表查找的开销，从而提升数据包处理的整体性能。

配置 DPDK 主要是导出环境变量和运行配置脚本。

cd dpdk路径
# 如 dpdk/dpdk-stable-19.08.2/
# 切换roo权限
sudo su 
exp    RTE_SDK=dpdk路径
export RTE_TARGET=x86_64-native-linux-gcc

43（加载DPDK UIO 模块，即插入driver）

44（加载VFIO模块，也是一种driver）

45（加载KNI模块，将一些数据写回内核）

46（设置巨页，可以不需要频繁页交换，512）

49（执行之前需要eth0 down掉，执行sudo ifconfig eth0 down，使绑定dpdk）pci地址=对应eth0的（如0000:03:00.0）

这样的 DPDK 环境就基本准备就绪，可以编译和运行 DPDK 应用程序了。

Windows 环境下，出于测试或特定网络配置需求，要手动添加静态 ARP (Address Resolution Protocol) 条目。需要管理员权限才可以操作。

（1）查看要加入的静态表接口。

示例结果如下，可以看到0x13这个位置，后面步骤用到。

接口: 192.168.2.130 --- 0x13
  Internet 地址         物理地址              类型
  192.168.0.20          00-17-16-07-b1-14     动态
  192.168.0.25          00-00-74-f8-0f-65     动态
  192.168.0.60          00-1e-67-6e-d4-c8     动态
  192.168.0.62          00-15-5d-00-29-01     动态
  192.168.3.166         2c-56-dc-dc-d5-45     动态
  192.168.4.191         d8-5e-d3-20-7a-53     动态
  192.168.5.0           18-c0-4d-9b-65-fb     动态
  192.168.7.31          fc-aa-14-a2-e7-4a     动态
  192.168.7.98          18-c0-4d-de-dd-be     动态
  192.168.7.146         00-0c-29-39-a8-c4     动态
  192.168.7.234         18-c0-4d-cc-b7-da     动态
  192.168.7.248         d4-5d-64-d2-b7-23     动态
  192.168.7.253         50-81-40-f3-ed-90     动态
  192.168.8.1           70-8c-b6-ee-02-12     动态
  192.168.20.188        e4-e7-49-ff-f0-9c     动态
  192.168.255.255       ff-ff-ff-ff-ff-ff     静态
  224.0.0.2             01-00-5e-00-00-02     静态
  224.0.0.22            01-00-5e-00-00-16     静态
  224.0.0.251           01-00-5e-00-00-fb     静态
  224.0.0.252           01-00-5e-00-00-fc     静态
  224.0.1.60            01-00-5e-00-01-3c     静态
  239.193.3.64          01-00-5e-41-03-40     静态
  239.193.4.69          01-00-5e-41-04-45     静态

Idx     Met         MTU          状态                名称
---  ----------  ----------  ------------  ---------------------------
  1          75  4294967295  connected     Loopback Pseudo-Interface 1
 19          35        1500  connected     以太网 2
  5          35        1500  connected     VMware Network Adapter VMnet1
 15          35        1500  connected     VMware Network Adapter VMnet8
 39          35        1500  connected     VMware Network Adapter VMnet2

可以看到，上面的0x13=19对应的网络接口是以太网。

netsh -c i i add neighbors 19 192.168.7.199 38-d5-47-1c-5c-fb

（4）检查是否添加成功。认新添加的静态 ARP 条目要出现在列表中，并且类型显示为“静态”。

（5）如果需要清除静态表，执行：

netsh i i delete neighbors 接口号
# 比如18就是接口号

一个基于 DPDK 实现的简单 UDP 协议栈。接收到的 UDP 数据包内容原样封装并发送回源地址。

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

#include <stdio.h>
#include <arpa/inet.h>


#define ENABLE_SEND	1

#define NUM_MBUFS (4096-1)

#define BURST_SIZE	32

int gDpdkPortId = 0; //

static const struct rte_eth_conf port_conf_default = {
	.rxmode = {.max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};


#if ENABLE_SEND

// sender 
static uint32_t gSrcIp;
static uint32_t gDstIp;

static uint16_t gSrcPort;
static uint32_t gDstPort;

static uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];
static uint8_t gDstMac[RTE_ETHER_ADDR_LEN];


#endif

//
static void ng_init_port(struct rte_mempool *mbuf_pool) {

	//1 count avail
	uint16_t nb_sys_ports= rte_eth_dev_count_avail(); //
	if (nb_sys_ports == 0) {
		rte_exit(EXIT_FAILURE, "No Supported eth found\n");
	}

	//1 
	struct rte_eth_dev_info dev_info;
	rte_eth_dev_info_get(gDpdkPortId, &dev_info); //

	//1 
	const int num_rx_queues = 1;
	const int num_tx_queues = 1;
	struct rte_eth_conf port_conf = port_conf_default;
	rte_eth_dev_configure(gDpdkPortId, num_rx_queues, num_tx_queues, &port_conf);

	//1 rx queue setup
	if (rte_eth_rx_queue_setup(gDpdkPortId, 0 , 1024, rte_eth_dev_socket_id(gDpdkPortId),NULL, mbuf_pool) < 0) {

		rte_exit(EXIT_FAILURE, "Could not setup RX queue\n");

	}

#if ENABLE_SEND
	struct rte_eth_txconf txq_conf = dev_info.default_txconf;
	txq_conf.offloads = port_conf.rxmode.offloads;
	if (rte_eth_tx_queue_setup(gDpdkPortId, 0 , 1024, 
		rte_eth_dev_socket_id(gDpdkPortId), &txq_conf) < 0) {

		rte_exit(EXIT_FAILURE, "Could not setup TX queue\n");

	}

#endif

	//1 start
	if (rte_eth_dev_start(gDpdkPortId) < 0 ) {
		rte_exit(EXIT_FAILURE, "Could not start\n");
	}

	rte_eth_promiscuous_enable( gDpdkPortId);

}


#if ENABLE_SEND

static int ng_encode_udp_pkt(uint8_t *msg, unsigned char *data, uint16_t total_len) {

	// encode 

	// 1 ethhdr
	struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
	rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
	rte_memcpy(eth->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
	eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
	

	// 2 iphdr 
	struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(msg + sizeof(struct rte_ether_hdr));
	ip->version_ihl = 0x45;
	ip->type_of_service = 0;
	ip->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
	ip->packet_id = 0;
	ip->fragment_offset = 0;
	ip->time_to_live = 64; // ttl = 64
	ip->next_proto_id = IPPROTO_UDP;
	ip->src_addr = gSrcIp;
	ip->dst_addr = gDstIp;
	
	ip->hdr_checksum = 0;
	ip->hdr_checksum = rte_ipv4_cksum(ip);

	// 3 udphdr 

	struct rte_udp_hdr *udp = (struct rte_udp_hdr *)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
	udp->src_port = gSrcPort;
	udp->dst_port = gDstPort;
	uint16_t udplen = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
	udp->dgram_len = htons(udplen);

	rte_memcpy((uint8_t*)(udp+1), data, udplen);

	udp->dgram_cksum = 0;
	udp->dgram_cksum = rte_ipv4_udptcp_cksum(ip, udp);

	struct in_addr addr;
	addr.s_addr = gSrcIp;
	printf(" --> src: %s:%d, ", inet_ntoa(addr), ntohs(gSrcPort));

	addr.s_addr = gDstIp;
	printf("dst: %s:%d\n", inet_ntoa(addr), ntohs(gDstPort));

	return 0;
}


static struct rte_mbuf * ng_send(struct rte_mempool *mbuf_pool, uint8_t *data, uint16_t length) {

	// mempool --> mbuf

	const unsigned total_len = length + 42;

	struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
	if (!mbuf) {
		rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc\n");
	}
	mbuf->pkt_len = total_len;
	mbuf->data_len = total_len;

	uint8_t *pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);

	ng_encode_udp_pkt(pktdata, data, total_len);

	return mbuf;

}



#endif

int main(int argc, char *argv[]) {

	if (rte_eal_init(argc, argv) < 0) {
		rte_exit(EXIT_FAILURE, "Error with EAL init\n");
		
	}

	struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("mbuf pool", NUM_MBUFS,
		0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
	if (mbuf_pool == NULL) {
		rte_exit(EXIT_FAILURE, "Could not create mbuf pool\n");
	}

	ng_init_port(mbuf_pool);

	while (1) {

		struct rte_mbuf *mbufs[BURST_SIZE];
		unsigned num_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
		if (num_recvd > BURST_SIZE) {
			rte_exit(EXIT_FAILURE, "Error receiving from eth\n");
		}

		unsigned i = 0;
		for (i = 0;i < num_recvd;i ++) {

			struct rte_ether_hdr *ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr*);
			if (ehdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
				continue;
			}

			struct rte_ipv4_hdr *iphdr =  rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr *, 
				sizeof(struct rte_ether_hdr));
			
			if (iphdr->next_proto_id == IPPROTO_UDP) {

				struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);

#if ENABLE_SEND		// echo

				// mac exchange
				rte_memcpy(gDstMac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
				rte_memcpy(gSrcMac, ehdr->d_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
				// ip exchange

				rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
				rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
				// port exchange

				rte_memcpy(&gSrcPort, &udphdr->dst_port, sizeof(uint16_t));
				rte_memcpy(&gDstPort, &udphdr->src_port, sizeof(uint16_t));
				

#endif

				uint16_t length = ntohs(udphdr->dgram_len);
				*((char*)udphdr + length) = '\0';

				struct in_addr addr;
				addr.s_addr = iphdr->src_addr;
				printf("src: %s:%d, ", inet_ntoa(addr), udphdr->src_port);

				addr.s_addr = iphdr->dst_addr;
				printf("dst: %s:%d, %s\n", inet_ntoa(addr), udphdr->src_port, 
					(char *)(udphdr+1));

#if ENABLE_SEND

				struct rte_mbuf *txbuf = ng_send(mbuf_pool, (unsigned char*)(udphdr+1), length);
				rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);

#endif

				rte_pktmbuf_free(mbufs[i]);
			} else {

			}
			
		}

	}

}

支持两种编译模式：共享库链接和静态库链接，并用 

 简化 DPDK 库的查找和链接过程。

# binary name
APP = dpdk_udp

# all source are stored in SRCS-y
SRCS-y := dpdk_udp.c

# Build using pkg-config variables if possible
ifeq ($(shell pkg-config --exists libdpdk && echo 0),0)

all: shared
.PHONY: shared static
shared: build/$(APP)-shared
        ln -sf $(APP)-shared build/$(APP)
static: build/$(APP)-static
        ln -sf $(APP)-static build/$(APP)

PKGCONF=pkg-config --define-prefix

PC_FILE := $(shell $(PKGCONF) --path libdpdk)
CFLAGS += -O3 $(shell $(PKGCONF) --cflags libdpdk)
LDFLAGS_SHARED = $(shell $(PKGCONF) --libs libdpdk)
LDFLAGS_STATIC = -Wl,-Bstatic $(shell $(PKGCONF) --static --libs libdpdk)

build/$(APP)-shared: $(SRCS-y) Makefile $(PC_FILE) | build
        $(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_SHARED)

build/$(APP)-static: $(SRCS-y) Makefile $(PC_FILE) | build
        $(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS) $(LDFLAGS_STATIC)

build:
        @mkdir -p $@

.PHONY: clean
clean:
        rm -f build/$(APP) build/$(APP)-static build/$(APP)-shared
        test -d build && rmdir -p build || true

else

ifeq ($(RTE_SDK),)
$(error "Please define RTE_SDK environment variable")
endif

# Default target, detect a build directory, by looking for a path with a .config
RTE_TARGET ?= $(notdir $(abspath $(dir $(firstword $(wildcard $(RTE_SDK)/*/.config)))))

include $(RTE_SDK)/mk/rte.vars.mk

DPDK 主要为高性能网络应用提供极致的吞吐量和低延迟。

DPDK 高性能网络数据处理：原理、配置与实践

这篇文章探讨 DPDK 在高性能网络数据处理中的应用。DPDK 通过绕过内核网络栈的开销，直接、高效处理网络数据包，最大限度地发挥网卡的硬件性能。这篇文章从背景知识、与传统 NIC 的对比、环境配置、Windows 静态 IP 表配置，到具体的代码实现进行详细阐述。

编程语言

前端

DPDK技术详解：高性能网络数据包处理方案，通过用户空间直接访问网卡数据，绕过内核协议栈提升性能。支持巨页内存减少TLB未命中，实现零拷贝传输，适用于高吞吐低延迟场景。包含UDP协议栈实现、环境配置指南及Windows静态IP表操作，帮助开发者构建高效网络应用。

内存管理

大数据

编译器

Windows

路由

AI驱动 智领未来

bigdata-class

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

DPDK 高性能网络数据处理：原理、配置与实践

DPDK 高性能网络数据处理：原理、配置与实践

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐