罗罗编程学习记录
本页内容 展开查看

04.9.5 性能优化与工具链

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.9 C 与 C++

覆盖范围

  • CPU cache 与数据布局:cache line、局部性友好的数据结构
  • 编译优化:O0/O1/O2/O3、inline、模板、常量传播
  • 性能分析工具:perf、gprof、valgrind/callgrind
  • 内存调试:AddressSanitizer、LeakSanitizer
  • 线程调试:ThreadSanitizer
  • 未定义行为调试:UndefinedBehaviorSanitizer

高频题速览

编号 题目 难度 频率
04.9.5-001 什么是 cache 友好的数据布局 高级 ★★★★☆
04.9.5-002 inline 函数有什么用 基础 ★★★★☆
04.9.5-003 O0 O1 O2 O3 优化级别区别 进阶 ★★★★☆
04.9.5-004 perf 怎么用 进阶 ★★★★☆
04.9.5-005 AddressSanitizer 原理 进阶 ★★★★☆
04.9.5-006 ThreadSanitizer 能检测什么 进阶 ★★★★☆
04.9.5-007 什么是伪共享(false sharing) 高级 ★★★★☆
04.9.5-008 性能优化的一般流程 基础 ★★★★★

04.9.5-001 什么是 cache 友好的数据布局?为什么重要?

频率 ★★★★☆ | 难度 高级

一句话结论

CPU 访问内存的速度比访问 cache 慢 100 倍以上,cache 友好就是让数据在内存中连续排列,遍历一次就能把很多数据加载到 cache,减少 cache miss;比如数组比链表快,就是因为数组连续、cache 命中率高。

概念解释

  • CPU 缓存层次:L1(几 KB,1~2ns)→ L2(几百 KB,3~10ns)→ L3(几 MB,10~30ns)→ 内存(几十 GB,100ns+)。
  • cache line:cache 的最小加载单位,通常 64 字节,一次加载一整块。
  • 时间局部性:刚访问过的数据很快又会被访问。
  • 空间局部性:刚访问过的数据附近的数据很快会被访问。

原理流程

  1. 遍历数组:连续内存,第一次访问某个元素时,CPU 把后面 64 字节都加载到 cache。
  2. 接下来的元素都在 cache 里,直接命中,速度极快。
  3. 遍历链表:每个节点在堆上随机位置,每次访问都可能 cache miss,要去内存取,慢 100 倍。
  4. SoA(Structure of Arrays)vs AoS(Array of Structures):SoA 把同一个字段存在一个数组里,遍历这个字段时全部连续,cache 命中率更高。

代码 / 示例

// AoS:Array of Structures
struct Particle {
    float x, y, z;    // 位置
    float vx, vy, vz; // 速度
    int color;
};
std::vector<Particle> particles;

// 只遍历位置的时候,速度和颜色的数据也被加载进 cache,浪费
for (auto& p : particles) {
    p.x += 1;
}

// SoA:Structure of Arrays
struct ParticleArray {
    std::vector<float> x, y, z;
    std::vector<float> vx, vy, vz;
    std::vector<int> color;
};
ParticleArray particles;

// 只遍历 x 的时候,cache 里全是 x,命中率极高
for (size_t i = 0; i < particles.x.size(); i++) {
    particles.x[i] += 1;
}

常见误区

  • 误区:数组快是因为随机访问 O(1)?正解:数组遍历快主要是因为 cache 友好,随机访问只是 O(1) 的算法复杂度。
  • 误区:链表慢只是因为指针跳转?正解:主要是 cache miss,每次访问节点都要去内存取,比 cache 慢 100 倍。

追问 / 延伸

  • 什么是 cache line 对齐?答:把数据按 64 字节对齐,避免一个数据跨两个 cache line,减少加载次数。
  • 什么是预取?答:CPU 自动检测连续访问模式,提前把后面的数据加载到 cache。

04.9.5-002 inline 函数有什么用?和宏有什么区别?

频率 ★★★★☆ | 难度 基础

