1
# 查看当前大页配置
2
cat /proc/meminfo | grep Huge
3
# 输出示例：
4
# AnonHugePages:         0 kB
5
# ShmemHugePages:        0 kB
6
# HugePages_Total:    1024       # 总大页数量
7
# HugePages_Free:     1024       # 空闲大页数量
8
# HugePages_Rsvd:        0       # 已预留但未分配的大页
9
# HugePages_Surp:        0       # 超额分配的大页
10
# Hugepagesize:       2048 kB    # 大页大小（2MB）
11
# Hugetlb:          2097152 kB   # 大页总内存
12

13
# 查看各 NUMA 节点的大页分布
14
cat /sys/devices/system/node/node*/meminfo | grep Huge
15
# Node 0 HugePages_Total: 512
16
# Node 1 HugePages_Total: 512

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

4
# 在 NUMA 节点 0 上分配 512 个大页
5
echo 512 | sudo tee /sys/devices/system/node/node0/hugepages/hugepages-2048kB/nr_hugepages
6

7
# 在 NUMA 节点 1 上分配 512 个大页
8
echo 512 | sudo tee /sys/devices/system/node/node1/hugepages/hugepages-2048kB/nr_hugepages

1
# 在 GRUB 配置中添加内核参数
2
# /etc/default/grub:
3
GRUB_CMDLINE_LINUX="default_hugepagesz=2M hugepagesz=2M hugepages=2048"
4

5
# 更新 GRUB 并重启
6
sudo update-grub
7
sudo reboot

1
# 1GB 大页必须在启动时预留，运行时分配几乎必然失败（内存碎片化）
2
# /etc/default/grub:
3
GRUB_CMDLINE_LINUX="default_hugepagesz=1G hugepagesz=1G hugepages=4 hugepagesz=2M hugepages=512"
4

5
# 这会预留 4 个 1GB 大页 + 512 个 2MB 大页
6
# 1GB 大页用于 DPDK 内存，2MB 大页用于其他用途
7
sudo update-grub
8
sudo reboot

1
# 创建挂载点
2
sudo mkdir -p /dev/hugepages
3

4
# 挂载 hugetlbfs
5
sudo mount -t hugetlbfs nodev /dev/hugepages
6

7
# 验证挂载
8
mount | grep huge
9
# 输出：nodev on /dev/hugepages type hugetlbfs (rw,relatime,pagesize=2M)
10

11
# 查看大页文件系统中的映射文件
12
ls -la /dev/hugepages/
13
# DPDK 应用运行后，这里会出现映射文件：
14
# -r-------- 1 root root 2097152 Apr 21 10:00 rte_mempool_0
15
# -r-------- 1 root root 2097152 Apr 21 10:00 rte_ring_0

1
// 从 mempool 获取一个对象
2
void *obj;
3
int ret = rte_mempool_get(mp, &obj);
4
if (ret < 0) {
5
    // 获取失败，mempool 已耗尽
6
}

1
// 将对象归还到 mempool
2
rte_mempool_put(mp, obj);

1
// 批量获取对象
2
void *objs[BURST_SIZE];
3
unsigned int n = rte_mempool_get_bulk(mp, objs, BURST_SIZE);
4

5
// 批量释放对象
6
rte_mempool_put_bulk(mp, objs, n);

1
#include <rte_mempool.h>
2
#include <rte_mbuf.h>
3
#include <rte_eal.h>
4
#include <rte_errno.h>
5

6
#define NB_MBUF     8192    /* 内存池中 mbuf 的数量 */
7
#define MBUF_CACHE_SIZE 512 /* Per-lcore 缓存大小 */
8
#define MBUF_SIZE   2048    /* 每个 mbuf 的数据区大小 */
9
#define MAX_PKT_BURST 32    /* 每次收包的最大数量 */
10

