Skip to content

GPU 自定义算子与 Triton 融合编程

详解 Triton 块级编程、Bank Conflict 与 Liger-Kernel 融合实现。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是 GPU 自定义算子与算子融合(Triton / CUTLASS)?

用纯 PyTorch 写一行 RMSNorm 再写一行 RoPE,GPU 就会乖乖把张量从显存读出来算完、写回显存、再读出来算下一行——大量时间白白耗在来回跑腿的显存读写上。

算子融合(Kernel Fusion) 就是把相邻的好几步运算塞进同一个 GPU 函数里,数据只读一次、全在高速片上缓存算完再写回;而 Triton / TileLang 让算法工程师不用啃晦涩的底层 CUDA C++ 线程同步,用类似 Python 的分块思维就能写出逼近手工极限速度的高性能融合算子。

01 问题从何而来:明明只加了两行代码,显存和速度怎么双双崩了? ​

用 PyTorch 写大模型时,代码看着极其清爽:先做残差相加,再过一个 RMSNorm,接着套上 RoPE 旋转位置编码,最后算一遍大词表交叉熵损失。每一行都只有寥寥几个字符,逻辑优雅得像教科书。

可一旦放到真机上一测性能,你会大跌眼镜:整张 H100 有大半时间都在空转,而且训练到最后一层计算 15 万大词表的 Loss 时,光一个临时 Logits 矩阵就能一口气吃掉 10 GB 以上的显存,直接把 Batch Size 憋到 OOM!

按照 GPU Roofline 模型 的诊断,病根一清二楚:PyTorch 默认按行“逐个发射算子”,每一步都要把数据从慢悠悠的 HBM 显存搬进芯片,算完微不足道的一两步加减乘除,又原封不动搬回 HBM 存盘,下一行再重新搬进来。要根治这种反复折返跑,就必须把多个小算子捏成一个大算子——这就是 算子融合(Kernel Fusion)。而 2019 年 OpenAI 推出的 Triton(ACM DOI ↗),彻底打破了“只有 CUDA 大神才能手写融合算子”的铁律。

类比 · 传菜员折返跑 vs 一条龙流水线

想象你在餐厅后厨做一道“拌凉菜”:洗菜、切丝、放盐、淋醋四道工序本来极其简单。

  • 未融合的 PyTorch:每道工序派一名独立员工。第一位员工从地下冷库搬出黄瓜,洗完后专门跑一趟冷库塞回去;第二位再下冷库搬出来切丝,切完又送回冷库;四步下来,黄瓜在楼梯上坐了八趟电梯!
  • 算子融合(Fused Kernel):只搬这一趟!黄瓜抱上料理台(片上 SRAM),一口气洗、切、拌、淋醋全部搞定,只把最终成品端回冷库。搬运量瞬间砍成四分之一,而且中间那堆半成品根本不用占冷库货架!
核心设问

手写原生 CUDA 门槛高到劝退九成算法工程师,有没有办法只用几十行直观的 Python 代码,就让编译器自动帮你把片上分块、线程同步和防冲突全包办好,还能顺手消灭大词表训练里吃掉十几 GB 显存的“Logits 怪兽”?

02 核心直觉与生活类比 ​

为什么以前大家都怕写 GPU 算子?因为原生 CUDA 采用的是 线程级(SIMT)编程——你要亲自操心成千上万个微线程各自干什么、32 个线程组成的 Warp 怎么交换数据、怎么防止片上共享内存撞车。

类比 · 当建筑总设计师 vs 亲自指挥每位砖瓦工

对比几种主流 GPU 编程工具,就像管理一座大工地:

  • 原生 CUDA:你是站在脚手架上的严苛工头,要细到指挥“第 17 号工人左手递砖,第 18 号工人右手抹灰,千万别踩同一根梯子”。干得极快,但写完头发也掉光了。
  • CUTLASS / CuTe:像采购顶级工业预制件,搭标准摩天大楼(比如矩阵乘 GEMM)性能封神,但自己魔改异形结构门槛依然很高。
  • Triton:你升格成了块级架构师!你不再管单个工人,而是直接对整块数据发号施令:“拿一个 128×128 的数据块搬上工作台,做完乘法再做归一化”。具体怎么派线程、怎么拼齐内存、怎么躲避共享内存撞车,全交给 Triton 编译器自动生成。

