Triton 算子调优:block size、num_warps、num_stages 自动调参与 roofline 的实战关系
更新时间:2026-09-30。在 CUDA 线程层级 里我们讲过 grid/block/warp 的硬件映射,在 Occupancy 与寄存器压力 里算过一个 block 占多少资源。Triton 把这两层的细节都抽象掉了——你写的是「块级」的 kernel,剩下的调度交给编译器。但抽象不等于免责:
BLOCK_SIZE、num_warps、num_stages这三个旋钮仍然直接决定 kernel 是跑到 roofline 的天花板还是趴在地板上。Triton 算子调优这门手艺,就是把这三个旋钮拧到正确位置。
本文要回答的问题
- Triton 的
BLOCK_SIZE、num_warps、num_stages各自控制什么硬件资源,调大调小各有什么代价? @triton.autotune的搜索机制怎么工作,key 参数为什么决定调优会不会反复触发?- 为什么说盲目全组合搜索是浪费,roofline 模型能怎样提前剪掉一大半配置?
- 一个 GEMM 算子和一个 LayerNorm 算子的调优过程长什么样,最优配置为什么差那么多?
- 调优结果怎么固化到生产代码里,避免每次启动都重新搜一遍?
一、三个旋钮各自控制什么
先建立一个心智模型:Triton kernel 里一个「程序实例」处理一个 tile(数据块),硬件上它对应 CUDA 的一个 thread block(在 NVIDIA 术语里也叫 CTA)。你写的 BLOCK_M × BLOCK_N 决定 tile 多大,而 num_warps 和 num_stages 是告诉编译器「这个 tile 用多少线程去算、用几级流水线去喂数据」。
上图把三个旋钮的作用链路画清楚了,逐个说:
BLOCK_SIZE 决定 tile 的粒度。tile 大,单次加载的数据多、数据复用率高(GEMM 里每个元素被复用 BLOCK_K 次),算术强度随之上升;但 tile 大意味着寄存器和共享内存吃得多,一个 SM 上驻留的 block 数就掉,延迟隐藏能力变差。tile 小则相反——occupancy 好看,但每个 block 都在重复搬运,带宽被浪费。
num_warps 决定一个 block 里有多少个 warp 分这个 tile 的活。4 个 warp 是 128 线程,8 个是 256 线程。warps 太少,单个线程的指令级并行压不满 SM 的执行单元;warps 太多,每个 warp 分到的 tile 切片太薄,同步开销占比上升,寄存器总量也可能超标。经验起点是 4,大 tile 往上试 8。
num_stages 是 Triton 特有的软件流水线级数:用 cp.async 或 TMA 把「下一轮的 tile」提前从全局内存搬到共享内存,计算和搬运重叠。stages=2 是双缓冲,stages=4 是四级流水。每多一级,共享内存多占一份 tile 大小的缓冲——A100 上 128×64 的 FP16 tile 是 16KB,4 级流水光 A、B 两个操作数就要 128KB,直接顶到单 block 的 SMEM 上限。这就是为什么 stages 不是越大越好:流水越深延迟隐藏越好,但 SMEM 耗尽会把 occupancy 打到 1,反而更慢。
把三者乘起来看:调参空间本质上是「tile 粒度 × 线程并行度 × 流水深度」在寄存器和 SMEM 两个硬约束下的最优化问题。手调几乎不可能试全,这就是 autotune 存在的理由。
二、@triton.autotune:搜索机制详解
Triton 的自动调参写法长这样:
@triton.autotune(
configs=[
triton.Config({'BLOCK_M': 128, 'BLOCK_N': 64, 'BLOCK_K': 32},
num_warps=4, num_stages=3),
triton.Config({'BLOCK_M': 64, 'BLOCK_N': 128, 'BLOCK_K': 32},
num_warps=4, num_stages=4),
triton.Config({'BLOCK_M': 128, 'BLOCK_N': 128, 'BLOCK_K': 32},
num_warps=8, num_stages=3),
# ... 更多候选
],
key=['M', 'N', 'K'],
)
@triton.jit
def matmul_kernel(A, B, C, M, N, K, ...):
...运行机制分三步,每一步都有工程含义:
第一步,分桶。autotune 用 key 里列的参数值(这里是 M、N、K)做哈希分桶。第一次遇到某个 (M, N, K) 组合时,把 configs 列表里每个候选都实际编译、跑一遍、计时,选出最快的缓存起来;之后相同 key 的调用直接命中缓存,零开销。这个设计的关键推论是:key 选什么决定调优触发频率。如果 key 里放了 batch size 这种每步都变的值,每次调用都重新全量搜索,训练直接慢十倍。实践原则是 key 只放「决定 tile 划分形状」的维度,放粗粒度的 shape 特征。
第二步,计时与选择。每个候选 config 编译成独立 cubin,用 CUDA event 计时跑若干次取中位数(新版 Triton 用 do_bench 的逻辑,含 L2 cache 刷洗)。计时的都是真实输入指针,所以 autotune 跑的过程会真的执行 kernel——输入数据必须是合法的,且 autotune 期间有副作用的 kernel(比如原地累加)会算错,这类 kernel 要么提供 reset_to_zero 钩子,要么别用 autotune。
第三步,剪枝(prune)。候选列表可以配 prune_configs_by,传一个 perf_model(性能模型)和 top_k:编译前先用模型估算每个配置的耗时,只实际编译跑 top_k 个。这把「编译 N 个候选」的成本砍掉一个数量级,而性能模型最常见的选择就是 roofline。
上图这套「缓存 + 剪枝 + 实测」的流程解释了 autotune 的两个典型坑:一是第一次调用特别慢(几十秒编译加搜索),生产环境要么预热要么离线固化;二是 key 设计不当导致缓存命中率低,搜索被反复触发。
三、roofline:给搜索空间装一把剪刀
为什么不把 block size 从 16 到 256 全排列扔给 autotune?因为编译一个 config 要几秒,100 个组合就是几分钟的搜索开销,而且绝大多数组合一眼就知道不行。roofline 模型提供了「一眼」的量化版本。
roofline 的核心就两条线:性能上限 = min(峰值算力, 带宽 × 算术强度)。算术强度(arithmetic intensity,每字节访存对应的浮点运算次数)决定 kernel 落在哪个区域。
用 roofline 裁剪搜索空间的具体做法分两步。
第一步,判断算子落在哪个区,确定调参方向。拿 A100 做基准:FP16 峰值 312 TFLOPS,HBM 带宽 1.6-2.0 TB/s,转折点算术强度约 140-160 FLOP/byte。LayerNorm 这种逐元素算子,每个元素读一次写一次,算术强度不到 1,铁定带宽受限——调参目标不是「算得快」而是「访存合并得好、occupancy 撑得高」,block 取 1024/2048 一档的中等值、warps 取 4-8,重点在让 SM 上同时驻留足够多的 block 来掩盖访存延迟。GEMM 相反,BLOCK_M×BLOCK_N 的 tile 做 BLOCK_K 次累加,算术强度约等于 min(BLOCK_M, BLOCK_N) 的一半量级,tile 从 64 加到 128,AI 直接翻倍——调参目标是把 tile 撑到资源约束允许的最大,把 kernel 推进算力受限区。
第二步,用资源约束删掉物理上不可能的配置。每个 config 在编译前就能估算资源:寄存器用量约正比于 BLOCK_M×BLOCK_N/线程数(每个线程持有的累加器),SMEM 用量 = (BLOCK_M×BLOCK_K + BLOCK_K×BLOCK_N) × 字节数 × num_stages。A100 单 block 的 SMEM 上限约 164KB、单线程寄存器 255 个,超出的组合直接删掉,根本不用编译。128×128×32、FP16、stages=4 这个组合 SMEM 需求是 (128×32 + 32×128)×2×4 = 64KB,能活;stages=5 就是 80KB 加上输出缓冲开始吃紧;tile 加到 256×128 则光流水缓冲就破百 KB,直接出局。一轮约束过滤下来,候选数通常从三位数砍到十几个。
这就是 roofline 与 autotune 的关系:roofline 不负责找出最优解,负责把搜索空间从「穷举」剪到「值得实测的少数」。Triton 官方的 matmul autotune 模板里那个 early_config_prune 函数,干的就是这两步的代码化。
四、实战一:GEMM 调优全过程
以 FP16 GEMM 为例,C = A×B,shape 取 LLM 推理里常见的 M=4096, N=4096, K=4096。候选空间按上一节的方法先剪一轮,剩下的大致是这张表:
| BLOCK_M×N×K | num_warps | num_stages | SMEM 估算 | 实测 TFLOPS | 判读 |
|---|---|---|---|---|---|
| 64×64×32 | 4 | 3 | 24KB | 95 | tile 太小,AI 不足,带宽区 |
| 128×64×32 | 4 | 4 | 48KB | 178 | 过渡区,occupancy 好 |
| 128×128×32 | 8 | 3 | 48KB | 246 | 进入算力区,甜点 |
| 128×128×64 | 8 | 3 | 96KB | 238 | K 加深但 SMEM 紧,略降 |
| 128×256×64 | 8 | 3 | 144KB | 229 | occupancy 掉到 1,吞吐回落 |
| 256×128×64 | 8 | 4 | 超上限 | 编译失败 | 约束过滤的对象 |
几个值得记住的规律。第一,性能曲线是中间高两头低的山形:tile 太小困在带宽区,tile 太大 occupancy 崩掉,甜点多在 128×128 或 128×256 一带。第二,num_stages 从 2 到 3 收益最大(从不能隐藏延迟到基本隐藏),3 到 4 边际递减,再往上 SMEM 代价反超收益。第三,num_warps 要跟着 tile 走:128×128 的 tile 配 4 个 warps,每线程累加器是 128×128/128=128 个 FP32 寄存器,已经顶格;配 8 个 warps 则每人 64 个,宽裕且调度灵活——这就是大 tile 配 8 warps 几乎总是更优的原因。
还有一点容易被忽略:不同 shape 的最优 config 不同。M=128(decode 阶段的单 token 生成)时,128×128 的 tile 会把 M 维浪费掉 7/8,小 tile 64×64 反而赢。这就是为什么 key 里必须带 M、N、K——让 autotune 为每种 shape 各存一份答案。
五、实战二:LayerNorm 与访存型算子
LayerNorm 是另一类典型:输入行向量逐元素减均值除方差,每行读一遍写一遍,算术强度恒定且极低,roofline 上钉死在带宽区。这类算子的调优逻辑和 GEMM 完全不同。
@triton.autotune(
configs=[
triton.Config({'BLOCK_N': 1024}, num_warps=4),
triton.Config({'BLOCK_N': 2048}, num_warps=8),
triton.Config({'BLOCK_N': 4096}, num_warps=8),
triton.Config({'BLOCK_N': 8192}, num_warps=16),
],
key=['N'],
)
@triton.jit
def layernorm_kernel(X, Y, W, B, N, ...):
row = tl.program_id(0)
cols = tl.arange(0, BLOCK_N)
x = tl.load(X + row * N + cols, mask=cols < N)
...这里没有 num_stages——逐元素算子没有跨迭代的数据复用,软件流水线无用武之地,配了也是白占 SMEM。BLOCK_N 的作用是「一行用多少个元素一趟处理完」:N=4096 的 hidden size,BLOCK_N=4096 时一趟搞定、无需循环,通常最优;N 超过 BLOCK_N 则自动落入循环,效率反而降。num_warps 决定这一行由多少线程分,4096 个 FP32 元素配 8 warps(256 线程),每线程 16 个元素,向量化加载正好铺满 128 字节事务,这是「合并访存」友好的切法。
调优的验收指标也换了一套:GEMM 看 TFLOPS 占峰值的百分比,LayerNorm 看有效带宽——(读字节数+写字节数)/耗时,能到 HBM 峰值的 80% 以上就是合格,90% 是优秀。用 triton.testing.do_bench 计时后手算一下字节数,比对着 TFLOPS 空想要实在得多。
上面这张决策图把两个实战串起来了:先按算术强度分流方向,再按方向生成候选,约束过滤之后交给 autotune 实测,最后按算子类型选验收指标。整条链路里 autotune 只做「最后一公里」的精调,前面的分流和过滤才是省时间的大头。
六、生产固化与常见坑
autotune 是运行期机制,直接带进生产有三个麻烦:首次调用慢、多进程各自重复搜索、结果不可复现。工程上的标准解法是离线调优 + 查表上线:
- 用真实 shape 集合在目标 GPU 上跑一遍 autotune,把每个 key 的最优 config 用
kernel.cache或手动记录导出成字典; - 生产代码里去掉
@triton.autotune,改成一个小路由函数按 shape 查表填BLOCK_*、num_warps、num_stages的默认值; - 查不到表的 shape 回退到一组保守的通用 config(比如 128×64、4 warps、3 stages),保证不错只保证不慢。
换 GPU 型号要重跑调优——A100 上调好的配置搬到 H100(SMEM 228KB、带宽 3.35TB/s)甜点位置会移动,搬到消费卡(SMEM 只有 100KB 上下)甚至可能编译失败,配置表必须按硬件分版本管理。
三代主流卡的关键约束数字放一起对照,调参时心里要有这张表:
| 维度 | A100 | H100 | RTX 4090 |
|---|---|---|---|
| FP16 峰值算力 | 312 TFLOPS | 990 TFLOPS(稀疏翻倍) | 约 165 TFLOPS |
| HBM 带宽 | 1.6-2.0 TB/s | 3.35 TB/s | 1.0 TB/s(GDDR6X) |
| 单 block SMEM 上限 | 约 164KB | 228KB | 约 100KB |
| roofline 转折点 AI | 约 160 FLOP/B | 约 295 FLOP/B | 约 165 FLOP/B |
| 甜点 tile 倾向 | 128×128 | 128×256 配 TMA | 128×128 或更小 |
H100 的转折点几乎翻倍,意味着同一个 GEMM 在 H100 上更「渴数据」:tile 要更大、stages 要更深才能把算术强度推过转折点,这也是为什么 H100 上 Triton 的 TMA(Tensor Memory Accelerator,张量内存加速器)描述符路径几乎成为大算子的标配——它把多级流水里地址计算的开销整个卸给专用硬件,等价于白捡一到两级 stages。RTX 4090 则相反,SMEM 紧张,官方模板里 stages=4 的大 tile 配置直接编译失败,得主动降档。结论还是那句话:配置表跟硬件版本走,不存在一份通吃的最优解。
常见坑清单:
- key 里放了步长、指针这类每次调用都变的值,缓存永远不命中,每次都全量搜索。
- 有副作用的 kernel(原子累加、原地清零)直接挂 autotune,搜索阶段被重复执行结果全错。
- 候选列表里堆几十上百个 config 不做剪枝,首次调用编译几分钟,线上超时。
- 盲目照抄官方 matmul 模板的大 tile 配置到小 shape 场景,M=16 的 decode 场景浪费八成算力。
- 给逐元素算子配 num_stages=4,SMEM 白占一份,occupancy 反而下降。
- 只看 TFLOPS 不看 roofline 位置:带宽型算子 TFLOPS 低是物理必然,该盯的是有效带宽。
- 在开发机上调好直接上线,生产卡型号不同,最优配置完全不通用。
这一篇在知识体系里的位置
- 向上承接:CUDA 线程层级 讲清 grid/block/warp 到硬件的映射,本篇的三个旋钮正是站在那套映射上的高层抽象;Occupancy 与寄存器压力 里算的寄存器与 SMEM 账,在本篇变成裁剪搜索空间的硬约束。
- 横向相关:FlashAttention 的显存分块 是 tile 化思想在注意力算子上的极致案例,其 Triton 实现同样依赖本篇的调参方法论;GPU 显存层级与带宽 解释了 HBM/L2/SMEM 各层带宽差,是 roofline 带宽线的物理出处。
- 应用延伸:TensorRT 推理优化 里的 kernel auto-tuning 与本篇的 autotune 是同一思想在推理引擎里的工程化版本,可对照阅读。
总结
Triton 算子调优的本质是在寄存器和共享内存约束下搜索「tile 粒度 × warps 并行度 × 流水线深度」的最优组合:@triton.autotune 用 key 分桶缓存、实测计时选优,但候选空间必须先用 roofline 裁剪——算术强度高的 GEMM 类往大 tile、8 warps、3-4 级流水方向调、以 TFLOPS 占比验收,算术强度低的逐元素类往访存合并与高 occupancy 方向调、以有效带宽验收;生产环境离线调优查表上线,换卡必须重调,这就是从「能跑」到「跑到 roofline 天花板」的全部路径。