11
/* 创建 mbuf 内存池 */
12
static struct rte_mempool *
13
create_mbuf_pool(uint16_t portid, unsigned int socket_id)
14
{
15
    char pool_name[64];
16
    snprintf(pool_name, sizeof(pool_name), "mbuf_pool_%u", portid);
17

18
    struct rte_mempool *mp = rte_pktmbuf_pool_create(
19
        pool_name,           /* 内存池名称 */
20
        NB_MBUF,             /* mbuf 总数 */
21
        MBUF_CACHE_SIZE,     /* Per-lcore 缓存大小 */
22
        0,                   /* 私有数据大小 */
23
        MBUF_SIZE,           /* 每个 mbuf 数据区大小 */
24
        socket_id            /* NUMA 节点 ID */
25
    );
26

27
    if (mp == NULL) {
28
        rte_exit(EXIT_FAILURE,
29
                 "Cannot create mbuf pool: %s\n",
30
                 rte_strerror(rte_errno));
31
    }
32

33
    return mp;
34
}
35

36
/* 使用内存池分配和释放 mbuf */
37
static void
38
mempool_usage_example(struct rte_mempool *mp)
39
{
40
    struct rte_mbuf *bufs[MAX_PKT_BURST];
41

42
    /* 批量分配 mbuf */
43
    int ret = rte_pktmbuf_alloc_bulk(mp, bufs, MAX_PKT_BURST);
44
    if (ret != 0) {
45
        printf("Failed to allocate mbufs from pool\n");
46
        return;
47
    }
48

49
    /* 使用 mbuf 处理数据包... */
50
    for (int i = 0; i < MAX_PKT_BURST; i++) {
51
        /* 在 mbuf 数据区写入数据 */
52
        char *data = rte_pktmbuf_mtod(bufs[i], char *);
53
        /* ... 业务逻辑 ... */
54
    }
55

56
    /* 批量释放 mbuf */
57
    rte_pktmbuf_free_bulk(bufs, MAX_PKT_BURST);
58
}

1
/* 将 mempool 的详细信息输出到日志 */
2
rte_mempool_dump(stdout, mp);
3

4
/* 输出示例：
5
 * mempool<"mbuf_pool_0">@0x7f0000000000
6
 *   flags=0x0
7
 *   pool config=0x0
8
 *   pool name=mbuf_pool_0
9
 *   pool ptr=0x7f0000000000
10
 *   pool physaddr=0x100000000
11
 *   nb_obj=8192
12
 *   obj_size=2304
13
 *   elt_size=2176
14
 *   header_size=128
15
 *   trailer_size=0
16
 *   total_elts=8192
17
 *   available_count=7680
18
 *   cache[0]: len=512, flush_count=0, prev=0, next=0
19
 *   cache[1]: len=0, flush_count=0, prev=0, next=0
20
 */

1
# 使用 dpdk-procinfo 工具查看运行中 DPDK 应用的 mempool 状态
2
dpdk-procinfo -- -p 0x3 --stats

1
// lib/mbuf/rte_mbuf.h — 简化版 rte_mbuf 结构体
2
struct rte_mbuf {
3
    /* ===== 第一个缓存行（64 字节）：最频繁访问的字段 ===== */
4
    void *buf_addr;           /* 数据缓冲区的虚拟地址 */
5
    uint64_t buf_iova;        /* 数据缓冲区的 IOVA 地址（用于 DMA） */
6
    uint16_t data_off;        /* 数据起始偏移（从 buf_addr 开始） */
7
    uint16_t data_len;        /* 当前分段的数据长度 */
8
    uint32_t pkt_len;         /* 整个包的总长度（所有分段之和） */
9
    uint16_t port;            /* 接收/发送端口 ID */
10
    uint16_t nb_segs;         /* 分段数量 */
11
    rte_atomic16_t refcnt;    /* 引用计数 */
12
    uint32_t ol_flags;        /* 卸载标志（校验和、TSO、VXLAN 等） */
13

14
    /* ===== 第二个缓存行（64 字节）：次频繁访问的字段 ===== */
15
    struct rte_mbuf *next;    /* 下一个分段指针（jumbo frame 链表） */
16
    struct rte_mempool *pool; /* 所属的内存池 */
17
    struct rte_mbuf *nextpkt; /* 同一队列中下一个 mbuf（用于批量操作） */
18
    uint16_t vlan_tci;        /* VLAN TCI（Tag Control Information） */
19
    uint32_t rss;             /* RSS 哈希值 */
20
    uint16_t hash;            /* 哈希值（替代 rss） */
21
    /* ... 更多字段（时间戳、seqn 等） */
22
};