在共享内存(SRAM)里干活,还有个著名的隐形杀手叫 Bank Conflict(存储体冲突)。

类比 · 银行 32 个窗口同时排队的悲剧

GPU 的共享内存被划分成了 32 个独立柜台(Bank),好比银行大厅并排开着 32 个窗口。每次同一小组(Warp)的 32 位顾客一起冲进去取钱:

  • 理想情况:32 个人刚好一人排一个不同的窗口,1 个时钟周期全部办完走人!
  • Bank Conflict:如果因为矩阵按列访问步长凑巧是 32 的倍数,32 位顾客全都涌向了 1 号窗口,旁边 31 个窗口全空着!大厅瞬间从 32 路并行退化成单列排长队,速度暴跌 32 倍!

解决办法也极具巧思:要么在每行末尾故意塞一个空占位(Padding),要么把门牌号和楼层号做一次异或打乱(Swizzling),强行把涌向同一个窗口的顾客均匀打散到 32 个窗口里。在 Triton 里,这些烧脑的排班戏法大多由编译器默默替你兜底了。

03 把关键公式读成人话 ​

融合算子到底能快多少?在 Roofline 的访存受限区间里,答案简单粗暴得像一道小学算术题:

Speedupfusion=QunfusedQfused≈K

把公式读成直觉:- K 是你串联起来的逐元素/归一化小算子个数。比如把 残差相加 + RMSNorm + RoPE 三步捏成一个融合 Kernel,原来要进出 HBM 显存 6 次,现在只要进出 2 次,理论速度直接翻 3 倍!

  • 更惊人的是显存红利:把最后一层投影和交叉熵损失融合成 Fused Linear Cross-Entropy 后,原本必须整张落盘的巨型 Logits 矩阵大小是:
Memorylogits=(B⋅T)×V×4 Bytes

把公式读成直觉:- 现代模型词表 V 动辄 15 万,只要一个微批次有 16K 个 Token,这张还没来得及算 Loss 的临时成绩单就要吞掉近 10 GB 显存(加上反向梯度接近 20 GB)!

  • Liger-Kernel(arXiv:2410.10989 ↗)的做法堪称绝妙:它把 16K 个 Token 切成每次 1024 个的小段,算完这一小段的局部 Logits 后,在芯片上当场算出 Loss 和梯度并直接反传给权重,算完立刻把这一小块 Logits 扔掉,再算下一段!
  • 整张 10 GB 的大表从头到尾压根就没在显存里出现过,峰值显存直接砍掉 60%–80%,训练吞吐反而还能多赚 20%!

04 它在模型里怎么工作 & 与上下游的关系 ​

自定义融合算子是连接“算法巧思”和“硬件极限”的万能胶水:

  • 注意力前后的“贴身打包”:在每一层 Transformer 里,残差相加紧挨着 RMSNorm,QK 投影之后立刻跟着 RoPE 旋转位置编码 与 QK-Norm。通过 Fused Residual+RMSNorm 和 Fused QK-Norm+RoPE,向量在寄存器里转一圈就把归一化与复数旋转一次干完,省去四五趟 HBM 搬运。
  • 预训练与微调的省显存利器:在 自回归预训练 和 SFT / LoRA 微调 中,直接一键替换 Liger-Kernel 的融合 RMSNorm、SwiGLU、RoPE 和 Fused Linear Cross-Entropy,往往不需要改任何模型数学逻辑,就能省下 40%–60% 显存、白赚 20% 吞吐,与 激活重计算 完美互补。
  • 推理加速的底层引擎:无论是 FlashAttention、面向长文解码的 FlashDecoding,还是 PagedAttention 的分页 KV 读写与反量化融合矩阵乘,底层全靠融合算子把零碎搬运压榨到极致。
  • 编译器与手写算子的双向奔赴:PyTorch 2 内置的 torch.compile 底层直接把计算图翻译成 Triton 代码;而在追求 95%+ 极限硬件利用率的超大模型底座上,社区又进一步演化出了兼顾 Python 易用性与硬件控制力的 TileLang(arXiv:2504.17577 ↗)。