一句话结论

inline 建议编译器把函数调用处直接展开成函数体代码,省去函数调用的开销(压栈、跳转、返回);和宏的区别是 inline 有类型检查、作用域检查,更安全。

概念解释

  • 函数调用开销:参数压栈、跳转到函数地址、执行、返回、恢复栈帧,几个到几十个周期。
  • inline 展开:把函数体代码直接复制到调用处,没有调用开销,但代码体积变大。
  • inline 只是建议,编译器可能不展开(函数太大、递归、取地址等情况)。
  • inline 函数可以在头文件里定义,不会报重复定义(因为 inline 允许跨翻译单元重复定义)。

原理流程

  1. 编译时,遇到 inline 函数调用,编译器决定是否展开。
  2. 如果展开,直接把函数体代码插到调用处,没有 call 指令。
  3. 如果不展开,就和普通函数一样生成符号,链接时处理。
  4. inline 函数在头文件里定义,每个源文件 include 时都有一份,但链接器会合并成一个。

代码 / 示例

// 普通函数:调用有开销
int add(int a, int b) { return a + b; }
int x = add(1, 2); // 编译成 call add 指令

// inline 函数:建议展开
inline int add_inline(int a, int b) { return a + b; }
int y = add_inline(1, 2); // 编译器可能直接展开成 y = 1 + 2;

// 宏:文本替换,没有类型检查
#define ADD(a, b) ((a) + (b))
int z = ADD(1, 2); // 预处理后变成 int z = ((1) + (2));
// 宏的问题:ADD(i++) 会变成 ((i++) + (i++)),i 自增两次,出 bug

常见误区

  • 误区:inline 一定能加快速度?正解:函数太大时,展开会让代码体积变大,指令 cache 命中率下降,反而更慢。
  • 误区:inline 必须写在类定义里?正解:类内部定义的成员函数自动是 inline 建议;外部写也要加 inline 关键字。

追问 / 延伸

  • 什么时候应该用 inline?答:函数很小、调用很频繁的场景,比如 getter/setter、小工具函数。
  • inline 和 constexpr 有什么关系?答:constexpr 函数在编译期求值,自然也是 inline 的。

04.9.5-003 O0 O1 O2 O3 优化级别有什么区别?

频率 ★★★★☆ | 难度 进阶

一句话结论

O0 不优化,调试友好;O1 做基础优化,代码变小;O2 做更多优化,速度变快;O3 做激进优化,包括自动向量化、循环展开,代码体积可能变大;Debug 用 O0,Release 用 O2 或 O3。

概念解释

  • O0:不做任何优化,代码和源码一一对应,方便调试。
  • O1(-O):基础优化,删除无用代码、简单常量传播,编译快,代码变小。
  • O2:推荐的 Release 优化,几乎所有安全的优化都开,不牺牲空间换速度。
  • O3:激进优化,包括循环展开、自动向量化、函数内联更多,速度可能更快但代码更大。
  • -g:生成调试信息,配合 O0 用。

原理流程

  1. 编译器优化阶段:对中间代码做各种变换,消除冗余、减少指令数、利用 CPU 特性。
  2. O0 时编译器不做这些变换,每行代码都老老实实生成指令。
  3. O2 时编译器做了几百种优化,比如:
    • 常量传播:编译期就能算出的表达式直接算好。
    • 死代码消除:永远走不到的分支直接删掉。
    • 循环优化:把循环里的不变量提出来。
    • 指令调度:调整指令顺序,利用 CPU 流水线。
  4. O3 额外做:
    • 循环展开:把循环几次的代码复制出来,减少分支判断。
    • 自动向量化:把循环改成 SIMD 指令,一次处理多个数据。

代码 / 示例

# Debug 构建:O0 + 调试信息
g++ -g -O0 main.cpp -o app_debug

# Release 构建:O2
g++ -O2 main.cpp -o app_release

# 极致性能:O3
g++ -O3 -march=native main.cpp -o app_fast