1
/* Prepend 操作：在包前面添加 4 字节 VLAN 标签 */
2
char *vlan_tag = rte_pktmbuf_prepend(mbuf, 4);
3
if (vlan_tag != NULL) {
4
    /* 在 vlan_tag 位置写入 VLAN 标签数据 */
5
    /* data_off 减小了 4，data_len 增加了 4 */
6
    /* 整个包的数据没有被拷贝！ */
7
}
8

9
/* Strip 操作：去掉包前面的 14 字节以太网头 */
10
char *eth_hdr = rte_pktmbuf_adj(mbuf, 14);
11
if (eth_hdr != NULL) {
12
    /* eth_hdr 指向被去掉的以太网头 */
13
    /* data_off 增加了 14，data_len 减少了 14 */
14
    /* 同样没有数据拷贝！ */
15
}

1
/* 遍历分段链 */
2
struct rte_mbuf *seg = mbuf;
3
while (seg != NULL) {
4
    /* 处理当前分段的数据 */
5
    void *data = rte_pktmbuf_mtod(seg, void *);
6
    uint16_t len = seg->data_len;
7

8
    /* ... 业务逻辑 ... */
9

10
    seg = seg->next;
11
}
12

13
/* 获取分段链的总长度 */
14
uint32_t total_len = mbuf->pkt_len;  /* 只在首段有效 */
15

16
/* 获取分段数量 */
17
uint16_t num_segs = mbuf->nb_segs;   /* 只在首段有效 */

1
/* ===== 分配与释放 ===== */
2

3
/* 从内存池分配一个 mbuf */
4
struct rte_mbuf *m = rte_pktmbuf_alloc(mp);
5

6
/* 批量分配 mbuf */
7
struct rte_mbuf *bufs[32];
8
int ret = rte_pktmbuf_alloc_bulk(mp, bufs, 32);
9

10
/* 释放一个 mbuf（如果是分段链，释放所有分段） */
11
rte_pktmbuf_free(m);
12

13
/* 批量释放 mbuf */
14
rte_pktmbuf_free_bulk(bufs, 32);
15

16
/* ===== 数据访问 ===== */
17

18
/* 获取数据区指针（带类型转换） */
19
struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
20

21
/* 获取数据区末尾指针（用于 append） */
22
char *tail = rte_pktmbuf_mtod_offset(m, char *, m->data_len);
23

24
/* ===== 数据操作 ===== */
25

26
/* Prepend：在数据前面添加 len 字节空间 */
27
char *ptr = rte_pktmbuf_prepend(m, len);
28

29
/* Append：在数据末尾添加 len 字节空间 */
30
char *ptr = rte_pktmbuf_append(m, len);
31

32
/* Adj（Strip）：从数据前面移除 len 字节 */
33
char *ptr = rte_pktmbuf_adj(m, len);
34

35
/* Trim：从数据末尾移除 len 字节 */
36
int ret = rte_pktmbuf_trim(m, len);
37

38
/* ===== 引用计数 ===== */
39

40
/* 增加引用计数（用于零拷贝共享） */
41
rte_pktmbuf_refcnt_update(m, 1);
42

43
/* 减少引用计数（归零时自动释放） */
44
rte_pktmbuf_refcnt_update(m, -1);
45

46
/* 克隆 mbuf（共享数据缓冲区，增加引用计数） */
47
struct rte_mbuf *clone = rte_pktmbuf_clone(m, mp);

1
/* 在当前 NUMA 节点上分配路由表 */
2
struct route_entry *routes = rte_malloc("route_table",
3
    sizeof(struct route_entry) * MAX_ROUTES, 0);
4
if (routes == NULL) {
5
    rte_exit(EXIT_FAILURE, "Failed to allocate route table\n");
6
}
7

