针对 CPU 缓存架构（L1/L2 Cache）优化矩阵乘法

> 本文面向有一定 C++ 基础的开发者，介绍如何利用 CPU 的 L1/L2 缓存特性，通过循环分块、循环重排、SIMD 向量化、多线程等技术显著提升矩阵乘法的性能。所有代码基于 x86-64 架构，使用 GCC/Clang 编译，适用于学习底层优化思想或实际高性能计算场景。

一、CPU 缓存层次结构

1.1 现代 CPU 缓存参数（以某代 Intel Core i7 为例）

不同 CPU 的具体参数可能有所差异，但层次结构和相对数量级基本一致。建议读者根据自己设备的实际缓存大小调整优化参数。

```cpp

// 典型缓存层次结构（仅供参考）

L1 Cache: 32KB 数据 + 32KB 指令 (每核心)

延迟: 4-5 时钟周期
带宽: ~500 GB/s
缓存行大小: 64 字节

L2 Cache: 256KB (每核心)

延迟: 12-15 时钟周期
带宽: ~200 GB/s
缓存行大小: 64 字节

L3 Cache: 8-32MB (共享)

延迟: 30-50 时钟周期
带宽: ~100 GB/s
缓存行大小: 64 字节

RAM: 16-64GB

延迟: 200-300 时钟周期
带宽: ~50 GB/s

```

1.2 缓存行与内存布局

理解缓存行（Cache Line）是优化内存访问模式的基础。现代 CPU 以 64 字节为单位在缓存和内存之间交换数据。

```cpp

#include <iostream>

const int CACHE_LINE_SIZE = 64;

const int DOUBLES_PER_CACHE_LINE = CACHE_LINE_SIZE / sizeof(double); // = 8

// 演示空间局部性对性能的影响

void demonstrate_cache_line() {

const int N = 10000;

double matrix $N$ $N$ ; // 行优先存储（C/C++ 默认）

// 好的访问模式：按行遍历（空间局部性好）

for (int i = 0; i < N; i++) {

for (int j = 0; j < N; j++) {

matrix $i$ $j$ += 1; // 相邻元素位于同一缓存行

}

// 坏的访问模式：按列遍历（每次跳跃 N*8 字节，缓存未命中率高）

for (int j = 0; j < N; j++) {

for (int i = 0; i < N; i++) {

matrix $i$ $j$ += 1; // 每步都跳到不同缓存行

}

```

二、朴素矩阵乘法及其性能瓶颈

2.1 标准实现

假设我们要计算 $ C = A \times B $，其中三个矩阵均为 $ n \times n $，按行优先存储。

```cpp

// 朴素 O(N³) 矩阵乘法

void naive_matrix_multiply(int n, double* A, double* B, double* C) {

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

double sum = 0.0;

for (int k = 0; k < n; k++) {

sum += A $i \* n + k$ * B $k \* n + j$ ;

}

C $i \* n + j$ = sum;

}

```

2.2 性能问题分析

**B 矩阵按列访问**：内层循环中 `B $k \* n + j$ ` 的 `j` 固定、`k` 变化，每次访问跨越 `n` 个元素（即 `n * 8` 字节），几乎每次都会导致缓存未命中。
**A 矩阵重用率低**：对于固定的 `i` 和 `j`，`A $i$ $k$ ` 虽然按行访问，但每个 `k` 仅使用一次，无法利用缓存。
**缓存污染**：同时频繁装入 A、B、C 的不同部分，容易造成 L1/L2 缓存抖动。

2.3 缓存未命中对性能的影响

通过简单的计时测试可以发现，当矩阵大小超过缓存容量时，执行时间会急剧上升。

```cpp

#include <chrono>

#include <iostream>

class CacheAnalyzer {

public:

void analyze_access_pattern(int n) {

const int iter = 100;

double* A = new double $n \* n$ ;

double* B = new double $n \* n$ ;

double* C = new double $n \* n$ ;

auto start = std::chrono::high_resolution_clock::now();

for (int t = 0; t < iter; t++) {

naive_matrix_multiply(n, A, B, C);

}

auto end = std::chrono::high_resolution_clock::now();

auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

std::cout << "Size " << n << ": " << duration.count() << " ms\n";

delete\[\] A; delete\[\] B; delete\[\] C;

}

};

// 典型输出（CPU 不同会略有差异）：

// n=128: ~5 ms （全部放入 L2 缓存）

// n=256: ~40 ms （L2 不足，需 L3）

// n=1024: ~3000 ms（频繁访问内存）

```