# -march=native:让编译器针对当前 CPU 优化,用所有支持的指令集

常见误区

  • 误区:O3 一定比 O2 快?正解:不一定。O3 代码体积变大,指令 cache 命中率下降,某些场景反而更慢;需要 benchmark 测试。
  • 误区:优化只是编译器的事?正解:写代码的方式也影响优化效果,比如循环内的分支预测、数据依赖。

追问 / 延伸

  • 什么是 LTO(Link Time Optimization)?答:链接时优化,跨编译单元优化,比如把不同 .o 文件里的小函数内联。
  • 什么是 PGO(Profile Guided Optimization)?答:先跑一遍程序收集热点,再根据热点重新编译优化。

04.9.5-004 perf 怎么用?能分析什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

perf 是 Linux 下的性能分析工具,基于 CPU 硬件性能计数器,可以统计函数耗时、cache miss、分支预测失败、指令数等,是定位性能瓶颈的首选工具。

概念解释

  • perf top:实时看哪个函数占 CPU 最多。
  • perf record:把程序运行的性能数据记录到文件。
  • perf report:分析 record 的数据,看每个函数的耗时占比。
  • perf stat:统计整体指标,比如指令数、cache miss 率、分支预测成功率。

原理流程

  1. perf 利用 CPU 的硬件性能计数器(PMC),定期采样程序当前执行的指令地址。
  2. 采样次数越多的函数,说明它占 CPU 时间越多。
  3. perf report 把采样结果按函数聚合,生成火焰图或调用栈。
  4. 除了 CPU 时间,还能统计 cache miss、分支失败、内存访问等硬件事件。

代码 / 示例

# 1. 看整体统计
perf stat ./my_program

# 输出示例:
#  Performance counter stats for './my_program':
#          1000.32 msec task-clock                #    1.000 CPUs utilized
#               120      context-switches          #    0.120 K/sec
#             50000      cache-misses              #    4.998 % of all cache refs

# 2. 记录程序运行
perf record -g ./my_program
# -g 记录调用栈

# 3. 分析结果
perf report
# 会打开交互式界面,看每个函数的占比

# 4. 生成火焰图
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

常见误区

  • 误区:perf 只能看 CPU 占用?正解:perf 可以统计很多硬件事件,cache miss、分支预测、TLB miss、浮点运算都能看。
  • 误区:优化热点函数就够了?正解:先看火焰图,找到真正的瓶颈,不要凭感觉优化。

追问 / 延伸

  • 什么是火焰图?答:x 轴是采样数(宽度越宽占 CPU 越多),y 轴是调用栈,一眼就能看到哪个函数最热。
  • perf 是采样的,准确吗?答:采样有误差,但对于找热点足够了;精确测量用 gprof 或插桩。

04.9.5-005 AddressSanitizer 是什么?原理是什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

AddressSanitizer(ASAN)是内存错误检测工具,可以检测越界访问、use-after-free、栈缓冲区溢出、内存泄漏等,编译时加 -fsanitize=address 就开,比 valgrind 快很多。

概念解释

  • 检测的问题:
    • 堆缓冲区溢出(heap buffer overflow)
    • 栈缓冲区溢出(stack buffer overflow)
    • use-after-free(释放后使用)
    • 全局缓冲区溢出(global buffer overflow)
    • 内存泄漏(memory leak)
  • 原理:在编译时给每个内存访问插桩,检查地址是否合法。

原理流程

  1. ASAN 把进程地址空间分成两部分:主应用内存和影子内存(shadow memory)。
  2. 每个 8 字节的应用内存对应 1 字节的影子内存,记录这块内存是否可访问。
  3. malloc 时,把这块内存的影子标记为"部分可访问"(前面是用户请求的大小,后面是红色区)。
  4. 每次内存访问时,ASAN 检查对应影子内存的标记,如果不可访问,立刻报错。
  5. free 时,把这块内存的影子标记为"不可访问"(红色区),这样 use-after-free 立刻能检测到。

代码 / 示例