8
/* 分配并清零 */
9
struct stats_counter *stats = rte_zmalloc("stats",
10
    sizeof(struct stats_counter), RTE_CACHE_LINE_SIZE);
11

12
/* 在指定 NUMA 节点上分配 */
13
struct hash_table *ht = rte_malloc_socket("hash_table",
14
    sizeof(struct hash_table), 0, rte_socket_id());
15

16
/* 释放 */
17
rte_free(routes);
18
rte_free(stats);
19
rte_free(ht);

1
# 查看 NUMA 拓扑
2
numactl --hardware
3
# 输出示例（双路服务器）：
4
# available: 2 nodes (0-1)
5
# node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
6
# node 0 size: 32768 MB
7
# node 1 cpus: 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
8
# node 1 size: 32768 MB
9
# node 0 distance: 10 21
10
# node 1 distance: 21 10

1
/* 获取当前 lcore 所在的 NUMA 节点 ID */
2
unsigned int socket_id = rte_socket_id();
3

4
/* 在当前 NUMA 节点上创建 mempool */
5
struct rte_mempool *mp = rte_pktmbuf_pool_create("mbuf_pool",
6
    NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE, socket_id);
7

8
/* 在当前 NUMA 节点上分配内存 */
9
void *buf = rte_malloc_socket("my_buf", size, 0, socket_id);

1
/* 正确做法：lcore 和内存池在同一 NUMA 节点 */
2
static int
3
lcore_main(void *arg)
4
{
5
    unsigned lcore_id = rte_lcore_id();
6
    unsigned socket_id = rte_socket_id();
7

8
    /* 获取与当前 lcore 同节点的内存池 */
9
    struct rte_mempool *mp = mempools[socket_id];
10

11
    /* 收包循环 */
12
    while (!force_quit) {
13
        struct rte_mbuf *bufs[BURST_SIZE];
14
        uint16_t nb_rx = rte_eth_rx_burst(port_id, queue_id, bufs, BURST_SIZE);
15
        /* ... 处理 ... */
16
        rte_pktmbuf_free_bulk(bufs, nb_rx);
17
    }
18
    return 0;
19
}

1
/* 错误：所有 lcore 共享一个内存池，可能跨节点访问 */
2
struct rte_mempool *shared_mp = rte_pktmbuf_pool_create("shared_pool",
3
    NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE, 0);  /* 只在节点 0 分配 */
4

5
/* lcore 8-15 在节点 1 上运行，但访问节点 0 的内存池 */
6
/* 每次分配/释放 mbuf 都要跨节点访问，性能下降 30%~50% */

1
#define MAX_NUMA_NODES 8
2

3
struct rte_mempool *mempools[MAX_NUMA_NODES];
4

5
/* 为每个 NUMA 节点创建独立的内存池 */
6
for (int i = 0; i < rte_socket_count(); i++) {
7
    int socket_id = rte_socket_id_by_idx(i);
8
    char name[64];
9
    snprintf(name, sizeof(name), "mbuf_pool_%d", socket_id);
10

11
    mempools[socket_id] = rte_pktmbuf_pool_create(name,
12
        NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE, socket_id);
13

14
    if (mempools[socket_id] == NULL) {
15
        rte_exit(EXIT_FAILURE,
16
                 "Cannot create mbuf pool on socket %d\n", socket_id);
17
    }
18
}

1
struct rte_memzone {
2
    char name[RTE_MEMZONE_NAMESIZE]; /* memzone 名称 */
3
    const void *addr;                 /* 虚拟地址 */
4
    uint64_t io_addr;                 /* IOVA 地址 */
5
    size_t len;                       /* 长度 */
6
    int socket_id;                    /* NUMA 节点 ID */
7
    uint32_t flags;                   /* 标志位 */
8
};

1
/* 为网卡接收描述符环预留物理连续内存 */
2
const struct rte_memzone *rx_ring_mz = rte_memzone_reserve_aligned(
3
    "rx_ring_0",
4
    ring_size * sizeof(struct rte_rx_desc),
5
    rte_socket_id(),
6
    0,                    /* 无特殊标志 */
7
    4096                  /* 4KB 对齐 */
8
);
9

