跳转到正文
Retep's
返回

[TIL] GPU 共享内存 Swizzle

编辑文章

本文由英文原文翻译。代码、公式与技术名称保留原文。

以前我对 swizzle 的理解很模糊,只知道它是“让 GPU 访存更快的布局技巧”。这说法太宽泛。在 CUDA kernel 和矩阵乘法中,swizzle 主要针对共享内存,原因很具体:共享内存划分为多个 bank。

主要问题在跨步或按列访问:同一 warp 的多个线程可能意外命中同一个 bank。swizzle 在重复的小块内调整物理布局,使相同逻辑访问分散到不同 bank。连续访问通常本来就很好。

共享内存 Bank

可以这样理解 NVIDIA 共享内存:

number of banks=32\text{number of banks} = 32 bank width=4 bytes\text{bank width} = 4\ \text{bytes}

给定字节地址,bank 索引近似为:

bank=⌊byte address4⌋ mod 32\text{bank} = \left\lfloor \frac{\text{byte address}}{4} \right\rfloor \bmod 32

对齐的 float32 数组每元素 4 字节,按 i 索引时:

byte address=base+4i\text{byte address} = \text{base} + 4i

忽略对齐基址,bank 为:

bank=i mod 32\text{bank} = i \bmod 32

因此连续 float32 访问很高效。warp 的 32 个 lane 分别读取 smem[0] 到 smem[31],正好命中 bank 0 到 31:

int lane = threadIdx.x % 32;
float x = smem[lane];

逻辑上:

lane 0  -> smem[0]  -> bank 0
lane 1  -> smem[1]  -> bank 1
...
lane 31 -> smem[31] -> bank 31

这里没有 bank conflict。

跨步访问则可能很差,例如:

int lane = threadIdx.x % 32;
float x = smem[lane * 32];

所有 lane 都映射到同一个 bank:

lane 0  -> smem[0]    -> bank 0
lane 1  -> smem[32]   -> bank 0
lane 2  -> smem[64]   -> bank 0
...
lane 31 -> smem[992]  -> bank 0

这是 32 路 bank conflict。warp 要求同一个 bank 提供多个不同地址,访问可能接近串行服务。这就是共享内存 swizzle 要解决的核心问题。

什么是 Lane?

lane 是线程在 warp 内的位置。在 NVIDIA GPU 上:

1 warp=32 threads1\ \text{warp} = 32\ \text{threads}

因此通常讨论 lane 0 到 31:

lane 0  = first thread in the warp
lane 1  = second thread in the warp
...
lane 31 = last thread in the warp

warp 执行共享内存加载时,所有活跃 lane 一起执行同一条指令,但可以计算不同地址。因此 bank conflict 取决于 lane 到地址的映射。

单个线程加载共享内存本身不会产生 lane 间冲突。冲突发生在同一 warp 指令的多个 lane 访问不同地址,而这些地址映射到同一个 bank 时。

因此,“加载只有 16B”并不意味着 swizzle 无关紧要。一个 lane 的 16B 向量加载涉及四个 4B bank 槽位。所有 lane 加载连续向量时可能没有问题,但跨步向量访问的每次事务仍可能冲突。

连续访问与按列访问

全局内存通常关注合并访存:相邻 lane 访问相邻地址,使硬件合并为高效事务。典型模式为:

lane 0 -> A[i + 0]
lane 1 -> A[i + 1]
lane 2 -> A[i + 2]
...

共享内存位于片上,但按 bank 组织。除了地址是否连续,还要看 lane 是否分散到不同 bank。

矩阵乘法自然体现这一点:先从全局内存合并加载 tile 到共享内存,之后可能按列、转置或 tensor core fragment 布局消费。bank conflict 常出现在后一个阶段。

也就是说,从全局内存搬到共享内存,与从共享内存读出是两个布局问题。前者希望相邻 lane 访问相邻全局地址,后者希望 warp 内 lane 命中不同共享内存 bank。swizzle 主要针对后者。

Swizzle 做了什么?

swizzle 改变逻辑共享内存坐标对应的物理地址。原来是:

physical offset=row⋅stride+col\text{physical offset} = \text{row} \cdot \text{stride} + \text{col}

现在应用一个小型置换:

physical offset=swizzle(row,col)\text{physical offset} = \text{swizzle}(\text{row}, \text{col})

具体公式取决于 GPU 指令、库、数据类型和布局。通常将 tile 分成固定字节大小的组,例如 64B 或 128B,再置换组内的低位地址。元素留在本地组内,相同置换模式重复应用到下一组。

若 (G) 为 swizzle 组大小,字节偏移可以分解为组基址和局部偏移:

group base=⌊offsetG⌋G\text{group base} = \left\lfloor \frac{\text{offset}}{G} \right\rfloor G local offset=offset mod G\text{local offset} = \text{offset} \bmod G

swizzle 改变局部偏移,保留组基址:

physical offset=group base+permute(local offset)\text{physical offset} = \text{group base} + \text{permute}(\text{local offset})

许多 swizzle 可以理解为把较高的坐标位 XOR 到较低地址位或 bank 位。二维示意通常为:

swizzled col=col⊕f(row)\text{swizzled col} = \text{col} \oplus f(\text{row})

于是:

physical offset=row⋅stride+swizzled col\text{physical offset} = \text{row} \cdot \text{stride} + \text{swizzled col}

目的在于打破按列访问时所有 lane 命中同一 bank 的模式。逻辑矩阵形状不变,只改变共享内存中的物理放置。

