Linux `perf` 性能分析 on Dorkytiger 的小屋

`perf stat` —— 统计模式

Mon, 01 Jan 0001 00:00:00 +0000

一、基本用法

# 统计程序运行期间的硬件计数器
perf stat ./my_program

# 输出示例：
# Performance counter stats for './my_program':
#
#       1324.56  msec task-clock                # 1.00 CPUs utilized
#            12  context-switches               # 9.06 /sec
#             0  cpu-migrations                 # 0.00 /sec
#           125  page-faults                    # 94.35 /sec
#    4,285,294,201  cycles                      # 3.235 GHz
#    2,142,647,100  instructions                # 0.50  insn per cycle
#      428,529,420  branches                    # 323.5 M/sec
#        8,570,588  branch-misses               # 2.00% of all branches
#      214,264,710  L1-dcache-loads
#       21,426,471  L1-dcache-load-misses       # 10.00% of all L1-dcache accesses
#      107,132,355  cache-references
#       10,713,235  cache-misses                # 10.001 % of all cache refs

二、关键指标解读

instructions per cycle (IPC)
  含义：每个 CPU 周期执行了多少条指令
  理想值：现代 CPU 可以做到 3-4（超标量 + 乱序执行）
  
  IPC > 2：程序运行良好，CPU 利用率高
  IPC 1~2：有轻度流水线停顿
  IPC < 1：严重停顿，可能是缓存未命中、分支预测失败、指令依赖

  ❌ 低 IPC 的程序：
    [周期][周期][周期][周期][周期][周期][周期][周期]
    [指令]      [指令]      [指令]      [指令]
    CPU 大部分时间在等待内存或解决依赖

  ✅ 高 IPC 的程序：
    [周期][周期][周期][周期][周期][周期][周期][周期]
    [指令][指令][指令][指令][指令][指令][指令][指令]
    CPU 利用率接近理论峰值

cache-misses
  含义：L3 缓存未命中的次数
  理想值：< 5%（如果 < 1% 说明数据访问模式非常好）

  > 20%：内存访问模式有问题，需要重构数据结构
  常见原因：链表遍历、红黑树中序遍历、跳跃指针

branch-misses
  含义：分支预测失败的次数占比
  理想值：< 5%

  > 10%：分支模式难以预测
  常见原因：二分搜索中的随机数据、switch-case 中的均匀分布
  优化：用分支友好的算法（如用 cmov 替代分支）、使用 [[likely]]/[[unlikely]]

三、C++ 代码与 perf 计数器的对应

// IPC 低的代码（Cache Miss 严重）
void list_traversal(const std::list<int>& lst) {
    // list 的节点散落在堆中，遍历时大量 Cache Miss
    // perf 会显示 IPC < 1, cache-misses > 20%
    for (auto it = lst.begin(); it != lst.end(); ++it) {
        total += *it;
    }
}

// IPC 高的代码（缓存友好）
void vector_traversal(const std::vector<int>& vec) {
    // vector 连续内存，预取器提前加载
    // perf 会显示 IPC > 2, cache-misses < 1%
    for (auto x : vec) {
        total += x;
    }
}

// 分支预测失败的代码
void unpredictable_branch(const std::vector<int>& data) {
    long long sum = 0;
    for (int x : data) {
        // 如果 data 中的正负数随机分布，分支预测失败率 ~50%
        if (x > 0) sum += x;
    }
}

// 分支预测友好的优化版
void predictable_branch(const std::vector<int>& data) {
    long long sum = 0;
    std::sort(data.begin(), data.end());  // 排序后正数都在前面
    for (int x : data) {
        if (x > 0) sum += x;  // 前一批全命中，后一批全不命中 → 预测率接近 100%
    }
}

如何用 perf 验证优化效果：

`perf record` + `perf report` —— 采样模式

Mon, 01 Jan 0001 00:00:00 +0000

一、基本使用

# 以 99Hz 频率采样，记录 CPU 正在执行的位置
perf record -F 99 -g ./my_program
# -F 99：每秒采样 99 次（避免采样开销过大）
# -g：记录调用栈（才能看到谁调了谁）

# 查看热点函数排名
perf report --stdio

# 输出示例：
# Samples: 1K of event 'cycles', 4000 Hz
# Event count (approx.): 845117845
# Overhead  Command   Shared Object     Symbol
#   25.32%  program   program           [.] compute_dct
#   18.15%  program   program           [.] motion_search
#   12.07%  program   program           [.] avcodec_send_frame
#    8.50%  program   libc-2.31.so      [.] memcpy
#    5.23%  program   program           [.] frame_copy
#    ...

# 看到热点函数后，用 perf annotate 查看汇编级别的热点
perf annotate compute_dct

二、perf annotate 的汇编级分析

输出示例：