05 演化对比与避坑备忘 ​

想决定手头的算子该用哪种武器,一张速查表就能拿捏:

方案开发门槛典型能效比最适合干什么
torch.compile1 行装饰器75%–88%常规逐元素算子链融合,零成本必开的第一步
Triton (ACM DOI ↗)纯 Python 数十行80%–92%Fused RMSNorm/RoPE/CE、自定义量化与稀疏算子
TileLang (arXiv ↗)Python 硬件 DSL90%–97%DeepSeek MLA、定制流水线与极端压榨 SRAM 的前沿算子
CUTLASS / CUDAC++ 专家级95%–100%FlashAttention-3、WGMMA/TMA 级厂商核心矩阵内核

自己上手写 Triton 算子时,有四个坑几乎人人都会踩一次:

  1. 千万别把超大维度硬塞进一个 BLOCK_SIZE:如果一行有 15 万列(比如词表维),直接写 BLOCK_SIZE = triton.next_power_of_2(V) 会把片上寄存器瞬间撑爆,编译器会悄悄把数据倒回慢如蜗牛的 Local Memory(本质就是 HBM),算子比原生 PyTorch 还慢十倍!大维度必须用小块循环配合在线归约。
  2. 别忘记把累加精度升回 FP32:对 BF16/FP16 张量做平方和或指数求和(RMSNorm、Softmax、交叉熵)时,一定要先 .to(tl.float32) 算完归约再转回低精度写回,否则长向量累加很快就会发生精度漂移甚至溢出炸出 NaN。
  3. 动态形状别误标 tl.constexpr:标成编译期常量的参数只要值一变,Triton 就会现场重新编译一次内核。在线推理如果把变长 seq_len 标成了常量,每来一条新长度的请求服务就卡死几百毫秒,务必把动态长度当普通变量传入!
  4. 上线前别忘开 @triton.autotune:同一段 Triton 代码在不同显卡(A100 vs H100)上最优的 num_warps 和 num_stages 差异巨大,随手写死参数往往会丢掉 20%–30% 的隐藏性能。

需要查阅 Bank Conflict 的 Swizzling 位运算公式、Fused Linear Cross-Entropy 数据流图以及完整可运行的 triton_rmsnorm 源码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

根据 GPU Roofline 性能模型,现代 Transformer 中除大型矩阵乘(GEMM)之外,存在海量逐元素与行规约算子——如 RMSNorm、SwiGLU、RoPE、Dropout 以及大词表 交叉熵损失。在标准 PyTorch 急切执行(Eager Mode)下,每个算子都会触发一次独立的 HBM 读入与写回,导致严重的 Memory-Bound 与显存峰值膨胀。Triton(Tillet et al., 2019,ACM DOI ↗)提出了一种面向分块张量的中级语言与编译器:开发者只需在 Python 中思考 块级(Block-Level)数据流,由编译器自动接管线程内归约、合并访存(Coalescing)、共享内存分配与 Bank Conflict 规避,让自定义高性能融合算子的研发门槛下降了一个数量级。

直观理解

写原生 CUDA 像在微型车间里手动指挥 32 名工人(一个 Warp)每人拿哪一颗螺丝、怎么防撞肩;写 Triton 则像直接下达班组级指令——“把这块 128×128 的数据块整体搬上工作台,做完归一化再顺手乘上旋转矩阵,一次送回仓库”,底层工人怎么分工排班全由编译器自动调度。

起源背景与 GPU 算子编程范式演进 ​