三、核心优化技术

3.1 循环分块（Loop Blocking / Tiling）

分块的思想是将大矩阵划分为多个小块，使得每个小块能完整放入 L1 或 L2 缓存中，从而大幅减少缓存未命中。

```cpp

// 分块矩阵乘法

void blocked_matrix_multiply(int n, int block_size,

double* A, double* B, double* C) {

// block_size 应根据缓存大小动态选择（典型值 64~128）

#pragma omp parallel for collapse(2)

for (int i_block = 0; i_block < n; i_block += block_size) {

for (int j_block = 0; j_block < n; j_block += block_size) {

// 初始化 C 块为 0

for (int i = i_block; i < std::min(i_block + block_size, n); i++) {

for (int j = j_block; j < std::min(j_block + block_size, n); j++) {

C $i \* n + j$ = 0.0;

}

// 对 A 和 B 的分块进行乘法

for (int k_block = 0; k_block < n; k_block += block_size) {

for (int i = i_block; i < std::min(i_block + block_size, n); i++) {

for (int k = k_block; k < std::min(k_block + block_size, n); k++) {

double aik = A $i \* n + k$ ;

for (int j = j_block; j < std::min(j_block + block_size, n); j++) {

C $i \* n + j$ += aik * B $k \* n + j$ ;

}

// 自动调优分块大小（基于 L1 数据缓存）

int auto_tune_block_size(int n) {

const int L1_DATA_CACHE = 32 * 1024; // 32KB

// 同时容纳 A_block, B_block, C_block 三个子块

int max_block_size = static_cast<int>(std::sqrt(L1_DATA_CACHE / (3.0 * sizeof(double))));

// 对齐到缓存行（64字节 = 8个double）

int block_size = (max_block_size / 8) * 8;

block_size = std::min(block_size, n);

block_size = std::max(block_size, 32);

return block_size;

}

```

3.2 循环重排（Loop Reordering）

改变循环嵌套顺序，使内层循环访问连续内存，有利于编译器自动向量化。

```cpp

// ikj 顺序：最大化 A 和 B 的重用

void ikj_matrix_multiply(int n, double* A, double* B, double* C) {

// 先清零 C

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

C $i \* n + j$ = 0.0;

}

for (int i = 0; i < n; i++) {

for (int k = 0; k < n; k++) {

double aik = A $i \* n + k$ ;

double* C_row = &C $i \* n$ ;

double* B_row = &B $k \* n$ ;

// 内层 j 连续访问，空间局部性极佳

for (int j = 0; j < n; j++) {

C_row $j$ += aik * B_row $j$ ;

}

```

3.3 软件数据预取（Software Prefetching）

通过显式指令提前将未来需要的数据加载到缓存，可掩盖内存访问延迟。

```cpp

#include <xmmintrin.h> // MMX intrinsics

void prefetch_matrix_multiply(int n, double* A, double* B, double* C) {

const int PREFETCH_DISTANCE = 8; // 提前 8 次迭代预取

for (int i = 0; i < n; i++) {

for (int k = 0; k < n; k++) {

double aik = A $i \* n + k$ ;

double* B_row = &B $k \* n$ ;

double* C_row = &C $i \* n$ ;

// 预取未来 k 循环中会用到的数据

if (k + PREFETCH_DISTANCE < n) {

_mm_prefetch(reinterpret_cast<char*>(&B $(k + PREFETCH_DISTANCE) \* n$ ),

_MM_HINT_T0); // 预取到 L1

_mm_prefetch(reinterpret_cast<char*>(&A $i \* n + (k + PREFETCH_DISTANCE)$ ),

_MM_HINT_T0);

}

for (int j = 0; j < n; j++) {

C_row $j$ += aik * B_row $j$ ;

}

```

> **注意**：`_mm_prefetch` 是 x86 专有指令，非 x86 平台需使用其他方式或忽略。预取距离需要根据实际硬件调优，不当使用可能降低性能。

四、高级优化技术

4.1 SIMD 向量化（AVX2 / AVX-512）

使用单指令多数据流（SIMD）一次处理多个 double，可大幅提升浮点计算吞吐量。

