↓ 跳过正文
  1. Posts/

GPU Memory Access: Coalescing, Shared Memory Tiling and Bank Conflicts

·6139 字·13 分钟

上一篇写 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 个 FP32128B 连续区域4
32 Lane stride=2 读取 FP32256B 区域,每个 Sector 只用一半8
32 Lane 逆序读取 32 个连续 FP32128B 连续区域(顺序不影响 Sector 归属)4
32 Lane 全部读同一个 FP32 地址1 个 Sector 内的同一地址1
Coalesced Access 与 Stride-2 Access 的 Sector 映射对比

第三行是我一开始容易搞混的地方: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。

Shared Memory Tiling:两阶段数据重排

具体流程:

  1. Lane 沿 x 方向从 Global Memory Coalesced Load 一行数据到寄存器。
  2. 将数据 按 row-major 写入 Shared Memory Tile:tile[threadIdx.y][threadIdx.x]。
  3. __syncthreads()——等待所有线程写入完成。
  4. 从 Shared Memory 按转置后的坐标读取:tile[threadIdx.x][threadIdx.y]。
  5. 将数据 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,因此:

$$ \text{Bank} = (\text{row} \times 32 + \text{col}) \bmod 32 = \text{col} \bmod 32 = \text{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 CoalescingShared Memory Bank Conflict
发生位置DRAM / HBM → L2 → L1SM 片上 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 来验证。

实验配置
#

配置数值
GPUNVIDIA A100-SXM4-40GB
Compute Capability8.0
SM 数量108
CUDA Architecturesm_80
Driver575.57.08
CUDA Version12.9
Matrix4096 × 4096 FP32
Matrix Size64 MiB
Tile32 × 32
Block32 × 8(256 Threads,8 Warps)
Grid128 × 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。

结果
#

Kernelms/launchEffective GB/s
Copy0.10291304.85
Naive Transpose0.5919226.75
Tiled Transpose0.10521276.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 对比:

KernelNCU 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。

结果
#

Kernelms/launchEffective GB/s
Unpadded0.184491727.50
Padded0.1068371256.28
$$ \text{Speedup} = \frac{0.184491}{0.106837} \approx 1.73\times $$

仅仅把 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 编译信息
#

指标UnpaddedPadded
Registers / Thread2424
Shared Memory4096 Bytes4224 Bytes
Spill Stores00
Spill Loads00

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。

性能指标对比
#

MetricUnpaddedPadded
Duration182.82 μs93.54 μs
Warp Cycles / Issued Instruction225.22106.62
Achieved Occupancy94.34%90.67%
Active Warps / SM60.3858.03
Registers / Thread2424
DRAM Throughput42.71%82.64%
Memory Throughput664.14 GB/s1.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)才能接近硬件带宽上限。这两个层次的问题独立存在,需要分别分析和解决。

参考资料
#

相关文章

Memory Banking:为什么不同的内存地址,不一定能同时访问?

·5210 字·11 分钟
之前写 Register Tiling 和 Cache Tiling 的时候,提到了 GPU 上的高性能 GEMM kernel 会把输入矩阵的 tile 搬到 Shared Memory。当时只关注了 data reuse 的部分。 后来在看矩阵转置的 CUDA 实现时,碰到了一行让我停下来的代码: 1__shared__ float tile[32][33]; // 为什么是 33? 这是一个经典的 Padding trick,用来消除 Shared Memory 的 Bank Conflict。道理我大概知道,但要我解释清楚——为什么 32 列会冲突?为什么 33 列就不冲突?32 和 33 这两个数字的差异到底对应什么硬件行为?——我发现自己说不出来。

Numerical Stability in ML Systems:从浮点误差到 GPU 计算

起因:H20 上 FP64 只有 1 TFLOPS,但计算要的是双精度 # 写这篇笔记的直接原因是一块 H20。业务里有一块对数值精度敏感的计算,需要接近 FP64 的结果,但 H20 的 FP64 算力只有 1 TFLOPS。对照同一张卡的其他规格,这个数字有多别扭很直观:FP32 是 44 TFLOPS,FP16/BF16 Tensor Core 是 148 TFLOPS,FP8 是 296 TFLOPS,FP64 只有 1——不到 FP32 的四十分之一,而满血的 H100 上 FP64 是 34 TFLOPS。

从 Register Tiling 到 Cache Tiling:理解高性能计算中的 Data Reuse

最近在看 CMU 15-442 的 Hardware Acceleration。课件翻到 Register Tiling,一个 2×3 output tile 的例子。我盯着那页 slide 看了一会儿——Register Tiling 这个词不陌生,但要我说清楚它和 Cache Tiling 的区别,以及它们到底在优化什么,我发现自己的理解一直停在"把矩阵切成小块"这个表面。