CPU缓存是介于CPU寄存器和主内存之间的高速存储组件，其访问速度远快于主内存，编写缓存友好的C++代码核心就是尽可能提升缓存命中率，减少访问主内存的次数。这需要从数据局部性和访问模式两个维度进行优化。
CPU缓存与局部性原理
现代CPU通常有多级缓存，常见的是L1、L2、L3三级结构，L1缓存速度最快但容量最小，L3缓存速度较慢但容量更大。缓存的基本存储单位是缓存行，通常为64字节，每次缓存加载都会加载一整个缓存行的内容。
局部性分为两种类型：
- 时间局部性：如果一个数据被访问过，那么在短时间内它很可能再次被访问。比如循环中的计数器变量，会被多次重复访问。
- 空间局部性：如果一个数据被访问，那么它相邻地址的数据很可能也会被访问。比如数组的连续元素遍历，就符合空间局部性特征。
数据访问模式对缓存的影响
连续访问与跳跃访问的差异
连续访问数组元素时，CPU会预加载后续缓存行，命中率很高；而跳跃访问会频繁触发缓存未命中，性能差距可能达到数倍。下面通过代码示例对比两种访问模式的性能差异。
#include <iostream>
#include <vector>
#include <chrono>
int main() {
const int SIZE = 10000000;
std::vector<int> arr(SIZE, 1);
auto start = std::chrono::high_resolution_clock::now();
// 连续访问模式
long long sum1 = 0;
for (int i = 0; i < SIZE; ++i) {
sum1 += arr[i];
}
auto mid = std::chrono::high_resolution_clock::now();
// 跳跃访问模式，步长为16
long long sum2 = 0;
for (int i = 0; i < SIZE; i += 16) {
sum2 += arr[i];
}
auto end = std::chrono::high_resolution_clock::now();
auto continuous_time = std::chrono::duration_cast<std::chrono::milliseconds>(mid - start).count();
auto stride_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - mid).count();
std::cout << "连续访问耗时: " << continuous_time << "ms" << std::endl;
std::cout << "跳跃访问耗时: " << stride_time << "ms" << std::endl;
return 0;
}
二维数组的遍历顺序问题
C++中二维数组按行存储，先行后列的遍历方式符合空间局部性，先列后行的遍历会导致大量缓存未命中。以下代码展示两种遍历方式的差异：
#include <iostream>
#include <vector>
#include <chrono>
int main() {
const int ROW = 10000;
const int COL = 10000;
std::vector<std::vector<int>> matrix(ROW, std::vector<int>(COL, 1));
auto start = std::chrono::high_resolution_clock::now();
// 先行后列遍历
long long sum1 = 0;
for (int i = 0; i < ROW; ++i) {
for (int j = 0; j < COL; ++j) {
sum1 += matrix[i][j];
}
}
auto mid = std::chrono::high_resolution_clock::now();
// 先列后行遍历
long long sum2 = 0;
for (int j = 0; j < COL; ++j) {
for (int i = 0; i < ROW; ++i) {
sum2 += matrix[i][j];
}
}
auto end = std::chrono::high_resolution_clock::now();
auto row_major_time = std::chrono::duration_cast<std::chrono::milliseconds>(mid - start).count();
auto col_major_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - mid).count();
std::cout << "行优先遍历耗时: " << row_major_time << "ms" << std::endl;
std::cout << "列优先遍历耗时: " << col_major_time << "ms" << std::endl;
return 0;
}
编写缓存友好代码的实践方法
优化数据结构布局
结构体成员的顺序会影响其内存占用，将频繁一起访问的成员放在相邻位置，可以减少缓存行浪费。比如以下两个结构体的对比：
#include <iostream>
// 未优化结构体，成员大小交错，可能存在填充
struct BadStruct {
char a;
long long b;
char c;
int d;
};
// 优化后的结构体，按成员大小降序排列，减少填充
struct GoodStruct {
long long b;
int d;
char a;
char c;
};
int main() {
std::cout << "BadStruct大小: " << sizeof(BadStruct) << "字节" << std::endl;
std::cout << "GoodStruct大小: " << sizeof(GoodStruct) << "字节" << std::endl;
return 0;
}
GoodStruct的布局更紧凑，占用内存更小，相同缓存行可以存储更多实例，提升缓存利用率。
避免伪共享问题
伪共享是指多个线程修改同一个缓存行中的不同变量，导致缓存行频繁失效的问题。可以通过缓存行对齐来避免，示例代码如下：
#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
// 未对齐的计数器，可能存在伪共享
struct UnalignedCounter {
int count1;
int count2;
};
// 缓存行对齐的计数器，避免伪共享
struct alignas(64) AlignedCounter {
int count1;
char padding[60]; // 填充到64字节
int count2;
};
int main() {
UnalignedCounter unaligned;
AlignedCounter aligned;
unaligned.count1 = 0;
unaligned.count2 = 0;
aligned.count1 = 0;
aligned.count2 = 0;
auto start1 = std::chrono::high_resolution_clock::now();
std::thread t1([&]() {
for (int i = 0; i < 100000000; ++i) {
unaligned.count1++;
}
});
std::thread t2([&]() {
for (int i = 0; i < 100000000; ++i) {
unaligned.count2++;
}
});
t1.join();
t2.join();
auto end1 = std::chrono::high_resolution_clock::now();
auto start2 = std::chrono::high_resolution_clock::now();
std::thread t3([&]() {
for (int i = 0; i < 100000000; ++i) {
aligned.count1++;
}
});
std::thread t4([&]() {
for (int i = 0; i < 100000000; ++i) {
aligned.count2++;
}
});
t3.join();
t4.join();
auto end2 = std::chrono::high_resolution_clock::now();
auto unaligned_time = std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1).count();
auto aligned_time = std::chrono::duration_cast<std::chrono::milliseconds>(end2 - start2).count();
std::cout << "未对齐计数器耗时: " << unaligned_time << "ms" << std::endl;
std::cout << "对齐计数器耗时: " << aligned_time << "ms" << std::endl;
return 0;
}
减少动态内存分配
频繁的new/delete会导致内存碎片化，降低空间局部性，尽量使用栈内存或预分配的内存池。比如遍历动态分配的二维数组时，连续的内存块比嵌套vector的碎片化内存缓存友好度更高。
总结
编写缓存友好的C++代码需要始终围绕提升缓存命中率的目标，充分利用时间局部性和空间局部性，优化数据访问模式，调整数据结构布局，避免伪共享和频繁动态内存分配。在实际开发中，可以结合性能分析工具定位缓存未命中的热点代码，针对性进行优化，从而有效提升程序的整体运行效率。