10
if (rx_ring_mz == NULL) {
11
    rte_exit(EXIT_FAILURE, "Cannot reserve RX ring memzone\n");
12
}
13

14
/* 获取虚拟地址和 IOVA 地址 */
15
void *ring_vaddr = rx_ring_mz->addr;        /* CPU 访问用 */
16
uint64_t ring_iova = rx_ring_mz->io_addr;   /* 网卡 DMA 用 */

1
/* 查询当前 IOVA 模式 */
2
enum rte_iova_mode iova_mode = rte_eal_iova_mode();
3

4
switch (iova_mode) {
5
    case RTE_IOVA_PA:
6
        printf("IOVA mode: PA (Physical Address)\n");
7
        break;
8
    case RTE_IOVA_VA:
9
        printf("IOVA mode: VA (Virtual Address)\n");
10
        break;
11
    default:
12
        printf("IOVA mode: Unknown\n");
13
        break;
14
}

1
# 在 EAL 参数中指定 IOVA 模式
2
sudo ./dpdk_app -l 0-3 -n 4 --iova-mode=pa  # 强制 PA 模式
3
sudo ./dpdk_app -l 0-3 -n 4 --iova-mode=va  # 强制 VA 模式
4

5
# 查看 EAL 初始化日志中的 IOVA 模式
6
# 输出中会包含：
7
# EAL: Selected IOVA mode 'PA'
8
# 或
9
# EAL: Selected IOVA mode 'VA'

1
/* 虚拟地址 → IOVA 地址 */
2
rte_iova_t iova = rte_mem_virt2iova(addr);
3

4
/* IOVA 地址 → 虚拟地址（需要 memzone 或 memseg 信息） */
5
void *addr = rte_mem_iova2virt(iova);
6

7
/* mbuf 的 IOVA 地址（最常用） */
8
rte_iova_t mbuf_iova = rte_mbuf_data_iova(m);  /* 等价于 m->buf_iova + m->data_off */

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
cat /proc/meminfo | grep Huge
9
# 预期输出：
10
# HugePages_Total:    1024
11
# HugePages_Free:     1024
12
# Hugepagesize:       2048 kB
13

14
# 第四步：查看各 NUMA 节点的大页分布
15
for node in /sys/devices/system/node/node*/hugepages/hugepages-2048kB/nr_hugepages; do
16
    echo "$node: $(cat $node)"
17
done
18

19
# 第五步：挂载 hugetlbfs
20
sudo mkdir -p /dev/hugepages
21
sudo mount -t hugetlbfs nodev /dev/hugepages
22

23
# 第六步：尝试分配 1GB 大页（可能失败）
24
echo 1 | sudo tee /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages
25
# 如果输出 "write error: Cannot allocate memory"，说明内存碎片化导致无法分配
26
# 需要在启动时通过内核参数预留
27

28
# 第七步：清理（释放大页）
29
echo 0 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

1
/* mempool_inspect.c — 创建并检查 mempool */
2
#include <stdio.h>
3
#include <rte_eal.h>
4
#include <rte_mempool.h>
5
#include <rte_mbuf.h>
6

7
#define NB_MBUF         4096
8
#define MBUF_CACHE_SIZE 256
9
#define MBUF_SIZE       2048
10

11
int main(int argc, char *argv[])
12
{
13
    int ret = rte_eal_init(argc, argv);
14
    if (ret < 0)
15
        return -1;
16

17
    /* 创建 mbuf 内存池 */
18
    struct rte_mempool *mp = rte_pktmbuf_pool_create(
19
        "test_pool", NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
20
        rte_socket_id());
21

22
    if (mp == NULL) {
23
        printf("Failed to create mempool: %s\n", rte_strerror(rte_errno));
24
        return -1;
25
    }
26

27
    /* 输出 mempool 详细信息 */
28
    printf("=== mempool dump ===\n");
29
    rte_mempool_dump(stdout, mp);
30

31
    /* 分配一些 mbuf，观察缓存变化 */
32
    struct rte_mbuf *bufs[64];
33
    rte_pktmbuf_alloc_bulk(mp, bufs, 32);
34

35
    printf("\n=== after allocating 32 mbufs ===\n");
36
    rte_mempool_dump(stdout, mp);
37

38
    /* 释放 mbuf，观察缓存恢复 */
39
    rte_pktmbuf_free_bulk(bufs, 32);
40

41
    printf("\n=== after freeing 32 mbufs ===\n");
42
    rte_mempool_dump(stdout, mp);
43

44
    rte_eal_cleanup();
45
    return 0;
46
}

