1
// 典型的 rte_eal_init 调用
2
int ret = rte_eal_init(argc, argv);
3
if (ret < 0) {
4
    rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
5
}

1
# 查看系统当前大页配置
2
cat /proc/meminfo | grep Huge
3

4
# 分配 1024 个 2MB 大页（共 2GB）
5
echo 1024 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
6

7
# 挂载大页文件系统
8
sudo mkdir -p /dev/hugepages
9
sudo mount -t hugetlbfs nodev /dev/hugepages

1
// 从网卡接收队列批量获取数据包
2
uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, rx_pkts, burst_size);
3

4
// 向网卡发送队列批量发送数据包
5
uint16_t nb_tx = rte_eth_tx_burst(port_id, queue_id, tx_pkts, nb_pkts);

1
while (!force_quit) {
2
    // 轮询接收
3
    uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, mbufs, BURST_SIZE);
4

5
    if (nb_rx == 0)
6
        continue;  // 没有包，继续轮询
7

8
    // 处理收到的包
9
    for (uint16_t i = 0; i < nb_rx; i++) {
10
        // 业务逻辑处理...
11
        rte_pktmbuf_free(mbufs[i]);  // 处理完毕，释放 mbuf
12
    }
13
}

1
// 创建环形队列
2
struct rte_ring *ring = rte_ring_create("my_ring", 1024,
3
    rte_socket_id(), RING_F_SP_ENQ | RING_F_SC_DEQ);  // SPSC 模式
4

5
// 入队
6
void *obj = mbuf;
7
rte_ring_enqueue(ring, obj);
8

9
// 批量入队
10
void *objs[BURST_SIZE];
11
unsigned int n = rte_ring_enqueue_bulk(ring, objs, BURST_SIZE, NULL);
12

13
// 出队
14
void *dequeued_obj;
15
rte_ring_dequeue(ring, &dequeued_obj);
16

17
// 批量出队
18
void *dequeued_objs[BURST_SIZE];
19
unsigned int n = rte_ring_dequeue_burst(ring, dequeued_objs, BURST_SIZE, NULL);

1
// rte_mbuf 的核心字段（简化版）
2
struct rte_mbuf {
3
    void *buf_addr;           /* 数据缓冲区地址 */
4
    uint16_t data_off;        /* 数据起始偏移 */
5
    uint16_t data_len;        /* 数据长度 */
6
    uint32_t pkt_len;         /* 整个包的长度（含分段） */
7
    uint16_t port;            /* 接收端口 ID */
8
    uint32_t ol_flags;        /* 卸载标志（校验和、TSO 等） */
9
    struct rte_mbuf *next;    /* 下一个分段（jumbo frame） */
10
    uint16_t nb_segs;         /* 分段数量 */
11
    rte_atomic16_t refcnt;    /* 引用计数 */
12
    /* ... 更多字段 */
13
};

1
# 使用 -l 0,2,4,6 启动 DPDK 应用
2
# 映射关系：
3
#   lcore 0 → CPU 核 0（Master lcore）
4
#   lcore 1 → CPU 核 2（Worker lcore）
5
#   lcore 2 → CPU 核 4（Worker lcore）
6
#   lcore 3 → CPU 核 6（Worker lcore）

1
// 获取当前 lcore 的 ID
2
unsigned lcore_id = rte_lcore_id();
3

4
// 获取当前 lcore 对应的物理 CPU 核 ID
5
unsigned cpu_id = rte_lcore_to_cpu_id(lcore_id);
6

7
// 获取下一个可用的 worker lcore ID
8
unsigned next_lcore = rte_get_next_lcore(lcore_id, 1, 0);

1
// 任务函数原型
2
typedef int (*lcore_function_t)(void *);
3

4
// 在所有 worker lcore 上启动 lcore_main 函数
5
rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MASTER);
6

7
// 等待所有 lcore 完成
8
rte_eal_mp_wait_lcore();

