【C++游戏引擎开发】第1周《线性代数》（3）：矩阵乘法的SIMD优化与转置加速

一、矩阵乘法数学原理与性能瓶颈

1.1 数学原理

矩阵乘法定义为：给定两个矩阵 $\mathrm{A}（m\times n）$和$\mathrm{B}（n\times p）$，它们的乘积 $\mathrm{C}=A\times B$ 是一个 $\mathrm{m}\times p$ 的矩阵，其中：

$$C_{i,j}=\sum _{k=1}^n{A}_{i,k}\cdot B_{k,j}$$

每个元素$C[i][j]$ 需要 $n$ 次乘法和 $n-1$ 次加法，总时间复杂度为 $O(mnp)$ 。对于两个$n\times n$ 方阵，时间复杂度为 $O(n^3)$。

2.2 ​性能问题

2.2.1 内存访问效率

• ​缓存未命中：大矩阵无法完全放入缓存，导致频繁访问内存，增加延迟。
• 非连续访问：访问$B$的列时，若存储为行主序，会导致缓存不友好。

2.2.2 并行化效率

• ​任务分配不均：静态分配可能导致负载不均衡。
• 同步开销：多线程间同步可能引入额外开销。

2.2.3 指令级并行与向量化

• SIMD利用率低：未充分利用向量指令（如AVX、NEON）。

2.2.4 循环结构与数据布局

• 低效循环顺序：传统三重循环（i-j-k）导致内存访问不连续。

2.3 优化策略

1. 分块处理：将矩阵划分为适合缓存的小块，减少内存访问。
2. 多线程并行：使用OpenMP、pthread等多线程库并行计算。
3. SIMD向量化：利用AVX/SSE指令加速计算。
4. 数据布局优化：转置矩阵 $B$ 或调整存储顺序（行/列主序）。

---

二、分块策略优化（Cache-Friendly）​

分块（Tiling）策略是优化矩阵乘法性能的核心技术之一，其核心思想是通过**数据局部性（Locality）**​提升缓存利用率，减少内存访问延迟。

2.1 为什么需要分块？

矩阵乘法的朴素实现（三重循环）通常存在以下问题：

• 内存访问模式差：对矩阵$B$的列访问（行主序存储下）不连续，导致**缓存行（Cache Line）**利用率低。
• ​数据重用率低：每个元素$A[i][k]$和$B[k][j]$仅被使用一次，无法利用缓存的时间局部性（Temporal Locality）。
• 缓存容量不足：当矩阵大小超过缓存容量时，频繁的缓存未命中（Cache Miss）会触发内存访问，导致性能骤降。
  分块策略通过将大矩阵拆分为适合缓存的小块，使得每个小块的数据能长时间驻留在缓存中，从而提升数据重用率。

2.2 分块策略的原理

2.2.1 数据局部性优化

• 时间局部性：同一块内的数据被多次使用（例如，分块后$A$的子块行与$B$的子块列多次参与计算）。
• ​空间局部性：连续访问内存中的数据（例如，按行优先顺序访问子块内的元素）。

2.2.2 分块步骤

1. 划分矩阵：将矩阵$A$和$B$划分为大小为$T\times T$的子块（Block），$A$按行分块，$B$按列分块，$C$对应分块，分块大小$T$需根据缓存容量（如L1/L2 Cache大小）调整。
2. 分块乘法：对每个子块执行矩阵乘法（子块乘积累加到$C$的对应位置）。
3. 循环顺序调整：将循环顺序从朴素的 ​i-j-k 调整为 ​i-k-j，优先处理分块内的计算。

2.2.3 分块后的计算流程

for i in 0 to m step T:           # 分块行循环
    for j in 0 to p step T:       # 分块列循环
        for k in 0 to n step T:   # 分块中间循环
            # 计算子块 C[i:i+T, j:j+T] += A[i:i+T, k:k+T] * B[k:k+T, j:j+T]
            for ii in i to i+T:   # 子块内行循环
                for kk in k to k+T:
                    for jj in j to j+T:
                        C[ii][jj] += A[ii][kk] * B[kk][jj]

2.3 示例代码

#include 

void block_matmul(int m, int n, int p, float* A, float* B, float* C) {
   
    const int T = 64; // 分块大小
    for (int i = 0; i < m; i += T) {
   
        for (int j = 0; j < p; j += T) {
   
            for (int k = 0; k < n; k += T) {
   
                // 子块范围
                int i_end = std::min(i + T, m);
                int j_end = std::min(j + T, p);
                int k_end = std::min(k + T, n);
                // 子块内计算（使用AVX2）
                for (int ii = i; ii < i_end; ii++) {
   
                    for (int kk = k; kk < k_end; kk++) {
   
                        __m256 a = _mm256_broadcast_ss(&A[ii * n + kk]);
                        for (int jj = j; jj < j_end; jj += 8) {
   
                            __m256 b = _mm256_loadu_ps(&B[kk * p + jj]);
                            __m256 c = _mm256_loadu_ps(&C[ii * p + jj]);
                            c = _mm256_fmadd_ps(a, b, c);
                            _mm256_storeu_ps(&C[ii * p + jj], c);
                        }
                    }
                }
            }
        }
    }
}

---

三、矩阵转置

矩阵转置是线性代数中的基本操作，指将矩阵的行和列互换。具体来说，对于一个$m\times n$的矩阵 $A$，其转置矩阵 $A^T$是一个$n\times m$的矩阵。

3.1 8x8块转置代码实现

void transpose_8x8_block(size_t i, size_t j, Matrix& result) const {
   
    const float* src = data_ + i * cols_ + j;
    __m256 row0 = _mm256_loadu_ps(src + 0 * cols_);
    __m256 row1 = _mm256_loadu_ps(src + 1 * cols_);
    __m256 row2 = _mm256_loadu_ps(src + 2 * cols_);
    __m256 row3 = _mm256_loadu_ps(src + 3 * cols_);
    __m256 row4 = _mm256_loadu_ps(src + 4 * cols_);
    __m256 row5 = _mm256_loadu_ps(src + 5 * cols_);
    __m256 row6 = _mm256_loadu_ps