上一篇写 Latency Hiding 的时候,关注的是 GPU 如何在等待内存返回数据的几百个 cycle 里保持计算单元忙碌。结论是:靠大量 Resident Warp 交替执行,让等待期间不空转。
但写完之后我发现自己跳过了另一个问题——即使 Warp 切换做得再好,如果内存访问本身就浪费了大量带宽,延迟隐藏也救不回来。
一个 Warp 读 32 个 FP32(128 Bytes),硬件实际搬运的数据可能是 128 Bytes,也可能是 256 Bytes 甚至更多——取决于这 32 个地址落在内存的什么位置。这篇想搞清楚的就是这件事:GPU 的性能不仅取决于需要访问多少数据,更取决于 Warp 的访问模式如何映射到实际的硬件内存组织。
Warp、Lane 和 Sector#
先把几个概念对齐。
一个 Warp 有 32 个 Thread,每个 Thread 占一个 Lane(Lane 0 到 Lane 31)。当 Warp 执行一条 Global Memory Load 指令时,32 个 Lane 各自给出自己要读取的地址。
但硬件不是逐个 Lane 去 HBM 搬数据的。GPU 的 Memory Controller 会把这 32 个地址收集起来,按照地址范围分组,组织成若干次 Memory Transaction。在 A100(Compute Capability 8.0)上,L1 Cache / Global Memory 的基本传输粒度是 32 Bytes 的 Sector。一个 128-Byte Cache Line 包含 4 个 Sector。
硬件会检查 32 个 Lane 的地址落在哪些 Sector 里,每个被触及的 Sector 对应一次实际的内存事务。这个过程就是 Memory Coalescing——把多个 Lane 的请求合并成尽可能少的 Sector 访问。
用一个简化模型来看不同的访问模式(假设 FP32,每个元素 4 Bytes,且起始地址 32B 对齐):
| 访问模式 | 地址分布 | Sector 数 |
|---|---|---|
| 32 Lane 连续读取 32 个 FP32 | 128B 连续区域 | 4 |
| 32 Lane stride=2 读取 FP32 | 256B 区域,每个 Sector 只用一半 | 8 |
| 32 Lane 逆序读取 32 个连续 FP32 | 128B 连续区域(顺序不影响 Sector 归属) | 4 |
| 32 Lane 全部读同一个 FP32 地址 | 1 个 Sector 内的同一地址 | 1 |
第三行是我一开始容易搞混的地方:Lane 0 读最后一个元素、Lane 31 读第一个元素——这不影响 Coalescing。硬件关心的不是哪个 Lane 读哪个地址的对应关系,而是整个 Warp 的 32 个地址在物理上触及了多少个 Sector。
第四行也有点反直觉:所有 Lane 读同一个地址,硬件只需要访问一个 Sector,然后 Broadcast 给所有 Lane。
Coalescing 是看 Warp 的地址分布,不是看代码下标#
一个容易踩的坑:觉得代码写了 a[i] 就是连续访问,就一定是 Coalesced。
Coalescing 针对的是 一次 Warp Memory Instruction 中 32 个 Lane 实际发出的地址分布。数组下标连续只是一个必要条件,数据在内存中的物理布局同样重要。
举个例子。一个矩阵每行 1025 个 FP32,按 Row-major 存储。行跨度(Leading Dimension):
$$ \text{LD} = 1025 \times 4 = 4100 \text{ Bytes} $$4100 不能被 32 整除(\( 4100 = 128 \times 32 + 4 \))。这意味着不同行的起始地址相对于 32B Sector 边界会逐渐偏移。如果一个 Warp 的 32 个 Lane 读取同一行的连续 32 个元素,在某些行上起始地址恰好 32B 对齐,需要 4 个 Sector;在另一些行上起始地址偏移了几个 Byte,128 Bytes 的数据会横跨 5 个 Sector 边界,需要 5 个 Sector。
这就是数据布局影响 Coalescing 的一个典型场景。代码完全一样,只是矩阵的列数从 1024 变成 1025,某些 Warp 的内存效率就下降了 25%。
Matrix Transpose:一端好,另一端就差#
Matrix Transpose 是 Global Memory Coalescing 问题的经典案例。
1// B[j][i] = A[i][j]
2// A: M×N, B: N×M, Row-major
3int x = blockIdx.x * TILE_DIM + threadIdx.x;
4int y = blockIdx.y * TILE_DIM + threadIdx.y;
5
6for (int k = 0; k < TILE_DIM; k += BLOCK_ROWS) {
7 B[(x) * M + (y + k)] = A[(y + k) * N + x];
8}假设 Lane 沿 threadIdx.x 方向分配(这是 CUDA 的默认行为——一个 Warp 内的 32 个 Thread 共享相同的 threadIdx.y,threadIdx.x 从 0 到 31)。
读取 A:A[(y+k) * N + x]。同一个 Warp 内 y+k 固定,x 从 blockIdx.x * TILE_DIM 到 blockIdx.x * TILE_DIM + 31。相邻 Lane 的地址差 4 Bytes(一个 FP32)——连续访问,Coalesced。
写入 B:B[x * M + (y+k)]。同一个 Warp 内 y+k 固定,但 x 变化。相邻 Lane 的地址差不是 4 Bytes,而是 M * sizeof(float) Bytes。
以一个 4096 × 4096 的矩阵为例:
1Lane 0 → B[0 * 4096 + col] // 某个 col
2Lane 1 → B[1 * 4096 + col]
3Lane 2 → B[2 * 4096 + col]
4...
5Lane 31 → B[31 * 4096 + col]相邻 Lane 的地址差:
$$ 4096 \times 4 = 16384 \text{ Bytes} $$32 个地址分散在 16384 × 32 = 512 KB 的范围内。每个 Lane 的地址落在不同的 Sector,甚至不同的 Cache Line。一个 Warp 的 32 次写入需要 32 个独立的 Sector 访问——最差情况。
这就是 Naive Transpose 的核心问题:如果 Lane 沿着让 Load Coalesced 的方向分配,Store 就变成 Strided;反过来让 Store Coalesced,Load 又变成 Strided。
Row-major 的矩阵,行方向连续、列方向 Stride 为一整行。对于转置操作,输入和输出的连续方向正好互相垂直。能不能找到一种办法,让 Load 和 Store 都是 Coalesced?
Shared Memory Tiling:不是因为快,而是能重排数据#
直接在 Global Memory 上做转置,Load 和 Store 不可能同时 Coalesced——因为输入矩阵和输出矩阵的连续方向是正交的,而 Lane 的排列方向只有一个。
但如果引入一个中间层——Shared Memory——情况就不一样了。
核心思路是:把一块 32 × 32 的数据先搬到 Shared Memory Tile 里,在 Shared Memory 中完成访问模式的转换,再搬回 Global Memory。
具体流程:
- Lane 沿 x 方向从 Global Memory Coalesced Load 一行数据到寄存器。
- 将数据 按 row-major 写入 Shared Memory Tile:
tile[threadIdx.y][threadIdx.x]。 __syncthreads()——等待所有线程写入完成。- 从 Shared Memory 按转置后的坐标读取:
tile[threadIdx.x][threadIdx.y]。 - 将数据 Coalesced Store 到 Global Memory 的转置位置。
这里面有一个容易被忽略的设计细节。CUDA Best Practices 中矩阵转置的经典配置是:
1#define TILE_DIM 32
2#define BLOCK_ROWS 8
3
4dim3 block(32, 8); // 256 threads
5dim3 grid(N / TILE_DIM, M / TILE_DIM);一个 Block 有 256 个 Thread(8 个 Warp),但要处理一个 32 × 32 = 1024 个元素的 Tile。Thread 数量和数据元素数量不一样——每个 Thread 通过一个 for (int k = 0; k < TILE_DIM; k += BLOCK_ROWS) 循环处理 4 个元素(32 / 8 = 4)。
为什么不直接用 32 × 32 = 1024 个 Thread?因为每个 SM 对驻留 Thread 数有上限(A100 是 2048),1024 Thread 的 Block 意味着每个 SM 最多驻留 2 个 Block,灵活性很差。256 Thread 的 Block 让调度器有更多余地,同时每个 Thread 多做几次循环迭代并不会增加太多开销。
回到关键问题:Shared Memory Tiling 为什么能让 Load 和 Store 都 Coalesced?
- Load(Global → Shared):Lane 沿 x 方向,Global Memory 地址连续——Coalesced。
- Store(Shared → Global):输出坐标交换了
blockIdx.x和blockIdx.y,Lane 沿 x 方向在输出矩阵的行方向连续——也是 Coalesced。
转置发生在 Shared Memory 的读写坐标交换上。写入时 tile[ty][tx],读取时 tile[tx][ty]——tx 和 ty 互换了角色。Shared Memory 作为中间层,承担了数据重排的功能。
我之前一直有个误解,觉得 Shared Memory Tiling 的好处主要是"Shared Memory 比 Global Memory 快"。但这不是全部——Shared Memory 的核心价值在于提供了一个 Block 内线程都能访问的数据重排空间。 通过一次 row-major 写入、一次 column-major 读取(加上一个 __syncthreads() 保证同步),让 Global Memory 两端的访问都满足 Coalescing。
额外的 Shared Memory 读写和同步当然有开销。但相比 Naive Transpose 中每次 Store 都是 32-way Strided Access 造成的带宽浪费,这个开销微不足道。
Shared Memory 也有自己的访问瓶颈#
到这里,Global Memory 的 Coalescing 问题通过 Shared Memory Tiling 解决了。但 Shared Memory 自身还有一个不同层次的问题:Bank Conflict。
这部分的理论推导我在 Memory Banking 那篇里详细写过。这里只做简要回顾,重点放在它和 Coalescing 的区别以及实验验证上。
A100 的 Shared Memory 分为 32 个 Bank,每个 Bank 宽度 4 Bytes。对于 FP32 访问:
$$ \text{Bank} = (\text{Word Address}) \bmod 32 $$一个 Warp 的 32 个 Lane 同时发出 Shared Memory 请求。如果 32 个请求落在 32 个不同 Bank,硬件可以一个周期全部完成。如果多个 Lane 访问同一个 Bank 的不同地址,就会产生 Bank Conflict——这些请求必须串行处理。
经典的问题出在 Tiled Transpose 的 Shared Memory 读取阶段。
1__shared__ float tile[32][32];
2// 读取:tile[threadIdx.x][threadIdx.y]
3// Warp 内 threadIdx.y 固定,threadIdx.x 从 0 到 31
Row-major 布局下,tile[row][col] 的 Word Index = row * 32 + col,因此:
col 固定时,32 个 Lane 不论 row 是多少,全部落在同一个 Bank——32-way Bank Conflict,最差情况。
解决方案是 Padding:
1__shared__ float tile[32][33]; // 多一列 Padding
每行 33 个 word,\( 33 \bmod 32 = 1 \),相邻行的起始 Bank 位置错开一格:
$$ \text{Bank} = (\text{row} \times 33 + \text{col}) \bmod 32 = (\text{row} + \text{col}) \bmod 32 $$col 固定、row 从 0 到 31 时,Bank 值依次为 \( \text{col}, \text{col}+1, \ldots, \text{col}+31 \) 对 32 取模——恰好覆盖所有 32 个 Bank。无冲突。
关于这个推导的完整过程——为什么 32 列会冲突、为什么 33 列不会、以及行宽 \( S \) 与 Bank 数的 \( \gcd(S, 32) \) 关系——可以看 Memory Banking 那篇的详细分析。
这里要强调一点:Bank Conflict 和 Global Memory Coalescing 是两个不同层次的问题。
| Global Memory Coalescing | Shared Memory Bank Conflict | |
|---|---|---|
| 发生位置 | DRAM / HBM → L2 → L1 | SM 片上 SRAM |
| 关注的硬件单元 | Sector(32B 传输粒度) | Bank(32 个独立访问端口) |
| 影响因素 | Warp 地址连续性、对齐 | Warp 地址的 Bank 分布 |
| 解决手段 | 调整 Lane → Data 映射 | 调整 Shared Memory 物理布局(Padding) |
解决了 Coalescing 并不意味着 Bank Conflict 也没了,反过来也一样。Tiled Transpose 不做 Padding 时,Global Memory 两端都是 Coalesced 的,但 Shared Memory 的列方向读取有 32-way Bank Conflict,性能仍然会打很大的折扣。
A100 实验一:Coalescing 的影响有多大#
理论分析完了,用 A100 上的实际 benchmark 来验证。
实验配置#
| 配置 | 数值 |
|---|---|
| GPU | NVIDIA A100-SXM4-40GB |
| Compute Capability | 8.0 |
| SM 数量 | 108 |
| CUDA Architecture | sm_80 |
| Driver | 575.57.08 |
| CUDA Version | 12.9 |
| Matrix | 4096 × 4096 FP32 |
| Matrix Size | 64 MiB |
| Tile | 32 × 32 |
| Block | 32 × 8(256 Threads,8 Warps) |
| Grid | 128 × 128 = 16384 CTAs |
每个 CTA 处理一个 32 × 32 的 Tile。
Benchmark 配置:Warmup 5 次,Iterations 20 次,Repeats 5 组,取 5 组结果的 Median。
三个 Kernel#
- Copy:
B[y][x] = A[y][x]。Load 和 Store 都是 Coalesced,作为带宽上限参考。 - Naive Transpose:
B[x][y] = A[y][x]。Load Coalesced,Store Strided。 - Tiled Transpose:通过 Shared Memory Tile 重排,Load 和 Store 都 Coalesced(暂时不加 Padding,先只看 Coalescing 的效果)。
三个 Kernel 的 Correctness Check 全部 PASS。
结果#
| Kernel | ms/launch | Effective GB/s |
|---|---|---|
| Copy | 0.1029 | 1304.85 |
| Naive Transpose | 0.5919 | 226.75 |
| Tiled Transpose | 0.1052 | 1276.26 |
Naive Transpose 比 Copy 慢 \( 0.5919 / 0.1029 \approx 5.75 \) 倍。
Tiled Transpose 比 Naive Transpose 快 \( 0.5919 / 0.1052 \approx 5.63 \) 倍。
Tiled Transpose 的 Effective GB/s 已经非常接近 Copy(1276 vs 1305),说明通过 Shared Memory 重排,Global Memory 两端的访问效率基本达到了理论上的 Coalesced 水平。
Effective GB/s 的含义#
这里必须解释一下 Effective GB/s 怎么算的:
$$ \text{Effective GB/s} = \frac{\text{Logical Bytes Read} + \text{Logical Bytes Written}}{\text{Execution Time}} $$对于 4096 × 4096 FP32 矩阵的 Copy 或 Transpose:
$$ \text{Logical Bytes} = 2 \times 4096 \times 4096 \times 4 = 134{,}217{,}728 \text{ Bytes} = 128 \text{ MiB} $$Effective GB/s 是根据逻辑数据量算的有效带宽,不等于 Nsight Compute 实际测量的 DRAM/HBM 物理带宽。 Naive Transpose 因为 Non-coalesced Store,实际从 HBM 搬运的数据量远大于逻辑数据量(每次 Store 触及一个完整 Sector 但只写 4 Bytes),Effective GB/s 反映的是这种浪费被分摊后的有效利用率。
Nsight Compute 证据#
NCU 对 Naive Transpose 的诊断:
Global Stores 的 Memory Access Pattern 不理想,平均每个 Sector 传输的 32 Bytes 中,每个 Thread 只利用 4 Bytes。
这和理论分析完全吻合——每个 Lane 的 Store 地址相距一整行(16384 Bytes),每次 Store 都触及一个独立的 Sector,但只写入其中 4 Bytes。
NCU 的 Memory Throughput 对比:
| Kernel | NCU Memory Throughput |
|---|---|
| Copy | ~1.31 TB/s |
| Tiled Transpose | ~1.31 TB/s |
| Naive Transpose | ~207.49 GB/s |
Copy 和 Tiled Transpose 几乎一样,Naive Transpose 只有它们的约 16%。这组数据直接说明了 Coalescing 对带宽利用的决定性影响。
A100 实验二:Bank Conflict 的代价#
接下来验证 Bank Conflict 和 Padding 的效果。
实验设计#
两个 Kernel 的逻辑完全相同,只有 Shared Memory 声明不同:
1// Unpadded
2__shared__ float tile[32][32];
3
4// Padded
5__shared__ float tile[32][33];其他配置和实验一一致,Benchmark 配置略有调整(Iterations 30,Repeats 7,取 Median)。两个 Kernel Correctness 均 PASS。
结果#
| Kernel | ms/launch | Effective GB/s |
|---|---|---|
| Unpadded | 0.184491 | 727.50 |
| Padded | 0.106837 | 1256.28 |
仅仅把 Shared Memory 的物理行宽从 32 改成 33——多 Padding 一个 float(4 Bytes),每个 Tile 的 Shared Memory 从 4096 Bytes 增加到 4224 Bytes——就获得了 1.73 倍的性能提升。
需要注意:这是在本实验特定的 Transpose Kernel 和 A100 上的结果。Bank Conflict 的实际影响取决于具体的访问模式和 Kernel 特性,1.73 倍不是一个通用数字。
Ptxas 编译信息#
| 指标 | Unpadded | Padded |
|---|---|---|
| Registers / Thread | 24 | 24 |
| Shared Memory | 4096 Bytes | 4224 Bytes |
| Spill Stores | 0 | 0 |
| Spill Loads | 0 | 0 |
Padding 没有增加寄存器使用量,也没有产生 Spill。额外的 128 Bytes Shared Memory 对于 A100 每个 SM 164 KB 的 Shared Memory 容量来说微不足道。
Nsight Compute:Bank Conflict 的硬件证据#
这是整篇文章里最直接的硬件证据。
NCU 对 Unpadded Kernel 的诊断:
SharedMemoryConflicts: The memory access pattern for shared loads causes on average a 32.1-way bank conflict. 524,288 shared load requests. 16,255,628 bank conflicts. 96.55% of the overall shared-load wavefronts.
几点解释:
- 32.1-way 是 NCU 跨大量 Shared Load Request 汇总的平均冲突诊断。它不是说单个 Warp 有 32.1 个 Lane(Warp 固定 32 Lane),而是统计意义上的平均冲突程度。
- 16,255,628 是 NCU 统计到的 Bank Conflict 总次数。
- 96.55% 是该诊断中冲突请求占对应统计口径的比例。
此外,NCU 的 UncoalescedSharedAccess 诊断报告了 16,252,928 个 excessive wavefronts,占其对应统计口径总 wavefronts 的约 94%。这两个指标的统计口径不同,不应混为同一个比例。
Padded Kernel 的 NCU 导出摘要中没有出现对应的 SharedMemoryConflicts 告警。结合理论推导(\( \gcd(33, 32) = 1 \),32 个 Lane 分散到 32 个不同 Bank),Padding 确实消除了经典的 32-way Bank Conflict。
性能指标对比#
| Metric | Unpadded | Padded |
|---|---|---|
| Duration | 182.82 μs | 93.54 μs |
| Warp Cycles / Issued Instruction | 225.22 | 106.62 |
| Achieved Occupancy | 94.34% | 90.67% |
| Active Warps / SM | 60.38 | 58.03 |
| Registers / Thread | 24 | 24 |
| DRAM Throughput | 42.71% | 82.64% |
| Memory Throughput | 664.14 GB/s | 1.28 TB/s |
NCU Profiling 下的执行时间加速比:\( 182.82 / 93.54 \approx 1.95\times \)(NCU Profiling 环境和 Benchmark 环境的绝对时间有差异,但趋势一致)。
这里有一个反直觉的现象值得注意:Padded 的 Achieved Occupancy 更低(90.67% vs 94.34%),但性能明显更好。
原因是 Padding 增加了每个 Block 的 Shared Memory 使用量(4096 → 4224 Bytes),理论上每个 SM 能同时驻留的 Block 数可能略微下降。但消除 Bank Conflict 带来的吞吐提升远远大于 Occupancy 略降的代价。
这和上一篇 Latency Hiding 中的结论一致:Occupancy 是隐藏延迟的资源条件,不是性能本身。 90% 和 94% 的 Occupancy 差异对延迟隐藏的影响很小,但 32-way Bank Conflict 导致的 Shared Memory 吞吐损失是致命的。
Stall 分析也提供了一些补充观察:
- Unpadded:最大 Stall 来源是 MIO Queue,约 105 cycles,占平均 225.2 cycles/instruction 的约 46.6%。MIO Queue 是 Shared Memory 请求的排队路径,Bank Conflict 导致大量请求排队等待。
- Padded:最大 Stall 来源变成 L1TEX Scoreboard,约 83 cycles,占平均 106.6 cycles/instruction 的约 77.8%。L1TEX Scoreboard 涉及多种内存操作(包括 Global Memory Load/Store 和 Shared Memory),不能仅凭这个 Stall 类型就断定具体的下游瓶颈一定是 DRAM。但可以看到,消除 Bank Conflict 后,瓶颈从 Shared Memory 排队转移到了其他内存操作上。
写在最后#
把这篇和上一篇串起来看,GPU 性能优化有两条不同但互补的线索。
上一篇关注的是 延迟暴露问题:一次 HBM 访问要等几百个 cycle,GPU 靠大量 Resident Warp 交替执行来隐藏这段等待。Latency Hiding 解决的是"等待期间做什么"。
这一篇关注的是 访问效率问题:即使延迟被隐藏了,如果访问模式不好,硬件搬运的数据远多于实际需要的数据,带宽就被浪费了。
四个层次的优化手段各自解决不同的问题:
- Latency Hiding:通过 Warp 交替执行,掩盖内存延迟。
- Coalescing:通过让 Warp 内的地址连续,减少 Global Memory Transaction 数量。
- Shared Memory Tiling:通过数据重排,让 Global Memory 的输入和输出两端都满足更好的访问模式。
- Padding:通过改变 Shared Memory 的物理布局,消除 Bank Conflict。
它们不是互相替代的关系——Matrix Transpose 需要同时做好 Coalescing(Tiling)和 Bank Conflict 消除(Padding)才能接近硬件带宽上限。这两个层次的问题独立存在,需要分别分析和解决。
参考资料#
- NVIDIA. An Efficient Matrix Transpose in CUDA C/C++.
- NVIDIA. CUDA C++ Programming Guide — Shared Memory.
- NVIDIA. CUDA C++ Best Practices Guide — Memory Optimizations.
- NVIDIA. Nsight Compute Documentation.
- GPU Execution Model:为什么大量 Warps 能隐藏内存延迟?
- Memory Banking:为什么不同的内存地址,不一定能同时访问?
- GPU 的数据存在哪?——从 HBM 到片上存储的存储层级