在深度学习发展早期,高性能算子几乎完全依赖厂商闭源库(cuBLAS / cuDNN)或手写 CUDA C++。然而随着大模型架构快速迭代(如新激活函数、变体位置编码、FP8 细粒度缩放、MoE 路由重排),厂商库往往滞后数月,而手写贴近硬件峰值的 CUDA 代码需要深入调优 Warp Shuffle、异步拷贝(cp.async / TMA)、软件流水线(Software Pipelining)与寄存器压力,开发周期极长。

由此演化出四代互补的 GPU 算子编程工具链:

  1. CUDA C++(线程级控制):控制粒度精确到单个线程与 PTX 指令,性能上限最高,但工程复杂度与维护成本极高。
  2. CUTLASS / CuTe(模板级矩阵库):NVIDIA 官方 C++ 模板库,通过 Layout 与 Tensor 代数抽象将 GEMM 分块、Tensor Core MMA 与 Hopper TMA/WGMMA 封装为可组合积木,是 FlashAttention-2/3 与 DeepGEMM 的底座。
  3. Triton(块级编译语言):OpenAI 主导,以 tl.program_id 划分网格,以 tl.load / tl.store / tl.dot 操作向量与矩阵块,成为 PyTorch 2 TorchInductor 与开源 LLM 生态(vLLM、Liger-Kernel、Unsloth)的事实标准。
  4. TileLang / Helion(显式硬件感知 DSL):在保留 Python 级开发效率的同时,向开发者开放显式片上 Buffer 布局与流水线阶段控制,进一步逼近手写 CUTLASS 的极限性能(如 DeepSeek MLA 与稀疏注意力算子)。

核心原理与关键硬件机制 ​

1. 算子融合的 IO 收益定量分析 ​

假设对形状为 (M,N) 的张量依次执行 K 个逐元素/行规约算子(如 Residual Add → RMSNorm → RoPE),每个元素占 e 字节。分立执行时,每个算子至少读一次、写一次 HBM,总访存量为 Qunfused=2KeMN;融合为单一 Kernel 后,中间结果全程驻留寄存器与 SRAM,仅在首尾访问一次 HBM,总访存量降至 Qfused=2eMN。在 Memory-Bound 区间,理论加速比直接等于:

Speedupfusion=QunfusedQfused=K

2. 分块(Tiling)、合并访存与 Bank Conflict ​

要在极小的片上 SRAM(每 SM 仅约 228 KB)中高效处理大张量,必须依赖 Tiling(分块) 与三项底层硬件纪律:

  • 合并访存(Memory Coalescing):同一 Warp 内 32 个相邻线程访问 HBM 时,其地址应落在连续对齐的 128 字节缓存行内,避免单次请求裂变为多次无效内存事务。
  • 共享内存 Bank Conflict(存储体冲突):NVIDIA GPU 的 Shared Memory 被划分为 32 个独立 Bank,每个 Bank 宽 4 字节(连续 32-bit 字循环映射到 Bank 0,1,…,31)。若同一 Warp 中多个线程在同一周期访问同一 Bank 的不同地址,硬件会被迫将其串行化,带宽瞬间跌至 1/32。工程中常用 Padding(列宽 +1) 或 Swizzling(地址异或重排) 消除冲突:
colswizzled=col⊕(rowmod8)
  • 片上规约与多阶段流水线:对于行归一化或矩阵乘累加,Triton 自动将行内求和编译为寄存器级的 Warp Shuffle(__shfl_xor_sync),并通过 num_stages 参数生成多缓冲异步预取流水线,将下一块的 HBM 加载延迟隐藏在当前块的 Tensor Core 计算之下。

3. 典型 LLM 融合模式:Fused RMSNorm+RoPE 与 Fused Linear Cross-Entropy ​

