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 字节,一次加载一整块。
- 时间局部性:刚访问过的数据很快又会被访问。
- 空间局部性:刚访问过的数据附近的数据很快会被访问。
原理流程
- 遍历数组:连续内存,第一次访问某个元素时,CPU 把后面 64 字节都加载到 cache。
- 接下来的元素都在 cache 里,直接命中,速度极快。
- 遍历链表:每个节点在堆上随机位置,每次访问都可能 cache miss,要去内存取,慢 100 倍。
- 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 允许跨翻译单元重复定义)。
原理流程
- 编译时,遇到 inline 函数调用,编译器决定是否展开。
- 如果展开,直接把函数体代码插到调用处,没有 call 指令。
- 如果不展开,就和普通函数一样生成符号,链接时处理。
- 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 用。
原理流程
- 编译器优化阶段:对中间代码做各种变换,消除冗余、减少指令数、利用 CPU 特性。
- O0 时编译器不做这些变换,每行代码都老老实实生成指令。
- O2 时编译器做了几百种优化,比如:
- 常量传播:编译期就能算出的表达式直接算好。
- 死代码消除:永远走不到的分支直接删掉。
- 循环优化:把循环里的不变量提出来。
- 指令调度:调整指令顺序,利用 CPU 流水线。
- 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 率、分支预测成功率。
原理流程
- perf 利用 CPU 的硬件性能计数器(PMC),定期采样程序当前执行的指令地址。
- 采样次数越多的函数,说明它占 CPU 时间越多。
- perf report 把采样结果按函数聚合,生成火焰图或调用栈。
- 除了 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)
- 原理:在编译时给每个内存访问插桩,检查地址是否合法。
原理流程
- ASAN 把进程地址空间分成两部分:主应用内存和影子内存(shadow memory)。
- 每个 8 字节的应用内存对应 1 字节的影子内存,记录这块内存是否可访问。
- malloc 时,把这块内存的影子标记为"部分可访问"(前面是用户请求的大小,后面是红色区)。
- 每次内存访问时,ASAN 检查对应影子内存的标记,如果不可访问,立刻报错。
- 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 还能检测死锁。
- 原理:记录每次内存访问的线程和时间戳,检测是否有冲突。
原理流程
- TSan 给每次内存访问记录:哪个线程、什么时候、读还是写。
- 维护每个线程的向量时钟(vector clock),记录线程间的 happens-before 关系。
- 如果两个线程对同一个地址有访问,且没有同步关系(一个读一个写,或两个都写),就报数据竞争。
- 报告会打印两个线程的调用栈,方便定位。
代码 / 示例
# 编译时加 -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,导致频繁同步。
原理流程
- 多线程编程中,每个线程有自己的计数器。
- 两个计数器刚好在同一个 cache line 里。
- 线程 0 修改 count0,整个 cache line 在核心 0 的 cache 里变成脏的。
- 线程 1 修改 count1,发现 cache line 不在核心 1 的 cache 里,要从核心 0 拉过来。
- 来回同步,每个核心都在等对方的 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% 的代码上。
- 过早优化是万恶之源:先写对,再写快。
- 测量、测量、再测量。
原理流程
- 先写正确、清晰、易维护的代码。
- 写 benchmark,测基准性能。
- 用 profiler(perf、gprof、valgrind)找到热点函数。
- 只优化热点函数,不要优化其他地方。
- 优化完再 benchmark,确认确实变快了。
- 如果优化后反而更慢,回滚,换一种优化方式。
代码 / 示例
// 错误流程:上来就优化
// 一开始就想着怎么内联、怎么减少循环、怎么用指针
// 结果代码又难读又难维护,性能还不一定好
// 正确流程:
// 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 对比
- [ ] 内存池与对象池优化
- [ ] 分支预测与分支预测失败的代价