1
# 项目定义
2
project('dpdk_helloworld', 'c',
3
    version: '1.0.0',
4
    default_options: ['c_std=c11']
5
)
6

7
# 查找 DPDK 依赖
8
dpdk = dependency('libdpdk', required: true)
9

10
# 构建可执行文件
11
executable('dpdk_helloworld',
12
    sources: 'main.c',
13
    dependencies: [dpdk]
14
)

1
# 1. 配置构建目录（Meson 要求在单独的构建目录中构建）
2
meson setup build
3

4
# 2. 编译
5
ninja -C build
6

7
# 3. 运行
8
sudo ./build/dpdk_helloworld -l 0-3 -n 4
9

10
# 4. 安装 DPDK（如果从源码编译 DPDK 本身）
11
meson setup build -Dexamples=all
12
ninja -C build
13
sudo ninja -C build install
14
sudo ldconfig

1
# 查看所有可用选项
2
meson configure build
3

4
# 常用选项示例
5
meson setup build \
6
    -Dmax_lcores=128 \           # 最大 lcore 数
7
    -Dmax_numa_nodes=8 \         # 最大 NUMA 节点数
8
    -Denable_kmods=true \        # 编译内核模块
9
    -Dexamples=l2fwd,l3fwd \    # 编译指定示例
10
    -Dplatform=generic           # 目标平台

1
/* SPDX-License-Identifier: BSD-3-Clause
2
 * DPDK Hello World 示例
3
 * 功能：在每个 lcore 上打印 "Hello World" 消息
4
 */
5

6
#include <stdio.h>
7
#include <stdlib.h>
8
#include <string.h>
9
#include <stdint.h>
10
#include <inttypes.h>
11
#include <unistd.h>
12

13
#include <rte_eal.h>
14
#include <rte_lcore.h>
15
#include <rte_debug.h>
16

17
/**
18
 * lcore_main - 每个 worker lcore 执行的函数
19
 *
20
 * @param arg: 传入的参数（本例中未使用）
21
 * @return: 0 表示正常退出
22
 *
23
 * 每个 lcore 会打印自己的 lcore ID 和对应的物理 CPU 核 ID，
24
 * 然后进入一个短暂的循环以演示 lcore 的独立性
25
 */
26
static int
27
lcore_main(__rte_unused void *arg)
28
{
29
    unsigned lcore_id = rte_lcore_id();
30
    unsigned cpu_id = rte_lcore_to_cpu_id(lcore_id);
31

32
    printf("Hello from lcore %u (CPU core %u)\n", lcore_id, cpu_id);
33

34
    return 0;
35
}
36

37
/**
38
 * main - 程序入口
39
 *
40
 * DPDK 应用的标准启动流程：
41
 * 1. 调用 rte_eal_init() 初始化 EAL
42
 * 2. 在 worker lcore 上启动任务函数
43
 * 3. 等待所有 lcore 完成
44
 * 4. 清理 EAL 资源
45
 */
