第23周：DPDK 性能分析

字数统计: 1.9k字   |   阅读时长≈ 9分

第23周：DPDK 性能分析

目标：掌握 DPDK 程序性能分析方法，能够定位和消除性能瓶颈。

1. 性能分析基础

1.1 性能指标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
关键指标：

吞吐（Throughput）：
  PPS = 每秒处理包数（Packets Per Second）
  BPS = 每秒处理字节数（Bytes Per Second）
  线速 = 接口理论最大值（如 10GbE = 14.88 Mpps @ 64B）

延迟（Latency）：
  转发延迟 = 收包时间 → 发包时间（纳秒级）
  典型值：100ns ~ 1μs（DPDK），100μs ~ 1ms（内核）

抖动（Jitter）：
  延迟的方差
  P99 latency = 99% 的包延迟低于此值

CPU 占用：
  单 lcore 占用百分比
  每 PPS 消耗的 CPU cycles

丢包率：
  missed（RX 缓冲区满）
  no_mbuf（mbuf 不足）
  dropped（应用处理不过来）

1.2 分析流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
性能调优流程：

1. 基准测试
   - 运行 testpmd 确定硬件上限
   - 确认 NIC 能跑满线速

2. 瓶颈定位
   - PPS 低？ → CPU 不够？burst 太小？
   - 延迟高？ → 缓存 miss？锁竞争？
   - 丢包？ → 哪里满了？

3. 热点分析
   - perf 找热点函数
   - 缓存 miss 分析
   - 分支预测失败

4. 优化
   - 调整参数（burst size, desc 数量）
   - 改进算法（减少分支、预取）
   - 内存优化（对齐、 NUMA）

5. 回归测试
   - 对比优化前后

2. perf 分析

2.1 基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# === CPU 性能分析 ===

# 采样热点（函数级）
perf stat -e cycles,instructions,cache-misses,cache-references \
    -a -- sleep 5

# 带 PID 分析
perf stat -p $(pidof testpmd) -- sleep 5

# 详细统计
perf stat -d -p $(pidof testpmd) -- sleep 5

# === 调用图分析 ===

perf record -g -p $(pidof testpmd) -- sleep 5
perf report

# === 火焰图生成 ===

# 1. 记录
perf record -g -F 99 -p $(pidof testpmd) -- sleep 10

# 2. 生成报告
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > dpdk_flame.svg

# 安装火焰图工具
# git clone https://github.com/brendangregg/FlameGraph

2.2 DPDK 专用分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# === 分析特定函数 ===

# 找出最耗时的函数
perf record -g -e cycles:u -p $(pidof testpmd) -- sleep 5
perf report | grep -E "rte_|do_something|main"

# 期望看到的顶部函数（DPDK 转发循环）：
# rte_eth_rx_burst      — 收包
# rte_eth_tx_burst      — 发包
# rte_pktmbuf_alloc     — 分配 mbuf
# rte_pktmbuf_free      — 释放 mbuf
# [你的处理函数]        — 包处理逻辑

# === 缓存分析 ===

perf stat -e cache-misses,cache-references,L1-dcache-load-misses \
          -p $(pidof testpmd) -- sleep 5

# 期望值（转发密集型）：
# cache-misses < 5%   — 好
# L1-dcache-load-misses < 3%  — 好

# === 分支预测 ===

perf stat -e branch-misses,branches -p $(pidof testpmd) -- sleep 5
# branch-misses < 1% — 好

3. rte_rdtsc 计时

3.1 TSC 计时器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <rte_cycles.h>

// 读取 TSC（Time Stamp Counter）
uint64_t tsc = rte_rdtsc();

// 获取 TSC 频率（Hz）
uint64_t hz = rte_get_timer_hz();

// 等待指定纳秒
rte_delay_us(100);  // 100 微秒

// 精确计时
uint64_t start = rte_rdtsc();
do_something();
uint64_t end = rte_rdtsc();

double elapsed_ns = (double)(end - start) * 1e9 / hz;
printf("do_something took %.2f ns\n", elapsed_ns);

3.2 关键路径计时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
// latency_stats.c — 测量转发延迟
struct latency_stats {
    uint64_t min;
    uint64_t max;
    uint64_t total;
    uint64_t count;
    uint64_t hist[32];  // 直方图（2^n 纳秒）
};