**编译要求**：需要启用 `-mavx2` 或 `-mavx512f` 标志（GCC/Clang）。运行前请检查 CPU 是否支持相应指令集。

```cpp

#include <immintrin.h>

// AVX2（一次处理 4 个 double）

void avx2_matrix_multiply(int n, double* A, double* B, double* C) {

const int VECTOR_SIZE = 4;

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j += VECTOR_SIZE) {

__m256d c_vec = _mm256_setzero_pd();

for (int k = 0; k < n; k++) {

__m256d a_vec = _mm256_broadcast_sd(&A $i \* n + k$ );

__m256d b_vec = _mm256_loadu_pd(&B $k \* n + j$ );

c_vec = _mm256_fmadd_pd(a_vec, b_vec, c_vec);

}

_mm256_storeu_pd(&C $i \* n + j$ , c_vec);

}

// AVX-512（一次处理 8 个 double，需 CPU 支持）

#ifdef AVX512F

void avx512_matrix_multiply(int n, double* A, double* B, double* C) {

const int VECTOR_SIZE = 8;

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j += VECTOR_SIZE) {

__m512d c_vec = _mm512_setzero_pd();

for (int k = 0; k < n; k++) {

__m512d a_vec = _mm512_set1_pd(A $i \* n + k$ );

__m512d b_vec = _mm512_loadu_pd(&B $k \* n + j$ );

c_vec = _mm512_fmadd_pd(a_vec, b_vec, c_vec);

}

_mm512_storeu_pd(&C $i \* n + j$ , c_vec);

}

#endif

```

4.2 缓存对齐与避免伪共享

多线程环境下，不同线程修改同一缓存行不同部分会导致缓存行频繁失效（伪共享）。通过对齐分配和填充可解决。

```cpp

#include <cstdlib>

// 缓存行对齐的内存分配器

class AlignedMatrix {

private:

int n;

double* data;

public:

AlignedMatrix(int size) : n(size) {

posix_memalign(reinterpret_cast<void**>(&data), CACHE_LINE_SIZE,

n * n * sizeof(double));

}

~AlignedMatrix() { free(data); }

double* row(int i) { return data + i * n; }

};

// 线程局部数据填充到缓存行大小

struct alignas(CACHE_LINE_SIZE) ThreadLocalData {

double local_sum $8$ ;

char padding $CACHE_LINE_SIZE - sizeof(double) \* 8$ ;

};

```

4.3 多线程并行化（OpenMP）

利用多核 CPU 并行计算不同分块，注意合理划分任务以减少同步开销。

```cpp

#include <omp.h>

// OpenMP 并行分块乘法

void parallel_blocked_matrix_multiply(int n, int block_size,

double* A, double* B, double* C) {

#pragma omp parallel for collapse(2) schedule(dynamic)

for (int i_block = 0; i_block < n; i_block += block_size) {

for (int j_block = 0; j_block < n; j_block += block_size) {

// 计算 C 块（代码与单线程分块类似）

for (int k_block = 0; k_block < n; k_block += block_size) {

for (int i = i_block; i < std::min(i_block + block_size, n); i++) {

for (int k = k_block; k < std::min(k_block + block_size, n); k++) {

double aik = A $i \* n + k$ ;

for (int j = j_block; j < std::min(j_block + block_size, n); j++) {

C $i \* n + j$ += aik * B $k \* n + j$ ;

}

```

> **OpenMP 编译**：需要添加 `-fopenmp` 标志。在 Mac 上可用 `-Xpreprocessor -fopenmp -lomp`。

五、完整优化实现及性能测试

5.1 生产级矩阵乘法类（动态选择最优算法）

```cpp

class OptimizedMatrixMultiply {

public:

static void multiply(int n, double* A, double* B, double* C) {

// 小矩阵直接使用展开优化

if (n <= 64) {

optimized_small_matrix(n, A, B, C);

return;

}

// 根据 CPU 指令集选择最佳实现

if (has_avx512()) {

avx512_multiply_with_blocking(n, A, B, C);

} else if (has_avx2()) {

avx2_multiply_with_blocking(n, A, B, C);

} else {

sse_multiply_with_blocking(n, A, B, C);

}

private:

static bool has_avx512() {

#ifdef AVX512F

return true;

#else

return false;

#endif

}

static bool has_avx2() {

#ifdef AVX2

return true;

#else

return false;

#endif

}

// 详细实现见下文或完整代码仓库（略去重复代码）

// ...

};

```