# 编译时加 -fsanitize=address
g++ -g -fsanitize=address main.cpp -o app_asan

# 运行程序
./app_asan
# 如果有内存错误,ASAN 会打印详细的错误信息:
# ==1234==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000010
# WRITE of size 4 at 0x602000000010 thread T0
#     #0 0x... in main main.cpp:5

常见误区

  • 误区:ASAN 很慢?正解:ASAN 比正常程序慢 2~3 倍,但比 valgrind 快 10~20 倍。
  • 误区:ASAN 能检测所有内存问题?正解:不能检测逻辑错误、未初始化读取(用 MSan)、数据竞争(用 TSan)。

追问 / 延伸

  • 什么是 LeakSanitizer?答:内存泄漏检测,ASAN 内置了,也可以单独用 -fsanitize=leak。
  • ASAN 适合生产环境吗?答:不适合,性能开销大;适合开发和测试环境。

04.9.5-006 ThreadSanitizer 能检测什么?

频率 ★★★★☆ | 难度 进阶

一句话结论

ThreadSanitizer(TSan)检测多线程中的数据竞争:两个线程同时访问同一个内存,至少一个是写,且没有同步机制,编译时加 -fsanitize=thread 就开。

概念解释

  • 数据竞争:两个线程并发访问同一个内存位置,至少一个是写,且没有 happens-before 关系。
  • TSan 还能检测死锁。
  • 原理:记录每次内存访问的线程和时间戳,检测是否有冲突。

原理流程

  1. TSan 给每次内存访问记录:哪个线程、什么时候、读还是写。
  2. 维护每个线程的向量时钟(vector clock),记录线程间的 happens-before 关系。
  3. 如果两个线程对同一个地址有访问,且没有同步关系(一个读一个写,或两个都写),就报数据竞争。
  4. 报告会打印两个线程的调用栈,方便定位。

代码 / 示例

# 编译时加 -fsanitize=thread
g++ -g -fsanitize=thread main.cpp -o app_tsan

# 运行
./app_tsan
# 输出示例:
# WARNING: ThreadSanitizer: data race (pid=1234)
#   Write of size 4 at 0x7fffffffdeac by thread T1:
#     #0 void worker() main.cpp:10
#   Previous read of size 4 at 0x7fffffffdeac by main thread:
#     #0 main main.cpp:5

常见误区

  • 误区:TSan 很慢?正解:TSan 比正常程序慢 5~15 倍,内存开销大,但开发测试阶段值得用。
  • 误区:加了锁就不会有数据竞争?正解:如果两个线程用不同的锁保护同一个变量,还是会有数据竞争。

追问 / 延伸

  • 什么是 happens-before?答:一个操作在另一个操作之前完成,且后者能看到前者的结果;锁的获取发生在锁的释放之后。
  • 怎么避免数据竞争?答:用互斥锁保护共享数据,或用原子操作,或用消息传递(不要共享内存)。

04.9.5-007 什么是伪共享(false sharing)?

频率 ★★★★☆ | 难度 高级

一句话结论

伪共享是两个不同变量被放在同一个 cache line 里,两个 CPU 核心分别修改这两个变量,虽然它们逻辑上不相关,但因为 cache line 是整体加载的,导致 cache line 在两个核心之间来回同步,性能下降。

概念解释

  • cache line 是 64 字节,一个 cache line 里可能放了好几个变量。
  • 两个 CPU 核心各自有自己的 L1/L2 cache。
  • 核心 0 修改 cache line 里的变量 A,整个 cache line 标记为"脏"。
  • 核心 1 要修改同一个 cache line 里的变量 B,发现 cache line 不是自己的,要从核心 0 同步过来。
  • 虽然 A 和 B 没关系,但因为在同一个 cache line,导致频繁同步。

原理流程

  1. 多线程编程中,每个线程有自己的计数器。
  2. 两个计数器刚好在同一个 cache line 里。
  3. 线程 0 修改 count0,整个 cache line 在核心 0 的 cache 里变成脏的。
  4. 线程 1 修改 count1,发现 cache line 不在核心 1 的 cache 里,要从核心 0 拉过来。
  5. 来回同步,每个核心都在等对方的 cache line,性能急剧下降。