64B 与 128B Swizzle

“64B swizzle”或“128B swizzle”通常指局部置换的字节粒度:

64B swizzle:permute offsets inside each 64-byte group\text{64B swizzle}: \text{permute offsets inside each 64-byte group} 128B swizzle:permute offsets inside each 128-byte group\text{128B swizzle}: \text{permute offsets inside each 128-byte group}

128B 很自然,因为完整 warp 每 lane 读取一个 float32,总共访问:

32 lanes×4 bytes=128 bytes32\ \text{lanes} \times 4\ \text{bytes} = 128\ \text{bytes}

所以对许多 warp 级共享内存模式,128B 是覆盖全部 bank 的自然跨度。如果访问和 tile 形状本身按 128B 分块,128B swizzle 往往合适。

但 128B 并非总更好。如果逻辑行或重复局部块只有 64B 宽,128B swizzle 可能跨过应当保持独立的边界,此时 64B 更合适。可以把它理解为匹配访问的自然宽度:选择不跨越逻辑边界、又能覆盖当前加载或存储对象的最大组。

数据类型影响形状

数据类型的字节大小决定 64B 或 128B swizzle 组中容纳多少元素。

对于 float32:

1 element=4 bytes1\ \text{element} = 4\ \text{bytes} 128B=32 float32 elements128\text{B} = 32\ \text{float32 elements} 64B=16 float32 elements64\text{B} = 16\ \text{float32 elements}

对于 float16:

1 element=2 bytes1\ \text{element} = 2\ \text{bytes} 128B=64 float16 elements128\text{B} = 64\ \text{float16 elements} 64B=32 float16 elements64\text{B} = 32\ \text{float16 elements}

因此相同字节级 swizzle,对不同 dtype 对应不同逻辑形状。float32 的 128B atom 可以是 4 x 8,因为包含 32 个元素:

4×8×4B=128B4 \times 8 \times 4\text{B} = 128\text{B}

而 float16 的 128B 可以是 8 x 8,因为包含 64 个元素:

8×8×2B=128B8 \times 8 \times 2\text{B} = 128\text{B}

所以 swizzle 模式要与 dtype、tile 形状以及消费 tile 的指令一起选择。

Atom

atom 是最小的重复布局块。大 tile 通过重复 atom 构建,swizzle 应用于每个 atom 内部。

atom 携带固定内部布局,更大 tile 就是多个 atom 的拼接。

128B swizzle 的 atom 常包含 128B 数据,但二维形状仍可选择。对于 float32,128B 是 32 个元素,因此以下形状字节数相同:

1 x 32 float32 = 128B
2 x 16 float32 = 128B
4 x 8  float32 = 128B
8 x 4  float32 = 128B

但它们并不等价。正确 atom 形状取决于 lane 映射和读写指令。

例如,4 x 8 的 float32 tile 包含:

4×8×4B=128B4 \times 8 \times 4\text{B} = 128\text{B}

所以它可以作为一个 128B atom。

8 x 16 的 float32 tile 包含:

8×16×4B=512B8 \times 16 \times 4\text{B} = 512\text{B}

若 atom 形状为 4 x 8,整个 tile 就有四个 atom:

512B128B=4\frac{512\text{B}}{128\text{B}} = 4

swizzle 在四个 atom 内分别执行,通常不会将第一个 atom 的值混入第二个。可以这样理解:

physical address=atom base(atom id)+swizzled local offset(local coordinate)\text{physical address} = \text{atom base}(\text{atom id}) + \text{swizzled local offset}(\text{local coordinate})

swizzle 是局部变换,atom 平铺则把该局部模式重复应用到整个大 tile。

Lane 映射如何与 Swizzle 配合?

atom 形状重要,是因为硬件指令有预期的 lane 到元素访问模式。某种模式下 4 x 8 能很好地分散 bank,另一种模式则可能更适合 2 x 16 或 1 x 32。

假设逻辑访问类似按列访问,行主序下 lane l 访问:

il=32li_l = 32l

于是:

bankl=il mod 32=0\text{bank}_l = i_l \bmod 32 = 0

每个 lane 都一样,这就是 bank conflict。

swizzle 将相同逻辑坐标映射到不同物理偏移:

il′=swizzle(il)i_l' = \text{swizzle}(i_l)

目标是让下面的值:

bankl=⌊byte address(il′)4⌋ mod 32\text{bank}_l = \left\lfloor \frac{\text{byte address}(i_l')}{4} \right\rfloor \bmod 32

随 lane 变化。理想情况下,活跃 lane 分散到多个 bank,而非全部冲突在同一个 bank。

这就是 lane 与 swizzle 的联系:lane 映射决定一条 warp 指令同时访问哪些逻辑值;swizzle 改变这些值的物理位置;bank 映射决定访问能否无冲突执行,或因冲突而串行化。

要点

swizzle 的主要目标是让重复的共享内存访问对 bank 更友好,尤其是跨步、按列、转置或 tensor core fragment 形状的访问。连续逐行访问通常已经很好。

理解时应从 warp 指令出发:各 lane 同时访问哪些逻辑值?没有 swizzle 时命中哪些 bank?当前 dtype 在 64B/128B 中容纳多少元素?哪种 atom 形状匹配指令模式?这些问题清楚后,swizzle 就是 atom 内的小型地址置换,目的是避免 warp 各 lane 争用同一个共享内存 bank。


编辑文章
分享文章:

上一篇
[TIL] 理解 IM2COL
下一篇
[TIL] TileLang 逐元素操作与向量化