1
# 编译
2
gcc -o mempool_inspect mempool_inspect.c $(pkg-config --cflags --libs libdpdk)
3

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

1
/* mbuf_inspect.c — 检查 mbuf 结构体布局 */
2
#include <stdio.h>
3
#include <stddef.h>
4
#include <rte_eal.h>
5
#include <rte_mempool.h>
6
#include <rte_mbuf.h>
7

8
#define NB_MBUF         1024
9
#define MBUF_CACHE_SIZE 128
10
#define MBUF_SIZE       2048
11

12
int main(int argc, char *argv[])
13
{
14
    int ret = rte_eal_init(argc, argv);
15
    if (ret < 0)
16
        return -1;
17

18
    struct rte_mempool *mp = rte_pktmbuf_pool_create(
19
        "mbuf_test", NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
20
        rte_socket_id());
21

22
    /* 分配一个 mbuf */
23
    struct rte_mbuf *m = rte_pktmbuf_alloc(mp);
24

25
    /* 打印 mbuf 关键字段的偏移和值 */
26
    printf("=== rte_mbuf field layout ===\n");
27
    printf("sizeof(struct rte_mbuf) = %zu\n", sizeof(struct rte_mbuf));
28
    printf("offsetof(buf_addr)  = %3zu  value = %p\n",
29
           offsetof(struct rte_mbuf, buf_addr), m->buf_addr);
30
    printf("offsetof(buf_iova)  = %3zu  value = 0x%lx\n",
31
           offsetof(struct rte_mbuf, buf_iova), (unsigned long)m->buf_iova);
32
    printf("offsetof(data_off)  = %3zu  value = %u\n",
33
           offsetof(struct rte_mbuf, data_off), m->data_off);
34
    printf("offsetof(data_len)  = %3zu  value = %u\n",
35
           offsetof(struct rte_mbuf, data_len), m->data_len);
36
    printf("offsetof(pkt_len)   = %3zu  value = %u\n",
37
           offsetof(struct rte_mbuf, pkt_len), m->pkt_len);
38
    printf("offsetof(nb_segs)   = %3zu  value = %u\n",
39
           offsetof(struct rte_mbuf, nb_segs), m->nb_segs);
40
    printf("offsetof(port)      = %3zu  value = %u\n",
41
           offsetof(struct rte_mbuf, port), m->port);
42
    printf("offsetof(refcnt)    = %3zu  value = %u\n",
43
           offsetof(struct rte_mbuf, refcnt), rte_atomic16_read(&m->refcnt));
44
    printf("offsetof(ol_flags)  = %3zu  value = 0x%x\n",
45
           offsetof(struct rte_mbuf, ol_flags), m->ol_flags);
46

47
    /* 检查 headroom 大小 */
48
    printf("\n=== headroom info ===\n");
49
    printf("data_off (headroom size) = %u\n", m->data_off);
50
    printf("RTE_PKTMBUF_HEADROOM    = %u\n", RTE_PKTMBUF_HEADROOM);
51
    printf("buf_addr                = %p\n", m->buf_addr);
52
    printf("data pointer            = %p\n", rte_pktmbuf_mtod(m, void *));
53

54
    /* 测试 prepend 和 append */
55
    printf("\n=== prepend/append test ===\n");
56
    char *p = rte_pktmbuf_prepend(m, 14);  /* 添加以太网头空间 */
57
    printf("After prepend(14): data_off=%u, data_len=%u\n",
58
           m->data_off, m->data_len);
59

60
    p = rte_pktmbuf_append(m, 100);  /* 添加 100 字节 payload 空间 */
61
    printf("After append(100): data_off=%u, data_len=%u\n",
62
           m->data_off, m->data_len);
63

64
    rte_pktmbuf_free(m);
65
    rte_eal_cleanup();
66
    return 0;
67
}

