tensor core fragment 布局:线程-数据映射、ldmatrix 与 mma.sync 的配合
更新时间:2026-10-04。前面 矩阵乘法分块 讲过 GEMM 怎么按 block/warp 两级 tile 切分、数据怎么在 global memory 与 shared memory 之间搬运;shared memory bank 冲突 讲过 shared memory 的 bank 结构与 swizzle 消冲突。这两篇解决的是「数据搬得快」,但数据搬到 shared memory 之后还有一道关卡:tensor core(张量核)不是一个线程算一个元素的单元,它是一条 warp 32 个线程合起来啃一小块矩阵的硬件,每个线程必须恰好捏着硬件期望的那几个元素。这个「哪个线程拿哪几个数」的规则,就是 tensor core fragment 布局。搞不懂它,手写 tensor core kernel 时结果永远是错的,而且错得很有规律。本篇把 fragment 布局的映射规则、WMMA 与 mma.sync 两层接口、ldmatrix 的搬运配合、以及排错方法讲透。
本文要回答的问题
- tensor core fragment 布局到底是什么,为什么矩阵元素要摊到 32 个线程的寄存器里?
- mma.sync 一条指令算什么形状的矩阵乘,A/B/C 三种 fragment 各自的线程-数据映射长什么样?
- WMMA API 和 mma.sync PTX 是什么关系,各自什么时候用?
- ldmatrix 怎么把 shared memory 里的 tile 一次性摆进正确线程的寄存器,布局对不上会怎样?
- 手写 tensor core kernel 时布局错了有什么特征,怎么快速定位?
一、fragment 是什么:一条 warp 合伙持有一块小矩阵
先用一句话立住概念。tensor core 做的基本运算是 D = A × B + C,其中 A、B、C、D 都是小矩阵(比如 16×8、8×16 这种量级)。这个运算不是由某个线程单独完成的,而是整条 warp 的 32 个线程作为一个整体,在一个指令周期里共同完成。硬件要求:指令发射时,A 矩阵的所有元素已经按固定规则摊在 32 个线程的寄存器里,B、C 同理;指令结束后,D 的元素也按固定规则落回 32 个线程的寄存器。
这个「摊在寄存器里的小矩阵」就叫 fragment(片段)。它不是一块连续内存,而是一个逻辑上的矩阵 + 物理上的线程-寄存器映射规则。映射规则由指令集定义死,程序员没有选择权,只能让数据去迁就硬件。
上图是理解全篇的核心:fragment 布局本质上是一张查表规则。以 m16n8k16 的 fp16 乘 fp32 累加为例,D/C fragment 里每个线程持 4 个 fp32,A fragment 每线程持 8 个 fp16(4 个 32 位寄存器、每寄存器打包 2 个 fp16),B fragment 每线程持 4 个 fp16。PTX 文档用「row = groupID 这类公式 + 线程分组图」的方式给出每个元素落在哪个线程的哪个寄存器,这套公式对每种形状、每种精度组合都不同。
为什么硬件要这么设计?因为 tensor core 内部是一个小的脉动阵列或点积树网络,数据从 32 个线程的寄存器堆直接喂进阵列的固定端口——线程号就是端口号。映射规则其实就是阵列布线的镜像。理解了这一点,就不会再问「为什么不能让我按行连续放」这种问题:硬件的数据通路是定死的,软件能做的只是按规矩摆数据。
二、mma.sync 的账本:形状、精度与三种 fragment 的映射细节
mma.sync 是 PTX 层直接驱动 tensor core 的指令,全名形如 mma.sync.aligned.m16n8k16.row.col.f32.f16.f16.f32。这一串修饰符每个都是硬约束:
m16n8k16:这一条指令算 D(16×8) = A(16×16) × B(16×8) + C(16×8);row.col:A 按行主序(row-major)布局、B 按列主序(column-major)布局——注意这说的是 fragment 内部元素编号的参照系,不是内存里的存储顺序;f32.f16.f16.f32:D 和 C 是 fp32,A 和 B 是 fp16。
Ampere(sm_80)之后常见形状有 m16n8k8(fp16 最小形)、m16n8k16(fp16 主力形)、m16n8k8/m16n8k16 的 int8 变体(k 更大,如 m16n8k32)。Hopper 引入 wgmma,账本又换了一套,本篇聚焦 Ampere/Ada 这一代的 mma.sync,它也是手写 kernel 最常见的一层。
三种 fragment 的映射规则,拿 m16n8k16 fp16 这个主力形状说细一点:
D/C fragment(16×8 fp32,每线程 4 个):32 个线程按 4 行 × 8 组划分。线程号 t 的「组号」groupID = t >> 2(0~7),组内位置 threadID_in_group = t % 4(0~3)。线程 t 持有的 4 个元素落在:行 = groupID 和 groupID + 8,列 = threadID_in_group × 2 和 +1。也就是每个线程捏着上下两行、每行相邻的两个元素。
A fragment(16×16 fp16,每线程 8 个):同样的 groupID 划分,线程 t 拿行 groupID 与 groupID+8 上的各 4 个连续 fp16,列起点是 threadID_in_group × 4 处。8 个 fp16 打包进 4 个 32 位寄存器。
B fragment(16×8 fp16,每线程 4 个):因为 B 是 col 参照系,映射方向转了一下:线程 t 拿列 threadID_in_group 相关位置上的元素,行分布在 k 维的两半。
上图把三种 fragment 的映射共性抽了出来:一切都从「8 组 × 4 线程」的划分出发。记映射不用背全部公式,背这个划分骨架,再记「D/C 每线程两行两列小块、A 每线程两行四列小块、B 转置视角」,细节现场查 PTX ISA 文档的 fragment 图即可。工程里更常见的做法是直接抄 CUTLASS 或成熟 kernel 里的注释表,但脑子里的骨架能帮你看懂抄的是什么。
| 指令形状 | 精度组合 | A 每线程 | B 每线程 | D/C 每线程 | 常见用途 |
|---|---|---|---|---|---|
| m16n8k8 | fp16 乘 fp32 累加 | 4 | 2 | 4 | Volta 兼容路径 |
| m16n8k16 | fp16/bf16 乘 fp32 累加 | 8 | 4 | 4 | Ampere 主力 |
| m16n8k32 | int8 乘 int32 累加 | 16 | 8 | 4 | 量化推理 |
| m16n8k16 | fp8 乘 fp32 累加 | 8 | 4 | 4 | Ada/Hopper 推理 |
表里有个值得停一秒的规律:乘加密度越高(k 越大、精度越低),每线程要喂的元素越多。int8 的 m16n8k32 里 A fragment 每线程 16 个元素、打包进 4 个寄存器,每寄存器塞 4 个 int8。这意味着低精度 kernel 的寄存器压力并没有因为元素变小而放松——tensor core 吃数据的速度是固定的,精度减半只是把同样位宽的寄存器喂进了翻倍的元素个数。这也是 occupancy 与寄存器压力 在 tensor core kernel 里格外紧张的原因之一:fragment 本身就是寄存器大户,一个 warp 同时持有 A、B 和累加中的 C,累加器 fragment 还会随 tile 的 N 维成倍增长。
三、WMMA 与 mma.sync:同一硬件的两层接口
CUDA C++ 里还有一层官方封装:WMMA API(nvcuda::wmma 命名空间下的 load_matrix_sync、mma_sync、store_matrix_sync)。它和 mma.sync 的关系是「高级语言和汇编」的关系:WMMA 让你声明一个 fragment<matrix_a, 16, 16, 16, half, row_major> 对象,调用 load_matrix_sync(frag, ptr, ldm) 把内存里的数据装进来,布局映射由编译器替你完成,你永远看不到哪个线程拿了哪几个元素。
这层抽象的代价是灵活性。WMMA 的 fragment 是不透明类型,你不能指定「这个 fragment 的数据从 shared memory 的 swizzle 地址来」之外的精细控制,想跨 warp 复用 fragment、想把 fragment 里的元素直接喂给非 tensor core 的计算(比如 attention 里的 softmax 中间结果)都很别扭。FlashAttention 这类手写 kernel 几乎全走 mma.sync + 手工布局,原因就是它们需要把 D fragment 的元素按「行 = groupID」的规则直接摊给线程做 row-wise softmax,WMMA 的不透明 fragment 给不了这个访问。
上图的选型结论可以压成一句话:标准 GEMM 用 WMMA 或直接调 cuBLAS/cuDNN 库,要把 tensor core 和自定义逐元素计算缝在一起(融合 kernel)就必须下到 mma.sync 层,而下了这层就绕不开 fragment 布局。中间地带的读者可以先用 WMMA 把 kernel 写对,再对照 PTX 文档把 WMMA 的 load/store 换成手工布局,这是成本最低的学习路径。
四、ldmatrix:把 shared memory 数据一次摆进正确线程
mma.sync 要求数据已经在寄存器里且布局正确,那数据从 shared memory 到寄存器这段搬运谁来做?朴素的办法是每个线程按映射公式算地址、逐个 ld.shared——能跑,但慢:一条 m16n8k16 的 A fragment 每线程要 4 次 32 位装载,整条 warp 就是 128 个访存事务, bank 冲突(见 shared memory bank 冲突)还可能雪上加霜。
Ampere 给了专用指令 ldmatrix:ldmatrix.sync.aligned.m8n8.x4.shared.b16,一条指令让一条 warp 从 shared memory 搬 4 块 8×8 的 b16 矩阵,搬完自动按 mma.sync 的 fragment 布局摊到 32 个线程的寄存器里。也就是说 ldmatrix 和 mma.sync 是配套设计的:前者的输出布局恰好是后者的输入布局,中间零重排。
配合方式有个关键细节:ldmatrix 要求 32 个线程各自提供「本线程负责的那一行的起始地址」。对 .x4(一次搬 4 块 8×8)来说,线程 0~7 提供第一块的 8 个行地址,线程 8~15 提供第二块的,依此类推。于是 shared memory 侧的 tile 怎么摆,直接决定这 32 个行地址怎么算——这就是为什么 tensor core kernel 的 shared memory 布局几乎都带 swizzle:既要把 ldmatrix 的行地址算成无 bank 冲突的模式,又要让上一级 cp.async 从 global memory 写进来时也连续。
上图这条流水线是现代 tensor core kernel 的标准骨架:cp.async 搬 global→shared,ldmatrix 搬 shared→寄存器,mma.sync 算。三级之间全靠布局约定咬合——cp.async 写 shared 的 swizzle 模式、ldmatrix 行地址的计算、mma.sync 的 fragment 映射,三者必须出自同一张「布局总图」,任何一环对不上,结果就错。CUTLASS 里那些让人望而生畏的 layout algebra(Swizzle<3,3,3> 之类模板参数),干的就是用类型系统把这张图编码进去、编译期校验一致性。
举个具体的咬合例子感受下约束强度。A tile 是 16×16 fp16,在 shared memory 里按 128 字节一行摆(一行 64 个 fp16,正好四个 8×8 块并排)。ldmatrix.x4 搬 A fragment 时,线程 0~7 要给「第一列两个 8×8 块的 8 个行地址」,线程 8~15 给第二列的——地址间隔、行内偏移都要和 swizzle 的 XOR 模式一致。如果 swizzle 按 (row%8) 对列块做异或,那么行地址 = base + row×ldm + ((col_block XOR (row%8)) × 32 字节) 这类公式,写 kernel 时这套公式通常封成一个内联函数,全 kernel 只有这一处知道布局细节。把布局知识收敛到单点,是这类 kernel 能维护下去的关键。
还要点破一个常见误解:ldmatrix 不做转置之外的任意重排。它有 .trans 变体可以在搬运时转置 8×8 块(用来把 row-major 存的 B 变成 mma.sync 要的 col 视角),但也仅此而已。指望 ldmatrix 把任意乱序数据「洗」成 fragment 布局是不可能的,shared memory 侧的排布必须提前设计好。
五、手写 kernel 的布局排错:错得很有规律是好消息
手写 tensor core kernel 时布局错误有个「好消息」:因为映射是确定性的,错了不是随机错,而是错出固定的几何图案。对照参考实现(比如 cuBLAS 或 PyTorch 的 matmul 输出)看错误结果的结构,基本能反推出错在哪一环。
几种典型症状与对应病根。第一种:输出矩阵里出现周期性的 8×8 或 16×8 块内错乱——块整体是对的,块内元素位置不对。这几乎一定是 fragment 映射记错了,比如把 D fragment 的「行 = groupID 与 groupID+8」记成「行 = groupID×2 与 +1」,写回 global memory 时元素就错位。第二种:结果像是 A 或 B 被转置了再乘——row/col 参照系搞反,或者 ldmatrix 该用 .trans 没用。第三种:输出每个 warp 负责的区域整体错位——warp 级 tile 坐标到 shared memory 偏移的换算错了,错在流水线骨架而非 fragment 本身。第四种:数值大面积正确但偶发几个元素错——大概率是 bank 冲突之外的竞态,比如 cp.async 没等到位就发 ldmatrix,缺了 cp.async.wait_group 或 __syncthreads。
上图是按症状反推病根的排查树。实战里还有两招能大幅压缩排错时间。一招是用小到能手算的尺寸:M=N=K=16,A 填 row×16+col 这种「元素值即坐标」的矩阵,B 填单位阵,那么 D 就应该等于 A——哪里不等于,错位的 (row, col) 直接告诉你哪个映射公式错了。另一招是用 printf 或小 kernel 把 fragment 内容按线程号 dump 出来,和 PTX 手册的线程分组图逐格对。这两招比在完整大 kernel 里瞪眼快一个数量级。
最后给一个工程上的落脚点:如果不是写 FlashAttention 这种融合 kernel,只是想要快 GEMM,优先用库;要写融合 kernel,建议站在 CUTLASS 的 MmaTensorOp 这层抽象上改,而不是从裸 mma.sync 起手写——fragment 布局的所有脏活 CUTLASS 都封装成了 FragmentIterator 和 layout 类型,你只需要在确实要「把手伸进 fragment」做逐元素操作时,按本篇的映射骨架访问对应寄存器。混合精度的坑(比如 fp8 的 fragment 打包顺序与 fp16 不同)另见 混合精度 FP16/BF16/FP8 与 int4 GEMM marlin kernel,低精度场景下 fragment 每寄存器打包 4 个甚至 8 个元素,映射查表时精度维度一个都不能省。
这一篇在知识体系里的位置
本篇是 GPU kernel 优化线里「tensor core 手工编程」的地基层:上游是 矩阵乘法分块(tile 怎么切、数据怎么搬——fragment 是 tile 落到 warp 之后的最后一段)、shared memory bank 冲突(swizzle 为什么要存在)、GPU 显存层次与带宽(整条数据流水线的带宽背景);同层对照 CUDA 线程层次(warp 作为整体执行的概念基础)、warp 特化流水线(把 ldmatrix/mma 流水推到极致的 Hopper 风格写法)、FlashAttention 显存分块(fragment 布局最出名的实战场);下游延伸是 CUTLASS layout algebra 与 Hopper wgmma/TMA 的新账本。
落地顺序建议:先用 WMMA 写对一个 16×16×16 的最小 kernel,把输出和 PyTorch 对拍;再下 mma.sync 层,用「元素值即坐标」的自检矩阵验证每种 fragment 映射;最后才碰 swizzle 与 cp.async 流水线。每一步都保持「能对拍」,布局错误就永远困在小 kernel 里,不会带进大工程。
总结
tensor core fragment 布局是「小矩阵元素如何摊到 warp 32 个线程寄存器」的硬件规定映射——一切从 8 组 × 4 线程的划分出发,D/C 每线程两行两列、A 每线程两行四列、B 取转置视角;WMMA 把这层映射藏进不透明 fragment 适合标准 GEMM,mma.sync 把映射摆到明面适合融合 kernel;ldmatrix 是 mma.sync 的配套搬运工,一条指令把 shared memory 的 swizzle tile 直接摆成 fragment 布局,shared 排布、ldmatrix 行地址、mma 映射三者必须出自同一张布局总图;排错时记住映射是确定性的,错误永远呈固定几何图案,用「元素值即坐标」的小矩阵对拍就能把布局 bug 按图案定位到具体公式。