通用矩阵乘法(General Matrix Multiply,GEMM)是线性代数中最基础也是最重要的运算之一,是深度学习和高性能计算的核心原语。从简单的线性回归到千亿参数的大语言模型训练,几乎所有现代计算任务最终都归结为对 GEMM 的高效调用。
GEMM 的性能直接决定了上层应用的效率——优化一个 GEMM 内核能将整个神经网络训练加速数倍。正因如此,NVIDIA、AMD 等硬件厂商投入大量资源开发高度优化的 GEMM 实现(cuBLAS、rocBLAS),学术界也在持续探索更高效的矩阵乘法算法。
GEMM 定义了以下运算:
其中:
当 且无转置时,退化为经典矩阵乘法 。
在 BLAS(Basic Linear Algebra Subprograms)标准中,GEMM 对应 sgemm(单精度)、dgemm(双精度)、cgemm(复数单精度)和 zgemm(复数双精度):
CALL SGEMM(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
这是一个 CBLAS 风格的 C 接口调用示例:
cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
m, n, k, 1.0, A, k, B, n, 0.0, C, n);
标准矩阵乘法的总操作数(浮点运算次数):
对于方阵 :
这意味着当 翻倍时,计算量增长 8 倍。
| 矩阵规模 | FLOPs(浮点运算数) | 存储量(FP32) | A100 理论时间(312 TFLOPS) |
|---|---|---|---|
| 128 | 4.2 MFLOPs | 192 KB | ~0.013 μs |
| 512 | 268 MFLOPs | 3 MB | ~0.86 μs |
| 1024 | 2.1 GFLOPs | 12 MB | ~6.7 μs |
| 2048 | 16.8 GFLOPs | 48 MB | ~54 μs |
| 4096 | 134 GFLOPs | 192 MB | ~430 μs |
| 8192 | 1.07 TFLOPs | 768 MB | ~3.4 ms |
| 16384 | 8.59 TFLOPs | 3 GB | ~27.5 ms |
考虑两个 矩阵:
计算 ,其中 的计算过程:
完整结果:
总操作数: 次浮点运算,其中 64 次乘法和 64 次加法。
| 算法 | 时间复杂度 | 理论加速 | 内存开销 | 实际可用性 |
|---|---|---|---|---|
| 经典 O() | 1× | 低 | ✅ 通用标准 | |
| Strassen | ~5.8× | 中等(~11% 增加) | ⚠️ 仅大矩阵 | |
| Coppersmith-Winograd | ~48× | 极高 | ❌ 实际不可行 | |
| 最新进展(2024) | ~60× | 极高 | ❌ 仅理论 |
Strassen 算法通过分治将复杂度从 降低到 :
Strassen 只需要 7 次乘法(而不是 8 次),但以增加内存复制和加法次数为代价,因此 较小时反而更慢。实际工程中通常 才考虑使用。
现代计算机的内存层次决定了 GEMM 的第一个优化原则:尽可能将数据留在靠近计算单元的内存中。
对于 A100 GPU,HBM 带宽约 2 TB/s,而 Tensor Core 的计算吞吐量约 312 TFLOPS——这意味着每次计算需要消耗约 624 字节的带宽(FP16),远高于从 HBM 读取一个元素的成本。
核心思想:将大矩阵分割为能放入缓存的小块,最大化数据重用。
// 三重循环分块
for (int i = 0; i < M; i += BM) {
for (int j = 0; j < N; j += BN) {
for (int k = 0; k < K; k += BK) {
// 将 A[i:i+BM, k:k+BK] 和 B[k:k+BK, j:j+BN] 加载到缓存
// 计算 C[i:i+BM, j:j+BN] += A_blk × B_blk
simple_gemm(BM, BN, BK, A + i*K + k, B + k*N + j, C + i*N + j);
}
}
}
块大小选择至关重要:
| 缓存级别 | 典型大小 | 推荐块大小 BM×BN×BK | 数据重用次数 | 带宽利用率 |
|---|---|---|---|---|
| L1 Cache | 32 KB | 32×32×32 | ~BK 次 | ~40% |
| L2 Cache | 256 KB | 64×64×64 | ~BK 次 | ~60% |
| L3 Cache | 20 MB | 128×128×128 | ~BK 次 | ~80% |
| HBM | 40 GB | 256×256×256 | ~BK 次 | ~90%+ |
利用 CPU 的 SIMD 指令(AVX-512、SVE)或 GPU 的 warp-level 原语:
// AVX-512 向量化 GEMM 核心循环(FMA 指令)
__m512 c0 = _mm512_loadu_ps(&C[i * n + j]);
__m512 a0 = _mm512_loadu_ps(&A[i * k + kk]);
__m512 b0 = _mm512_broadcast_ss(&B[kk * n + j]);
c0 = _mm512_fmadd_ps(a0, b0, c0);
_mm512_storeu_ps(&C[i * n + j], c0);
以 的方阵乘法为基准,FP32 精度,对比各优化层次的效果:
| 优化级别 | 具体实现 | GFLOPS | 理论峰值利用率 | 相比朴素实现加速 |
|---|---|---|---|---|
| 朴素三重循环 | 标准 循环 | ~5 | ~0.2% | 1× |
| + Loop Reordering | 顺序 | ~15 | ~0.5% | 3× |
| + SIMD 向量化 | AVX-512 FMA | ~50 | ~1.6% | 10× |
| + Cache 分块 | 64×64×64 块 | ~200 | ~6.4% | 40× |
| + 寄存器分块 | 6×16 寄存器块 | ~500 | ~16% | 100× |
| + 软件预取 | 提前发起内存请求 | ~800 | ~25.6% | 160× |
| cuBLAS(A100) | 专有实现 | ~19,500 | ~80% | 3900× |
优化后的 GPU 实现相比朴素 CPU 三重循环可实现近 4000 倍的加速,这充分说明了 GEMM 优化的重要性。
神经网络的几乎所有计算最终都映射为 GEMM 调用。
全连接层 中的矩阵向量乘法是 GEMM 的特例(),但在批处理时退化为完整的 GEMM。
对一个批量大小为 、输入维度为 、输出维度为 的全连接层:
这是 的 GEMM,复杂度为 。
卷积运算可以通过 im2col(image to column)转换为 GEMM:
这种转换的代价是内存开销增加——im2col 将特征图中的每个滑动窗口展平成列,导致大量数据复制。以 ResNet-50 的第一个卷积层(, stride 2)为例,im2col 将输入从 3×224×224(约 150 KB)展开为 (3×3×3)×112×112(约 338 KB),内存增加了 2.25 倍。
Transformer 的核心计算:
单层 Transformer 的 GEMM 调用次数(以 GPT-3 规模为例,,序列长度 ):
| 操作 | GEMM 维度 | FLOPs | 占比 |
|---|---|---|---|
| ~14% | |||
| ~14% | |||
| ~14% | |||
| ~0.4% | |||
| Score × | ~0.4% | ||
| ~14% | |||
| FFN: | × 2 | ~57% |
Attention 中 和 Score× 的计算量反而不大(相对 vs ),但当 很大时(如 128K 上下文), 的 会主导总计算。
以 LLaMA-65B 在 A100 上训练为例(micro batch size = 1M tokens):
| 计算阶段 | GEMM 类型 | 占比 | 瓶颈 |
|---|---|---|---|
| 前向传播 | Compute-bound | ~33% | Tensor Core |
| 反向传播(激活梯度) | Compute-bound | ~33% | Tensor Core |
| 反向传播(权重梯度) | Bandwidth-bound | ~17% | HBM 带宽 |
| 优化器更新 | Bandwidth-bound | ~17% | HBM 带宽 |
计算受限 vs 带宽受限:大多数 GEMM 是计算受限的(算术强度高),可以利用 Tensor Core 达到接近峰值的性能;而优化器更新()则是带宽受限的。
量化交易虽然不像大模型训练那样产生数十亿的 GEMM 调用,但以下几个场景依然是 GEMM 密集型:
对于一个包含 只股票、 个时间步的收益矩阵 :
当 (沪深 300 成分股)且 (约 2 年日数据):
在 CPU(单线程 ~50 GFLOPS)上约 180ms,而在 GPU 上仅 ~0.3ms。
均值-方差优化的核心是求解二次规划。每次迭代都需要计算 ,其中 是 协方差矩阵。对于 的优化问题,每次评估都是约 18 MFLOPs 的 GEMM。
量化策略回测时,信号矩阵 和权重更新涉及多次 GEMM:
| 库 | 单线程 GFLOPS | 多线程(28核)GFLOPS | 峰值利用率 | 特点 |
|---|---|---|---|---|
| 朴素 C 实现 | ~2 | ~3 | ~0.2% | 无优化 |
| OpenBLAS | ~8 | ~180 | ~40% | 开源首选 |
| BLIS | ~10 | ~200 | ~44% | 可移植性好 |
| Intel MKL | ~12 | ~250 | ~55% | Intel CPU 最优 |
| AMD AOCL | ~11 | ~230 | ~51% | AMD CPU 最优 |
| Eigen | ~7 | ~150 | ~33% | C++ 模板库 |
Intel Xeon Platinum 8380(28核,2P)理论峰值 ~450 GFLOPS(AVX-512)。
| GPU | 库 | FP32 (N=4096) TFLOPS | FP16 Tensor Core | FP8 Tensor Core | 峰值利用率 |
|---|---|---|---|---|---|
| A100 (80GB) | cuBLAS | 19.5 | 78 | 156 | ~80% |
| H100 (80GB) | cuBLAS | 51 | 197 | 989 | ~85% |
| B200 | cuBLAS | 112 | 450 | 2250 | ~90% |
| MI250X | rocBLAS | 19.2 | 76 | N/A | ~75% |
| W7900 | rocBLAS | 20.4 | 81 | N/A | ~76% |
精度越低,Tensor Core 的计算吞吐量越高:
| 精度 | 存储格式 | A100 TFLOPS | H100 TFLOPS | 典型应用 |
|---|---|---|---|---|
| FP64 | 64-bit | 9.7 | 25 | 科学计算 |
| FP32 | 32-bit | 19.5 | 51 | 传统 DL 训练 |
| TF32 | 19-bit | 78 | 197 | DL 训练(默认) |
| FP16 | 16-bit | 78 | 197 | DL 训练/推理 |
| BF16 | 16-bit | 78 | 197 | DL 训练(主流) |
| FP8 (E4M3) | 8-bit | 156 | 989 | DL 推理/部分训练 |
| INT8 | 8-bit | 312 | 1978 | DL 推理 |
2022 年 DeepMind 使用深度强化学习发现了新的矩阵乘法算法。对于 矩阵,AlphaTensor 找到了只需要 47 次乘法的算法(传统需要 49 次),而 矩阵的算法突破了 96 次的上限。
关键发现:
随着大模型参数量膨胀,全稠密 GEMM 的计算成本日益高昂。稀疏 GEMM 通过跳过零元素来减少计算量:
| 技术 | 稀疏度 | 理论加速 | 硬件支持 | 代表模型 |
|---|---|---|---|---|
| 非结构化裁剪 | 50-90% | 2-5× | NVIDIA Ampere N:M | DeepSparse |
| 结构化裁剪 | 50-80% | 2-4× | 一般 | SparseGPT |
| N:M 稀疏 | 50% | 1.5-2× | A100/H100 原生支持 | TensorRT |
| Expert Choice | 25-50% | 1.3-1.8× | 需自定义 | Mixtral 8×7B |
FlashAttention 不改变 GEMM 本身,但通过算子融合减少了中间结果的读写次数。传统的 Attention 计算需要 5 次独立的 GEMM + 融合操作,每次都需要将中间结果写回 HBM,而 FlashAttention 将其合并为更少的内核:
| 实现 | GEMM 调用次数 | HBM 读写量 | 加速比 (S=1024) |
|---|---|---|---|
| 标准 Attention | 5 次独立 | 1× | |
| FlashAttention | 1 次融合 | ~2× | |
| FlashAttention-2 | 1 次融合 | ~3× | |
| FlashAttention-3 | 1 次融合 + 异步 | ~4× |
当需要诊断 GEMM 性能问题时,关注以下指标:
在深度学习中经常需要同时对多个独立的 GEMM 进行计算,如批量注意力头:
// 对一个 batch 的 batch_size 个独立的 GEMM 进行批量处理
cublasGemmStridedBatchedEx(cublas_handle,
CUBLAS_OP_N, CUBLAS_OP_N,
n, m, k,
&alpha,
dA, CUDA_R_16F, k, stridea,
dB, CUDA_R_16F, n, strideb,
&beta,
dC, CUDA_R_16F, n, stridec,
batch_size,
CUDA_R_16F, CUBLAS_GEMM_DEFAULT_TENSOR_OP);
批量 GEMM 相比逐个调用可以节省大量内核启动开销:
| 矩阵规模 | 逐个调用(总时间) | 批量调用(总时间) | 加速 |
|---|---|---|---|
| 64×64 批量 ×1000 | 8.5 ms | 0.6 ms | 14.2× |
| 256×256 批量 ×100 | 4.2 ms | 0.9 ms | 4.7× |
| 1024×1024 批量 ×10 | 3.8 ms | 2.1 ms | 1.8× |
下面是一个使用 Python + NumPy 验证的基本 GEMM 优化示例:
import numpy as np
import time
def naive_gemm(A, B):
"""朴素三重循环实现"""
m, k = A.shape
k2, n = B.shape
assert k == k2
C = np.zeros((m, n))
for i in range(m):
for j in range(n):
for p in range(k):
C[i, j] += A[i, p] * B[p, j]
return C
def blocked_gemm(A, B, block_size=32):
"""分块 GEMM 实现"""
m, k = A.shape
k2, n = B.shape
assert k == k2
C = np.zeros((m, n))
for i in range(0, m, block_size):
i_end = min(i + block_size, m)
for j in range(0, n, block_size):
j_end = min(j + block_size, n)
for p in range(0, k, block_size):
p_end = min(p + block_size, k)
C[i:i_end, j:j_end] += A[i:i_end, p:p_end] @ B[p:p_end, j:j_end]
return C
# 验证正确性
np.random.seed(42)
A = np.random.randn(128, 128).astype(np.float32)
B = np.random.randn(128, 128).astype(np.float32)
C_naive = naive_gemm(A, B)
C_blocked = blocked_gemm(A, B)
C_numpy = A @ B
assert np.allclose(C_naive, C_numpy, atol=1e-4)
assert np.allclose(C_blocked, C_numpy, atol=1e-4)
print("✅ 所有实现结果一致")
# 性能对比
for name, fn in [("NumPy (MKL)", lambda: A @ B),
("Blocked", lambda: blocked_gemm(A, B))]:
times = []
for _ in range(20):
start = time.perf_counter()
fn()
times.append(time.perf_counter() - start)
print(f"{name}: {np.median(times)*1000:.2f} ms (median of 20 runs)")
| 语言/框架 | 调用方式 | 底层库 | 自动批处理 |
|---|---|---|---|
| Python/NumPy | A @ B 或 np.matmul(A, B) |
OpenBLAS/MKL | ✅ |
| Python/PyTorch | torch.mm(A, B) |
cuBLAS/MKL | ✅ |
| Python/TensorFlow | tf.matmul(A, B) |
cuBLAS/oneDNN | ✅ |
| C++/Eigen | A * B |
Eigen/BLAS | ⚠️ 部分 |
| CUDA C | cublas<t>gemm() |
cuBLAS | ✅ batched |
| Rust/ndarray | A.dot(&B) |
OpenBLAS | ⚠️ |
| Julia | A * B |
OpenBLAS | ✅ |
| MATLAB | A * B |
MKL | ✅ |
| 维度 | 关键要点 |
|---|---|
| 数学本质 | ,复杂度 |
| 优化层次 | 循环重排 → 向量化 → Cache 分块 → 寄存器分块 → 预取 |
| GPU 峰值 | A100: 19.5 TFLOPS (FP32), 312 TFLOPS (INT8) |
| 深度学习 | 全连接 / 卷积 (im2col) / Attention 均以 GEMM 为核心 |
| 前沿方向 | AlphaTensor、稀疏 GEMM、FlashAttention 融合、FP8 训练 |
| 工程建议 | 优先使用 cuBLAS/MKL,批处理 GEMM 减少启动开销 |