性能测试结果（Intel i7-9700K, 3.6GHz，矩阵大小 1024×1024）

\[performance_results\]

optimization = "朴素算法"

execution_time_ms = 3000

gflops = 0.5

speedup = "1×"

\[performance_results\]

optimization = "+ 循环分块 + 循环重排"

execution_time_ms = 600

gflops = 5.0

speedup = "10×"

\[performance_results\]

optimization = "+ AVX2 向量化"

execution_time_ms = 120

gflops = 25.0

speedup = "50×"

\[performance_results\]

optimization = "+ OpenMP（8 核）"

execution_time_ms = 20

gflops = 150.0

speedup = "300×"

\[performance_results\]

optimization = "理论峰值（AVX2 + 8核）"

execution_time_ms = 13

gflops = 230.0

speedup = "460×"

> 注：实际性能受内存带宽、CPU 频率、编译器版本等因素影响，上表仅为示例值。

六、总结与最佳实践

优化技术小结

\[optimization_techniques\]

technique = "循环分块"

expected_speedup = "2-10 倍"

implementation_difficulty = "中"

applicable_scenarios = "所有大小，特别是大矩阵"

\[optimization_techniques\]

technique = "循环重排"

expected_speedup = "2-5 倍"

implementation_difficulty = "低"

applicable_scenarios = "所有大小"

\[optimization_techniques\]

technique = "SIMD 向量化"

expected_speedup = "4-8 倍"

implementation_difficulty = "高"

applicable_scenarios = "大矩阵，需 CPU 支持"

\[optimization_techniques\]

technique = "多线程"

expected_speedup = "核心数倍"

implementation_difficulty = "中"

applicable_scenarios = "大矩阵，多核 CPU"

\[optimization_techniques\]

technique = "数据预取"

expected_speedup = "10-30%"

implementation_difficulty = "中"

applicable_scenarios = "内存带宽瓶颈场景"

\[optimization_techniques\]

technique = "缓存对齐"

expected_speedup = "5-20%"

implementation_difficulty = "低"

applicable_scenarios = "多线程，避免伪共享"

6.2 编写高性能矩阵乘法的关键点

**分块大小**：根据实际 L1/L2 缓存动态计算，典型值 64~128。可使用 `sysctl hw.l1dcachesize`（macOS）或 `/sys/devices/system/cpu/cpu0/cache/`（Linux）查询。
**访问模式**：优先按行遍历，利用空间局部性；通过 ikj 或 kij 重排使内层循环连续访问内存。
**向量化**：优先依赖编译器自动向量化（如 `-O3 -mavx2`），必要时使用 intrinsics 进行手工调优。
**并行化**：使用 OpenMP 时注意 `collapse(2)` 和 `schedule(dynamic)` 以均衡负载；务必避免伪共享。
**预取**：仅在对特定硬件充分测试后使用，默认不开启。

6.3 进一步阅读与建议

**Intel Intrinsics Guide**：查询 SIMD 指令的详细用法。
**《Computer Organization and Design》**：深入理解缓存与内存层次结构。
**BLAS 库（OpenBLAS, Intel MKL）**：生产环境直接使用经过极致优化的库，无需重复造轮子。

[量化]《从 L1/L2 缓存到 SIMD：矩阵乘法性能优化完全指南》

针对 CPU 缓存架构（L1/L2 Cache）优化矩阵乘法

一、CPU 缓存层次结构

1.1 现代 CPU 缓存参数（以某代 Intel Core i7 为例）

1.2 缓存行与内存布局

二、朴素矩阵乘法及其性能瓶颈

2.1 标准实现

2.2 性能问题分析

2.3 缓存未命中对性能的影响

三、核心优化技术

3.1 循环分块（Loop Blocking / Tiling）

3.2 循环重排（Loop Reordering）

3.3 软件数据预取（Software Prefetching）

四、高级优化技术

4.1 SIMD 向量化（AVX2 / AVX-512）

4.2 缓存对齐与避免伪共享

4.3 多线程并行化（OpenMP）

五、完整优化实现及性能测试

5.1 生产级矩阵乘法类（动态选择最优算法）

性能测试结果（Intel i7-9700K, 3.6GHz，矩阵大小 1024×1024）

六、总结与最佳实践

优化技术小结

6.2 编写高性能矩阵乘法的关键点

6.3 进一步阅读与建议