static struct latency_stats g_latency;

void measure_latency(struct rte_mbuf *m) {
    // 获取包的时间戳（可以从 mbuf 中带的时间戳获取）
    // 这里简化：测量处理时间
    uint64_t start = rte_rdtsc();
    uint64_t hz = rte_get_timer_hz();

    process_packet(m);

    uint64_t end = rte_rdtsc();
    uint64_t delta = end - start;
    double ns = (double)delta * 1e9 / hz;

    // 更新统计
    if (g_latency.count == 0 || delta < g_latency.min)
        g_latency.min = delta;
    if (delta > g_latency.max)
        g_latency.max = delta;
    g_latency.total += delta;
    g_latency.count++;

    // 直方图（log scale）
    int bucket = 0;
    while (bucket < 31 && delta > (1ULL << bucket))
        bucket++;
    g_latency.hist[bucket]++;
}

void print_latency_stats(void) {
    uint64_t hz = rte_get_timer_hz();
    double avg_ns = (double)g_latency.total / g_latency.count * 1e9 / hz;
    double min_ns = (double)g_latency.min * 1e9 / hz;
    double max_ns = (double)g_latency.max * 1e9 / hz;

    printf("Latency: min=%.0f ns, avg=%.0f ns, max=%.0f ns (%lu samples)\n",
           min_ns, avg_ns, max_ns, g_latency.count);

    printf("Histogram:\n");
    for (int i = 0; i < 32; i++) {
        if (g_latency.hist[i] > 0) {
            printf("  < %d ns: %lu\n", 1 << i, g_latency.hist[i]);
        }
    }
}

4. 火焰图

4.1 CPU 火焰图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
火焰图解读：

  │            │
  │  ┌──────┐  │     ← 顶层：总 CPU 时间
  │  │ func │  │
  │  │  ┌─┐ │  │     ← 中间：调用栈
  │  │  │b│ │  │
  │  │  └─┘ │  │     ← 底层：具体指令
  │  └──────┘  │

y 轴：调用栈深度（越深 = 越底层的函数）
x 轴：CPU 时间（越宽 = 占用越多）

生成火焰图：
  1. perf record 采集调用栈
  2. perf script 导出
  3. stackcollapse-perf.pl 折叠
  4. flamegraph.pl 生成 SVG

查找热点：
  - 最宽的柱子 = 最耗 CPU 的函数
  - 长调用链 = 深的函数调用
  - 异常宽的底层函数 = 可能有问题

4.2 生成火焰图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 1. 采集（需要 root，采集所有 CPU）
sudo perf record -g -F 99 -a -- sleep 10

# 2. 导出
sudo perf script > out.perf

# 3. 折叠
./stackcollapse-perf.pl < out.perf > out.folded

# 4. 生成 SVG（on-cpu 火焰图）
./flamegraph.pl < out.folded > dpdk_oncpu.svg

# off-CPU 火焰图（等待/阻塞时间）
sudo perf record -g -e sched:sched_switch -a -- sleep 10
sudo perf script > offcpu.perf
./stackcollapse-perf.pl < offcpu.perf > offcpu.folded
./flamegraph.pl --bg=orange --color=io < offcpu.folded > dpdk_offcpu.svg

# 查看
firefox dpdk_oncpu.svg

4.3 解读 DPDK 火焰图

1
2
3
4
5
6
7
8
9
10
11
12
好的火焰图特征：

rte_eth_rx_burst ████████   ← 这是正常的
rte_eth_tx_burst ████       ← 正常
my_process     ██████       ← 你的处理逻辑
[others]       ██           ← 其他开销小

有问题的火焰图：

rte_spinlock_lock ████████████████████████  ← 锁竞争严重！
malloc          ██████████████████████      ← malloc 太多！
printf          ████████████████            ← 打印太多！

5. 缓存优化

5.1 缓存 miss 分析

1
2
3
4
5
6
7
8
9
10
11
12
# 使用 perf 分析缓存 miss
perf stat -e L1-dcache-load-misses,L1-dcache-loads,L1-dcache-load-misses-rate \
          -p $(pidof testpmd) -- sleep 5

# 使用 perf cache 子命令
perf cache stat -p $(pidof testpmd) -- sleep 5

# 使用 valgrind --tool=cachegrind（用户态）
valgrind --tool=cachegrind ./my_fwd -l 2-7 --socket-mem 1024