46
int
47
main(int argc, char *argv[])
48
{
49
    int ret;
50

51
    /* ========================================
52
     * 第一步：初始化 EAL
53
     * ========================================
54
     * rte_eal_init() 会解析 EAL 参数（如 -l, -n 等），
55
     * 完成大页内存映射、PCI 设备扫描、lcore 线程启动等工作。
56
     * 返回值是去掉 EAL 参数后剩余的参数个数。
57
     */
58
    ret = rte_eal_init(argc, argv);
59
    if (ret < 0) {
60
        rte_exit(EXIT_FAILURE, "Error with EAL initialization.\n");
61
    }
62

63
    /* 调整 argc 和 argv，跳过 EAL 已处理的参数 */
64
    argc -= ret;
65
    argv += ret;
66

67
    /* ========================================
68
     * 第二步：检查可用的 lcore 数量
69
     * ========================================
70
     * rte_lcore_count() 返回已启用的 lcore 总数。
71
     * 至少需要 1 个 lcore 才能运行。
72
     */
73
    unsigned lcore_count = rte_lcore_count();
74
    if (lcore_count == 0) {
75
        rte_exit(EXIT_FAILURE, "No lcores available.\n");
76
    }
77

78
    printf("DPDK Hello World: %u lcore(s) available\n", lcore_count);
79

80
    /* ========================================
81
     * 第三步：在所有 worker lcore 上启动任务
82
     * ========================================
83
     * rte_eal_mp_remote_launch() 会在每个 worker lcore 上
84
     * 执行 lcore_main 函数。
85
     *
86
     * SKIP_MASTER 表示 Master lcore 不执行 lcore_main，
87
     * 而是继续执行后面的代码。
88
     */
89
    rte_eal_mp_remote_launch(lcore_main, NULL, SKIP_MASTER);
90

91
    /* ========================================
92
     * 第四步：Master lcore 也执行任务
93
     * ========================================
94
     * 虽然使用了 SKIP_MASTER，但 Master lcore
95
     * 也可以手动调用 lcore_main 来执行相同的逻辑。
96
     */
97
    lcore_main(NULL);
98

99
    /* ========================================
100
     * 第五步：等待所有 worker lcore 完成
101
     * ========================================
102
     * rte_eal_mp_wait_lcore() 会阻塞等待所有
103
     * worker lcore 上的函数执行完毕。
104
     */
105
    rte_eal_mp_wait_lcore();
106

107
    /* ========================================
108
     * 第六步：清理 EAL 资源
109
     * ========================================
110
     * rte_eal_cleanup() 释放 EAL 分配的资源，
111
     * 包括共享内存、文件描述符等。
112
     */
113
    ret = rte_eal_cleanup();
114
    if (ret != 0) {
115
        fprintf(stderr, "EAL cleanup failed: %d\n", ret);
116
    }
117

118
    printf("DPDK Hello World completed.\n");
119

120
    return 0;
121
}

1
dpdk_helloworld/
2
├── main.c
3
└── meson.build

1
project('dpdk_helloworld', 'c',
2
    version: '1.0.0',
3
    default_options: ['c_std=c11']
4
)
5

6
dpdk = dependency('libdpdk', required: true)
7

8
executable('dpdk_helloworld',
9
    sources: 'main.c',
10
    dependencies: [dpdk]
11
)

1
# 配置构建
2
meson setup build
3

4
# 编译
5
ninja -C build
6

7
# 运行（需要 root 权限以访问大页和网卡）
8
sudo ./build/dpdk_helloworld -l 0-3 -n 4

1
EAL: Detected 8 lcore(s)
2
EAL: Detected 1 NUMA nodes
3
EAL: Multi-process socket /var/run/dpdk/rte/mp_socket
4
EAL: Selected IOVA mode 'PA'
5
EAL: Probing VFIO support...
6
DPDK Hello World: 4 lcore(s) available
7
Hello from lcore 0 (CPU core 0)
8
Hello from lcore 1 (CPU core 1)
9
Hello from lcore 2 (CPU core 2)
10
Hello from lcore 3 (CPU core 3)
11
DPDK Hello World completed.

1
# 单文件编译（快速测试）
2
gcc -o dpdk_helloworld main.c $(pkg-config --cflags --libs libdpdk)
3

4
# 运行
5
sudo ./dpdk_helloworld -l 0-3 -n 4

1
# 第一步：安装 DPDK 开发包
2
# Ubuntu/Debian
3
sudo apt update
4
sudo apt install -y dpdk dpdk-dev meson ninja-build pkg-config
5

6
# CentOS/RHEL
7
sudo yum install -y dpdk dpdk-devel meson ninja-build pkgconfig
8

9
# 第二步：验证 DPDK 安装
10
pkg-config --modversion libdpdk
11
# 预期输出：22.11.x 或更高版本
12

13
# 第三步：配置大页内存
14
# 分配 1024 个 2MB 大页（共 2GB）
15
echo 1024 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
16