在现代 Transformer 块中,有两类收益最高的跨算子融合模式:

  1. Fused Residual + RMSNorm + RoPE:在注意力层入口,残差连接输出 x+r 需立刻经过 RMSNorm,而在 QK 投影之后又会立即施加 RoPE 旋转位置编码(以及 QK-Norm)。将 Residual Add 与 RMSNorm 融为单一内核、并将 QK-Norm 与 RoPE 的复数旋转融为单一内核,可将片上寄存器中的归一化输出直接乘以预取的 (cos⁡mθ,sin⁡mθ) 旋转表,省去多达 4–6 次整张激活张量的 HBM 读写。
  2. Fused Linear Cross-Entropy(FLCE):现代大模型词表尺寸 V 已普遍膨胀至 128K–256K(如 Llama 3 为 128,256,Qwen 为 152,064)。在 自回归预训练 或 SFT 微调 中,最后一层隐藏态 H∈RB⋅T×d 乘以 LM Head 权重 W∈RV×d 会产生巨型 Logits 张量 Z∈RB⋅T×V。当 B⋅T=16384,V=152064 时,仅 FP32 的 Logits 及其反向梯度就需要:
Memorylogits=16384×152064×4 B≈9.96 GB(单副本)

Liger-Kernel(Hsu et al., 2024,arXiv:2410.10989 ↗)提出的 Fused Linear Cross-Entropy(FLCE) 彻底消灭了这一显存黑洞:按 Token 维将 H 切分为小块 Hc∈RC×d(如 C=1024),逐块在片上即时计算局部 Logits Zc=HcW⊤,立刻用单次融合 Triton Kernel 算出该块损失值及原地覆写的梯度 ∇ZcL=Softmax(Zc)−Yc,随即反传累加 ∇Hc=∇ZcW 与 ∇W+=∇Zc⊤Hc 并释放 Zc。完整 B⋅T×V 矩阵从未在显存中实化,显存骤降 60%–80%,同时吞吐量提升 20% 以上。

图表加载中...

主流 GPU 算子开发框架横向对比 ​

维度原生 CUDA C++CUTLASS / CuTeTritonTileLang
编程粒度线程级(SIMT)线程块 / Warp 模板级块级(Block-Level)显式 Tile + 内存布局级
开发效率低(数周调优)中低(模板复杂)极高(纯 Python 数十行)高(Python DSL)
Bank Conflict 处理手动 Padding / SwizzleCuTe Layout 自动 Swizzle编译器自动优化显式声明 + 自动推导
适用算子类型极致非规则 / 系统原语GEMM、FlashAttention-3融合 Norm/RoPE/CE/量化定制 MLA / 稀疏注意力
典型硬件利用率95%–100%(专家手写)90%–98%80%–92%90%–97%

核心 Triton / PyTorch 融合实现:Fused RMSNorm ​

以下展示标准 PyTorch 分立实现与单 Kernel Triton Fused RMSNorm 的完整对比。Triton 版本将整行加载进片上寄存器,在单次访存内完成平方和规约、倒数平方根与权重缩放,完全消除中间张量写回 HBM:

python
import torch
import triton
import triton.language as tl


@triton.jit
def _fused_rmsnorm_fwd_kernel(
    X_ptr, W_ptr, Y_ptr, Rstd_ptr,
    stride_x_row, stride_y_row,
    N: tl.constexpr, eps: tl.constexpr,
    BLOCK_SIZE: tl.constexpr,
):
    row_idx = tl.program_id(0)
    cols = tl.arange(0, BLOCK_SIZE)
    mask = cols < N

    # 1. 合并访存加载整行输入,统一提升至 FP32 保障数值稳定
    x = tl.load(X_ptr + row_idx * stride_x_row + cols, mask=mask, other=0.0).to(tl.float32)
    w = tl.load(W_ptr + cols, mask=mask, other=0.0).to(tl.float32)

    # 2. 片上寄存器直接完成均方根规约,零 HBM 中间落盘
    mean_sq = tl.sum(x * x, axis=0) / N
    rstd = tl.rsqrt(mean_sq + eps)
    y = (x * rstd) * w

    # 3. 一次写回输出与供反向传播复用的 rstd 标量
    tl.store(Y_ptr + row_idx * stride_y_row + cols, y.to(X_ptr.dtype.element_ty), mask=mask)
    tl.store(Rstd_ptr + row_idx, rstd)