代码 / 示例

#include <atomic>
#include <thread>

// 错误写法:两个变量在同一个 cache line
struct BadData {
    std::atomic<int> count0{0};
    std::atomic<int> count1{0};
};
BadData bad;

void thread0() {
    for (int i = 0; i < 1000000; i++) bad.count0++;
}
void thread1() {
    for (int i = 0; i < 1000000; i++) bad.count1++;
}
// count0 和 count1 在同一个 cache line,伪共享,性能差

// 正确写法:每个变量独占一个 cache line
struct alignas(64) PaddedInt {
    std::atomic<int> value{0};
};
struct GoodData {
    PaddedInt count0;
    PaddedInt count1;
};
GoodData good;
// 每个 count 都对齐到 64 字节,独占一个 cache line,没有伪共享

常见误区

  • 误区:两个线程访问不同变量就不会有问题?正解:如果两个变量在同一个 cache line,还是会有伪共享。
  • 误区:伪共享只影响计数器?正解:任何多线程频繁修改的变量,只要挤在同一个 cache line 就会有问题。

追问 / 延伸

  • 怎么检测伪共享?答:用 perf stat 看 cache-misses 是不是异常高,或者用 perf c2c 看缓存一致性流量。
  • alignas(64) 是什么?答:C++11 的对齐修饰,让变量按 64 字节对齐,独占一个 cache line。

04.9.5-008 性能优化的一般流程是什么?

频率 ★★★★★ | 难度 基础

一句话结论

不要凭感觉优化,先测量(benchmark + profiler)找到真正的热点,再优化最热点的地方,优化完再测量验证,不要优化没热点的地方。

概念解释

  • 80/20 法则:80% 的时间花在 20% 的代码上。
  • 过早优化是万恶之源:先写对,再写快。
  • 测量、测量、再测量。

原理流程

  1. 先写正确、清晰、易维护的代码。
  2. 写 benchmark,测基准性能。
  3. 用 profiler(perf、gprof、valgrind)找到热点函数。
  4. 只优化热点函数,不要优化其他地方。
  5. 优化完再 benchmark,确认确实变快了。
  6. 如果优化后反而更慢,回滚,换一种优化方式。

代码 / 示例

// 错误流程:上来就优化
// 一开始就想着怎么内联、怎么减少循环、怎么用指针
// 结果代码又难读又难维护,性能还不一定好

// 正确流程:
// 1. 写清晰的代码
std::vector<int> data = load_data();
sort(data.begin(), data.end());
auto result = process(data);
save_result(result);

// 2. 测性能
// time ./my_program
// 发现 process 函数占了 80% 的时间

// 3. 用 profiler 看 process 里面哪个函数最慢
// perf record -g ./my_program
// perf report
// 发现是 string_concat 最慢

// 4. 优化 string_concat,用 reserve 预分配
std::string result;
result.reserve(estimated_size);
for (auto& s : strings) {
    result += s;
}

// 5. 再测,确认变快了

常见误区

  • 误区:优化所有代码一定更快?正解:优化会让代码变复杂,指令 cache 命中率下降,某些场景反而更慢。
  • 误区:用 O3 编译就不用管代码了?正解:编译器优化是有限的,算法复杂度的提升才是根本。

追问 / 延伸

  • 算法优化 vs 代码优化哪个重要?正解:算法复杂度从 O(n²) 到 O(n log n) 是质的飞跃,比任何代码级优化都重要。
  • 什么是基准测试?答:在相同的输入、相同的环境下,反复运行程序测平均时间,排除偶然因素。

待整理清单

  • [ ] 火焰图生成与解读
  • [ ] SIMD 与自动向量化
  • [ ] gprof 与 perf 对比
  • [ ] 内存池与对象池优化
  • [ ] 分支预测与分支预测失败的代价