compute_dct:
         │ 循环展开的热点：
         │ dct_4x4.c:25 (循环主体)
         │ vld1.32  {q0}, [r1]!       ← 加载数据
   23.5% │ vmla.f32  q1, q0, q2       ← 乘加运算（占 23.5% 的 CPU 时间）
   12.1% │ vld1.32  {q3}, [r2]!       ← 再加载数据
   18.3% │ vmla.f32  q4, q3, q5       ← 乘加运算
         │ subs     r3, #1
    5.2% │ bne      loop              ← 分支

如果一条指令占的时间异常高（比如 50%+），说明这条指令可能是流水线停滞点。
常见原因：
  - cache miss（加载指令）
  - 除法（div 指令，几十个周期）
  - 浮点转换（fcvt）

三、C++ 实战：用 perf 找到热点函数

// bench.cpp —— 一个需要性能分析的程序
#include <vector>
#include <algorithm>
#include <cmath>

// 模拟视频编码中的运动估计
void motion_search(const std::vector<int>& frame, int& best_mv) {
    best_mv = 0;
    int best_cost = INT_MAX;

    for (int dy = -16; dy <= 16; dy++) {
        for (int dx = -16; dx <= 16; dx++) {
            int cost = 0;
            // 简化的 SAD（绝对差和）计算
            for (int i = 0; i < 64; i++) {
                int diff = frame[i] - frame[i + dy * 64 + dx];
                cost += std::abs(diff);
            }
            if (cost < best_cost) {
                best_cost = cost;
                best_mv = dy * 64 + dx;
            }
        }
    }
}

// 模拟 DCT 变换
void dct_transform(std::vector<float>& block) {
    for (int i = 0; i < 64; i++) {
        block[i] = std::sin(block[i]) * std::cos(block[i]);  // 假运算模拟负载
    }
}

int main() {
    std::vector<int> frame(4096, 128);
    std::vector<float> dct_block(64, 1.0f);

    for (int i = 0; i < 100000; i++) {
        if (i % 10 == 0) {
            dct_transform(dct_block);  // 每 10 次做一次 DCT
        } else {
            int mv;
            motion_search(frame, mv);  // 大多数时间做运动估计
        }
    }
}

# 编译并运行 perf
g++ -O2 -g -o bench bench.cpp
perf record -F 99 -g ./bench
perf report --stdio

# 预期输出：
# Overhead  Symbol
#   72.5%   motion_search    ← 主要热点，占总 CPU 的 72%
#   18.3%   dct_transform    ← 次要热点
#    5.2%   std::abs         ← 被 motion_search 调用的

# 优化方向：把 motion_search 的 -16..16 搜索区域减少、提前终止等

`perf top` —— 实时热点监控

Mon, 01 Jan 0001 00:00:00 +0000

一、线上排查用

# 查看整个系统实时热点
perf top

# 只看某个进程
perf top -p <pid>

# 只看某个 CPU 核心
perf top -C 0

# 只看内核态
perf top -k 1

适用场景：

程序运行中突然 CPU 飙高到 100%，但不能停掉程序。
用 perf top -p <pid> 直接看到当前哪个函数在吃 CPU。

输出示例：
  PerfTop:    5000 irqs/sec  kernel:10.0%  exact:  100.0%
   40.2%  libc-2.31.so      [.] malloc            ← 内存分配是热点
   25.1%  my_program         [.] serialize_packet  ← 序列化函数
   12.3%  [kernel]           [.] tcp_sendmsg       ← 内核 TCP 发送

  → 马上知道：程序在频繁 malloc，需要优化内存分配策略。

`perf c2c`——检测伪共享

Mon, 01 Jan 0001 00:00:00 +0000

一、什么时候用

你的多线程程序性能不随核心数线性提升，怀疑是伪共享（False Sharing）。

# 记录缓存行冲突
perf c2c record -F 99 ./my_program

# 查看报告
perf c2c report --stdio

# 输出示例：
# =================================================
#     Shared Data Cache Line Table
# =================================================
#  Total records       : 12345
#  Load records        : 8123
#  Store records       : 4222
#
#  Offset    Node    PA           Snoop    Cacheline
#  0x100     0       0x7f1234     HitM     0x7f1234
#  ↑ 这里有大量缓存行在核心间乒乓

对应代码中的伪共享：

struct Data {
    int a;  // 线程 1 频繁写
    int b;  // 线程 2 频繁写
    // a 和 b 在同一缓存行（64 字节），导致 RFO 在核心间乒乓
};

// 修复：用 alignas(64) 分开到不同缓存行
struct alignas(64) Data1 { int a; };
struct alignas(64) Data2 { int b; };

第一阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

perf stat → 统计计数：IPC、Cache Miss、分支预测
perf record/report → 采样：哪个函数最占 CPU
perf top → 实时监控：线上救火
perf c2c → 伪共享检测：多线程性能不线性扩展时

核心优化思路：
    IPC < 1 → 看 Cache Miss / 分支预测
    Cache Miss 高 → 改数据结构（连续内存/对齐）
    分支预测差 → 排序/分支消除/[[likely]]