# 使用 Intel VTune（更详细）
# amplxe-cl -collect hotspots -target-duration-type=short -r ./vtune_result ./my_fwd

5.2 缓存优化策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 1. 数据对齐（cache line 对齐）
struct __rte_cache_aligned my_struct {
    uint32_t counter;
    char pad[RTE_CACHE_LINE_SIZE];  // 填充到 64 bytes
};

// 2. 避免 false sharing
// 不同 lcore 写的变量必须在不同的 cache line
struct per_lcore_data {
    uint64_t packets;
    uint64_t bytes;
    char pad[48];  // 填满一个 cache line (64 bytes)
} __rte_cache_aligned;

// 3. 预取
rte_prefetch0(ptr);   // 预取到 L1 cache
rte_prefetch1(ptr);   // 预取到 L2 cache
rte_prefetch2(ptr);   // 预取到 L3 cache

// 4. 批量处理（Burst）— 预取下一批
for (i = 0; i < nb_rx; i++) {
    // 预取下一个 mbuf 的数据
    if (i + 1 < nb_rx)
        rte_prefetch0(rte_pktmbuf_mtod(pkts[i+1], void *));

    process_packet(pkts[i]);
}

6. 性能诊断脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/bin/bash
# dpdk_perf_check.sh

echo "=== DPDK Performance Diagnostics ==="

# 1. CPU 信息
echo "CPU:"
lscpu | grep -E "Model name|CPU\(s\)|CPU max MHz|NUMA"
echo ""

# 2. CPU 频率
echo "Current CPU frequencies:"
lscpu | grep "CPU MHz"
echo ""

# 3. CPU 亲和性
echo "Current process affinity:"
taskset -p $$ 2>/dev/null || echo "N/A"
echo ""

# 4. 软中断
echo "Soft IRQs:"
cat /proc/softirqs | awk '{print $1, $2}' | head -5
echo ""

# 5. 中断
echo "Interrupts for NIC:"
cat /proc/interrupts | grep -E "eth|enp" | head -5
echo ""

# 6. 内存
echo "Hugepages:"
grep -E "HugePages_Total|Hugepagesize" /proc/meminfo
echo ""

# 7. NUMA
echo "NUMA topology:"
numactl --hardware
echo ""

# 8. IRQ 绑定
echo "IRQ affinity for eth0:"
for irq in $(grep -l "eth0" /proc/irq/*/interrupts 2>/dev/null); do
    echo "  $irq: $(cat ${irq}/smp_affinity_list)"
done

# 9. 网卡
echo "Network:"
ethtool -i $(ip route get 8.8.8.8 | awk '{print $5; exit}') 2>/dev/null
echo ""

echo "=== Diagnostics complete ==="

7. 常见性能问题

问题 症状 原因 解决方案
PPS 低于线速 吞吐上不去 CPU 瓶颈 增加 lcore 数量
延迟波动大 抖动高 中断/调度 隔离 CPU，禁用节能
RX missed 增长 丢包 应用处理太慢 增加 burst size，优化处理
RX no_mbuf 增长 mbuf 不足 pool 太小 增加 mbuf 数量
TX 延迟增加 发送慢 TX desc 满 增加 TX desc 数量
CPU 使用率不均 部分 lcore 满 不均负载 调整队列绑定
缓存 miss 高 低吞吐 数据局部性差 对齐、预取、调整结构体布局
锁竞争 性能不随 lcore 增长 共享锁 per-lcore 数据

8. 性能检查清单

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 基准
□ testpmd 能跑满线速吗？（验证 NIC 能力）
□ 没有 missed / no_mbuf？
□ CPU 使用率 < 80%（单 lcore）？

# 配置
□ 网卡绑定到 vfio-pci？
□ Hugepage 正确挂载？
□ CPU 已隔离（isolcpus）？
□ CPU 频率设为 performance？
□ 网卡中断不在 lcore 上？
□ NUMA 节点匹配（网卡和 mbuf pool 在同一 NUMA）？

# 代码
□ 使用 Burst（≥ 32）？
□ 无 printf/malloc 在转发路径？
□ 无锁（或 per-lcore 数据）？
□ 数据对齐 cache line？
□ 有预取？
□ 批量释放 mbuf（free_bulk）？
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870