1
# 第一步：查看 NUMA 拓扑
2
numactl --hardware
3

4
# 第二步：使用 numactl 测量本地 vs 远端内存访问延迟
5
# 在节点 0 上分配内存，从节点 0 访问（本地）
6
numactl --cpunodebind=0 --membind=0 ./latency_test
7

8
# 在节点 0 上分配内存，从节点 1 访问（远端）
9
numactl --cpunodebind=1 --membind=0 ./latency_test
10

11
# 第三步：使用 DPDK 测量跨节点 mempool 访问性能
12
# 以下 C 代码演示了本地 vs 远端 mempool 的分配延迟差异

1
/* numa_latency.c — 测量本地 vs 远端 mempool 分配延迟 */
2
#include <stdio.h>
3
#include <rte_eal.h>
4
#include <rte_mempool.h>
5
#include <rte_mbuf.h>
6
#include <rte_cycles.h>
7

8
#define NB_MBUF         8192
9
#define MBUF_CACHE_SIZE 512
10
#define MBUF_SIZE       2048
11
#define ITERATIONS      1000000
12

13
static void
14
measure_mempool_latency(struct rte_mempool *mp, const char *desc)
15
{
16
    struct rte_mbuf *m;
17
    uint64_t start, end, total_cycles = 0;
18
    unsigned int i;
19

20
    /* 预热缓存 */
21
    for (i = 0; i < 100; i++) {
22
        m = rte_pktmbuf_alloc(mp);
23
        rte_pktmbuf_free(m);
24
    }
25

26
    /* 测量分配延迟 */
27
    for (i = 0; i < ITERATIONS; i++) {
28
        start = rte_rdtsc();
29
        m = rte_pktmbuf_alloc(mp);
30
        end = rte_rdtsc();
31
        total_cycles += (end - start);
32
        rte_pktmbuf_free(m);
33
    }
34

35
    double avg_ns = (double)total_cycles / ITERATIONS
36
                    * 1000000000.0 / rte_get_tsc_hz();
37
    printf("%s: avg alloc latency = %.2f ns (%.1f cycles)\n",
38
           desc, avg_ns, (double)total_cycles / ITERATIONS);
39
}
40

41
int main(int argc, char *argv[])
42
{
43
    int ret = rte_eal_init(argc, argv);
44
    if (ret < 0)
45
        return -1;
46

47
    unsigned int socket_id = rte_socket_id();
48

49
    /* 在本地 NUMA 节点创建 mempool */
50
    struct rte_mempool *local_mp = rte_pktmbuf_pool_create(
51
        "local_pool", NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE, socket_id);
52

53
    /* 在远端 NUMA 节点创建 mempool（如果有多个节点） */
54
    int remote_socket = (socket_id == 0) ? 1 : 0;
55
    struct rte_mempool *remote_mp = rte_pktmbuf_pool_create(
56
        "remote_pool", NB_MBUF, MBUF_CACHE_SIZE, 0, MBUF_SIZE, remote_socket);
57

58
    if (local_mp)
59
        measure_mempool_latency(local_mp, "Local NUMA");
60
    if (remote_mp)
61
        measure_mempool_latency(remote_mp, "Remote NUMA");
62

63
    rte_eal_cleanup();
64
    return 0;
65
}

1
# 编译
2
gcc -o numa_latency numa_latency.c $(pkg-config --cflags --libs libdpdk)
3

4
# 在 NUMA 节点 0 上运行
5
sudo numactl --cpunodebind=0 ./numa_latency -l 0 -n 4
6

7
# 预期输出：
8
# Local NUMA:  avg alloc latency = 15.23 ns (45.7 cycles)
9
# Remote NUMA: avg alloc latency = 28.67 ns (86.0 cycles)
10
# 远端比本地慢约 1.5~2 倍