def triton_rmsnorm(x: torch.Tensor, weight: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
    assert x.is_contiguous() and weight.is_contiguous()
    orig_shape = x.shape
    x_2d = x.view(-1, orig_shape[-1])
    M, N = x_2d.shape
    y = torch.empty_like(x_2d)
    rstd = torch.empty((M,), device=x.device, dtype=torch.float32)

    BLOCK_SIZE = triton.next_power_of_2(N)
    # 针对大隐藏维适度增加 num_warps 隐藏延迟
    num_warps = 4 if BLOCK_SIZE <= 2048 else 8
    _fused_rmsnorm_fwd_kernel[(M,)](
        x_2d, weight, y, rstd,
        x_2d.stride(0), y.stride(0),
        N=N, eps=eps, BLOCK_SIZE=BLOCK_SIZE,
        num_warps=num_warps,
    )
    return y.view(orig_shape)


def torch_rmsnorm_ref(x: torch.Tensor, weight: torch.Tensor, eps: float = 1e-6) -> torch.Tensor:
    """标准 PyTorch 分立实现:产生至少 4 次 HBM 中间读写."""
    xf = x.float()
    rstd = torch.rsqrt(xf.pow(2).mean(dim=-1, keepdim=True) + eps)
    return (xf * rstd).to(x.dtype) * weight

工程实践与常见陷阱 ​

陷阱一:BLOCK_SIZE 过大引发寄存器溢出(Register Spilling)

在 Triton 中习惯性地将 BLOCK_SIZE 设为 next_power_of_2(N) 虽简单直观,但当词表维度 V=152064 时单块根本无法塞进片上寄存器,编译器会把超出部分静默溢出到极慢的 Local Memory(本质仍是 HBM),导致性能断崖式下跌 10 倍。大维度规约必须采用分块循环 + 在线归约(Online Reduction),将单次 BLOCK_SIZE 限制在 4096–8192 以内。

陷阱二:忘记 Autotune 与 tl.constexpr 导致的二次编译抖动

Triton Kernel 在首次遇到新张量形状或 tl.constexpr 常量组合时会触发 JIT 编译(耗时数百毫秒)。线上推理服务若传入动态变长序列而把 seq_len 错标为 tl.constexpr,会引发持续卡顿与编译缓存泄漏。动态维度应作为普通标量参数传入,只将分块尺寸与架构常量设为 constexpr,并配合 @triton.autotune 在预热期搜索最优 (BLOCK_SIZE, num_warps, num_stages)。

工程最佳实践:先 torch.compile,再手写 Triton

PyTorch 2 的 torch.compile 后端 TorchInductor 已能自动将常规逐元素算子链融合为高质量 Triton Kernel。在动手造轮子前,应先用 torch.compile 建立基线;仅当遇到跨归约边界的大颗粒融合(如 Fused Linear Cross-Entropy、Fused RMSNorm+RoPE、量化反量化融合 GEMM 或自定义 KV Cache 分页 读写)时,手写 Triton/TileLang 才能带来 2×–5× 的决定性收益。

参考文献 ​

  1. Tillet, P., Kung, H. T., & Cox, D. (2019). Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations. MAPL 2019. ACM DOI ↗
  2. Hsu, P.-L., et al. (2024). Liger Kernel: Efficient Triton Kernels for LLM Training. arXiv:2410.10989 ↗
  3. Wang, L., et al. (2025). TileLang: A Composable Tiled Programming Model for AI Systems. arXiv:2504.17577 ↗
  4. NVIDIA Corporation. (2024). CUTLASS & CuTe: CUDA Templates for Linear Algebra Subroutines. GitHub ↗
  5. Ansel, J., et al. (2024). PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and Graph Compilation. ASPLOS 2024. ACM DOI ↗