17
# 第四步：验证大页分配
18
cat /proc/meminfo | grep Huge
19
# 预期输出：
20
# AnonHugePages:         0 kB
21
# ShmemHugePages:        0 kB
22
# HugePages_Total:    1024
23
# HugePages_Free:     1024
24
# HugePages_Rsvd:        0
25
# HugePages_Surp:        0
26
# Hugepagesize:       2048 kB
27

28
# 第五步：挂载大页文件系统
29
sudo mkdir -p /dev/hugepages
30
sudo mount -t hugetlbfs nodev /dev/hugepages
31

32
# 验证挂载
33
mount | grep huge
34
# 预期输出：nodev on /dev/hugepages type hugetlbfs (...)

1
# 第一步：创建项目目录
2
mkdir -p ~/dpdk_helloworld && cd ~/dpdk_helloworld
3

4
# 第二步：创建 main.c（使用上面第九节的完整源码）
5
# 将上面的完整源码保存为 main.c
6

7
# 第三步：创建 meson.build
8
cat > meson.build << 'EOF'
9
project('dpdk_helloworld', 'c',
10
    version: '1.0.0',
11
    default_options: ['c_std=c11']
12
)
13

14
dpdk = dependency('libdpdk', required: true)
15

16
executable('dpdk_helloworld',
17
    sources: 'main.c',
18
    dependencies: [dpdk]
19
)
20
EOF
21

22
# 第四步：编译
23
meson setup build
24
ninja -C build
25

26
# 第五步：运行
27
sudo ./build/dpdk_helloworld -l 0-3 -n 4
28

29
# 第六步：尝试不同的 lcore 配置
30
# 只使用核 0 和核 2
31
sudo ./build/dpdk_helloworld -l 0,2 -n 4
32

33
# 使用核掩码
34
sudo ./build/dpdk_helloworld -c 0x5 -n 4
35
# 0x5 = 二进制 101 = 核 0 和核 2

1
# 第一步：查找 DPDK 示例程序
2
# 如果从源码编译 DPDK，示例在源码目录的 examples/ 下
3
# 如果通过包管理器安装，示例可能在 /usr/share/dpdk/examples/ 下
4

5
# 第二步：编译 l2fwd（从源码编译时）
6
# 假设 DPDK 源码在 ~/dpdk
7
cd ~/dpdk/examples/l2fwd
8
meson setup build
9
ninja -C build
10

11
# 第三步：绑定网卡到 DPDK
12
# 首先查看当前网卡驱动
13
dpdk-devbind.py --status
14

15
# 将网卡从内核驱动解绑，绑定到 VFIO
16
# 注意：这会断开该网卡的 SSH 连接！请确保有其他管理口
17
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.0
18
sudo dpdk-devbind.py --bind=vfio-pci 0000:01:00.1
19

20
# 第四步：运行 l2fwd
21
sudo ./build/l2fwd -l 0-3 -n 4 -- -p 0x3 -T 1
22
# -l 0-3: 使用核 0-3
23
# -n 4: 4 个内存通道
24
# --: EAL 参数结束
25
# -p 0x3: 使用端口 0 和端口 1
26
# -T 1: 每秒打印一次统计信息
27

28
# 第五步：观察输出
29
# l2fwd 会定期打印收发包统计：
30
# Port 0: RX - 1234567 packets, TX - 1234500 packets
31
# Port 1: RX - 1234400 packets, TX - 1234467 packets

1
# 查看 DPDK 使用的大页内存
2
cat /proc/meminfo | grep Huge
3

4
# 查看大页文件系统中的映射文件
5
ls -la /dev/hugepages/
6

7
# 查看 DPDK 进程的内存映射
8
sudo cat /proc/$(pgrep dpdk_helloworld)/maps | grep huge
9

10
# 查看 DPDK 进程的 CPU 亲和性
11
taskset -pc $(pgrep dpdk_helloworld)
12

13
# 查看 DPDK 进程的线程与 CPU 核绑定关系
14
ps -T -p $(pgrep dpdk_helloworld) -o pid,tid,comm