大模型里有一类算子,计算强度极低、时间几乎全花在数据搬运上,softmax 是最典型的代表。用 PyTorch 的朴素写法做一次行 softmax(M 行 N 列,FP32),中间结果要在显存里反复倒手:整体需要读 5MN+2M、写 3MN+2M 个元素,而数学上真正必须发生的,只有读一遍 MN、写一遍 MN。

本文依托 FlagOS 社区推出的《智能计算系统软硬件基础》课程,把“融合收益从哪来、边界在哪、kernel 怎么写、以及怎么把收益交付给普通用户”这条链路拆开讲一遍:先算融合的收益与代价(含两个公开的性能回退案例),再逐段拆解 Triton 的 Fused Softmax 实现,最后看 FlagGems 如何把这类 Triton kernel 以零代码修改的方式注入 PyTorch。

先给结论:融合把 softmax 的显存流量从 8MN+4M 压到 2MN(约 1/4),实测带宽从朴素实现的 ~350 GB/s 提升到 ~1.4 TB/s 量级,加速比 2.43×(N=256)到 3.79×(N=2560),曲线右端约 3.8–3.9×,逼近 4× 的理论上限;在与 torch.softmax 的对比中,Triton 融合版在 N=2176 处领先 22.87%,且全程无深度凹陷。用户侧要改的只有两行:import flag_gems; flag_gems.enable()。

 

图片

 

一、融合的收益从哪来,边界在哪

算子的生命周期分三层。框架层把高层复合算子(如 TransformerBlock)拆解为细粒度原语(MatMul、Softmax、LayerNorm),在标准 IR(MLIR、XLA HLO)上做图规范化,再 lowering 成设备相关代码;运行时层为每个算子准备设备指针、共享内存大小、Stream ID 等参数,发起 kernel launch;硬件层则是最朴素的循环:从 Global Memory 读数据,计算单元处理,结果写回 Global Memory。

默认执行模式下,"结果写回"是刚性的:每个算子的输出都必须落回显存,下一个算子再读一遍。以 Conv → Scale/Bias → MaxPool 为例,中间激活(N×H×W×K)被完整写出又读入,激活值在相邻算子之间没有机会留在片上。

算子融合(Operator Fusion)就是把这串独立算子合并成一个 kernel 执行,深度学习里的典型形态有三种:

  • 垂直融合(Vertical):Conv + Bias + ReLU,沿数据流方向串联;

  • 水平融合(Horizontal):多个相同输入、不同参数的 GEMM 合并;

  • 归约融合(Reduction):LayerNorm 内部的 Mean + Var + Scale 串成一次归约。

融合的收益主要有四条:消除中间结果的显存读写(数据留在寄存器或共享内存里);减少 CPU 与 GPU 之间的 launch 握手次数(这也是 CUDA Graph 用 Capture/Replay 缓解的问题);数据在片上 SRAM 中被连续使用,缓存利用率更高;单次任务的指令流更长,更容易掩盖内存延迟。

但融合有代价,核心矛盾是寄存器压力。GPU SM 的寄存器总量固定(A100 为 256KB/SM),融合后单线程要保存更多中间状态,链条逐级放大:单线程寄存器占用上升,带动每个线程块的寄存器占用随之上升,SM 能并发容纳的线程块数因此减少,最终表现为 SM 上活跃 warp 数(Occupancy)下降。融合后的 kernel 还可能超出指令缓存限制。省下的带宽与丢掉的并行度之间,存在一个必须实测才能找到的甜点区。

两个公开案例说明这条边界真实存在。

XLA 的贪婪合并(openxla/xla Discussion #766)。输入 Parameter 的强制布局是 {3,2,1,0},custom-call 的强制布局是 {1,0,2,3},而 Add 要求两个操作数布局一致,XLA 便插入一个 Copy 做转换;随后 GpuInstructionFusion 为了减少 launch 开销把 Add 与 Copy 合并——同一个 kernel 里 I/O 布局不一致,破坏了访存合并(coalesced access),读取退化为随机跳跃。Stable Diffusion 基准中的 fused_computation.1116,不一致布局耗时 21.63ms,同样融合模式下改用一致布局只要 2.43ms,差约 8.9 倍。后续的 FusionMerger、GpuMultiOutputFusion 等融合 pass 同样不考虑布局,还会把这个坏 kernel 越合越大。

Fused AdamW 在 A40 上的回退(pytorch/pytorch Issue #121857)。512M 参数的语言模型、bf16、PyTorch 2.2.0、A40 单卡,优化器开 fused=True 后,整体训练吞吐从 85 TFLOPS 掉到 68 TFLOPS。trace 分析给出的解释:fused kernel 的占用率只有 67%(foreach 版是 100%),寄存器用量接近翻倍;fused 路径按张量分块触发 kernel,参数张量一多,启动次数随之放大。到 2.4 nightly 修复后,fused 才基本追平 unfused(69.5 vs 70.5 TFLOPS)。

两个案例的共同点:融合决策只回答了"能不能合",没回答"合了之后访存和寄存器会怎样"。融合只是一种带宽优化手段,做不做、怎么做,最终得靠测量说话。

 

二、Fused Softmax:把 4× 做出来

先看朴素实现到底浪费在哪。下面这段代码来自 Triton 官方教程,每行都标了流量账:

def naive_softmax(x):
read  MN elements ; write M  elements
x_max = x.max(dim=1)[0]
read MN + M elements ; write MN elements
z = x - x_max[:, None]
read  MN elements ; write MN elements
numerator = torch.exp(z)
read  MN elements ; write M  elements
denominator = numerator.sum(dim=1)
read MN + M elements ; write MN elements
ret = numerator / denominator[:, None]
in total: read 5MN + 2M elements ; wrote 3MN + 2M elements
return ret

5 次读、3 次写。融合 kernel 只需读一遍 x、写一遍 y,流量从 8MN+4M 降到 2MN,理论加速比 (8MN+4M)/2MN ≈ 4×,这就是融合在带宽受限算子上的物理上限。torch.jit.script 一类自动融合之所以达不到,正是因为它在这里并没有真正做融合。

 

图片

这笔账不装 GPU 也能亲自验一遍:给存储访问加个计数器,让朴素分步实现和融合单遍实现各自跑 4096 行,读写次数就摆在了桌面上(实操演示-无环境.py,纯标准库,任何机器可运行):

$ python 实操演示-无环境.py
行宽N     朴素-读      朴素-写     朴素合计    融合-读   融合-写   融合合计  流量比
256   5,251,072   3,153,920   8,404,992  1,048,576  1,048,576  2,097,152  4.01x
2560  52,436,992  31,465,472  83,902,464 10,485,760 10,485,760 20,971,520  4.00x

每行朴素 8N+4 次、融合 2N 次,比值随 N 增大贴向 4×,与上面的分析逐项吻合。要说明的是,这里统计的是访存次数口径;真实带宽与端到端加速比还取决于硬件。

下面是 Triton 融合 kernel(与官方教程一致),每个 program 负责一行:

@triton.jit
def softmax_kernel(output_ptr, input_ptr, input_row_stride, output_row_stride,
n_rows, n_cols, BLOCK_SIZE: tl.constexpr, num_stages: tl.constexpr):
row_start = tl.program_id(0)
row_step  = tl.num_programs(0)
for row_idx in tl.range(row_start, n_rows, row_step, num_stages=num_stages):
row_start_ptr = input_ptr + row_idx * input_row_stride
col_offsets = tl.arange(0, BLOCK_SIZE)
input_ptrs = row_start_ptr + col_offsets
mask = col_offsets < n_cols
row = tl.load(input_ptrs, mask=mask, other=-float('inf'))
row_minus_max = row - tl.max(row, axis=0)
numerator = tl.exp(row_minus_max)
快速近似,相当于 CUDA 的 __expf
denominator = tl.sum(numerator, axis=0)
softmax_output = numerator / denominator
output_ptrs = output_ptr + row_idx * output_row_stride + col_offsets
tl.store(output_ptrs, softmax_output, mask=mask)

这段在做什么:一整行数据一次性载入后常驻片上(SRAM Residency),Max、Sub、Exp、Sum 四步全部在 SRAM 内完成,归约的树状并行结构由编译器自动生成,只有最终结果写回显存,这就是"融合"的字面含义。BLOCK_SIZE 取大于 n_cols 的最小 2 的幂,掩码外的位置填 -inf,保证 max 和 sum 不被污染。有个细节需要留意:tl.exp 是快速近似实现(相当于 CUDA 的 __expf),精度敏感的场景需要另行评估。

 

图片

kernel 之外,Host 端的调度同样决定性能。核心逻辑如下(节选自官方教程,省略了 HIP 分支与部分参数):

def softmax(x):
n_rows, n_cols = x.shape
BLOCK_SIZE = triton.next_power_of_2(n_cols)
1. 静态特化
num_warps = 8
2. warmup 预编译,探测真实的资源消耗
kernel = softmax_kernel.warmup(y, x, ..., grid=(1, ))
kernel._init_handles()
occupancy = min(NUM_REGS // (kernel.n_regs * WARP_SIZE * num_warps),
SIZE_SMEM // kernel.metadata.shared)
3. 持久化网格:喂饱所有 SM
num_programs = min(NUM_SM * occupancy, n_rows)
kernel[(num_programs, 1, 1)](y, x, ..., n_rows, n_cols, BLOCK_SIZE, num_stages)
return y

三板斧各管一件事。BLOCK_SIZE 是编译期常量,编译器可以完全展开循环、消除运行时分支判断;warmup 预编译拿到寄存器用量 n_regs 和共享内存占用量,据此算出每个 SM 能容纳多少个这样的 block,占用率不靠猜,用实测值;网格大小与数据量解耦,每个 program 通过 grid-stride 循环串行处理多行,行数少时不会为凑网格而空转,行数多时 launch 一次就够。

还有两个不太显眼但影响很大的点。其一是连续寻址:归约按步长减半迭代时,交错寻址(相邻线程跨步访问共享内存)会触发 bank conflict,连续寻址(相邻线程读相邻数据)才能吃满带宽。在 CUDA 里这是手写时的纪律,写错不报错、只掉性能;Triton 里 tl.arange(0, BLOCK_SIZE) 显式生成连续索引,从源头杜绝了这类错误。

其二是算法级联:朴素归约分配 O(N) 个线程、走 O(log N) 步,总成本 O(N log N);按 Brent 定理改用 O(N/log N) 个线程,每个线程先串行处理 O(log N) 个元素,再全体协作走 O(log N) 步并行归约,总成本 O(N/log N) × O(log N) = O(N)。落到 Triton 上就是:当 BLOCK_SIZE 远大于物理线程数时,编译器自动让每个线程内部循环处理 BLOCK_SIZE/线程数 个元素。

图片

 

三、性能与口径

先说口径,再看数字。以下数据来自 FlagOS 社区《智能计算系统软硬件基础》课程课件,基于 Triton 官方教程 02(Fused Softmax)基准脚本的实测:固定 M=4096 行,N 从 256 扫到 12672(步长 128),FP32;计时用 triton.testing.do_bench(内置预热与多轮重复,取中位数);带宽按 2 × MN × 4B ÷ 时间 折算,即读+写双向流量。有一处要先交代:课件与官方教程页面都没有标注测试用的 GPU 型号,表中是实测带宽,不是标称值;官方页面同一脚本近期一轮的结果与课件数据逐点差异多在 5% 以内,曲线形态与结论一致。

 

图片

 

图片

从表里能看到三件事。

对朴素实现,融合的收益随 N 增大逼近理论上限:N=256 时 2.43×,N=2560 时 3.79×,曲线右端约 3.8–3.9×(约 1.4 TB/s 对 ~370 GB/s)。

对 torch.softmax,N≤1664 时 Torch 仍领先,小矩阵 launch 开销占比高,PyTorch 的手调 CUDA kernel 在小尺寸上打磨得很足;N=1792 起 Triton 反超(1203.30 对 1200.78),N=2176 处 Torch 出现深度凹陷(962.99 GB/s),Triton 领先 22.87%。

曲线形态同样值得看:Torch 除 N≈2176 外,在 N≈7300–9200 区间还有一段凹陷(按图读数谷底约 1.1 TB/s,同区间 Triton 高出三成左右);不过在 N>9300 的部分点上 Torch 回升并反超(两条线都在 1.4–1.5 TB/s 量级,差距 3–4%),到 N≈12300 之后 Torch 再次回落。Triton 全程平稳、无深度凹陷——对推理服务而言,最差情况往往比平均值更重要。

适用边界也得交代清楚:torch.softmax 支持任意 shape 和更多数据布局,这个 Triton kernel 的适用前提是单行能装进 SRAM。教程里的正确性验证方法值得照抄:用 1823×781 这样的不规则 shape 做 torch.allclose 校验,专门验证掩码逻辑。

 

四、FlagGems:把一个 kernel 变成一个库

到这里有了"一个快 kernel",但真实模型里有几百个算子,手动逐个替换不现实,跨芯片复用更不现实,这正是算子库要解决的问题。FlagGems(FlagOS 旗下、Triton 实现的开源算子库,写作时最新版本 v5.4.0)的思路:把 Triton kernel 注册进 PyTorch 的 ATen 调度体系,让现有模型代码零修改地被替换。

PyTorch 的 dispatcher 本质上是一张按调度键索引的函数表:一次算子调用到达后,先从输入张量收集元数据(设备、dtype、layout),组合生成调度键,再到全局调度表里查内核函数指针,最后调用执行。FlagGems 的注入点就在这张表上,把特定调度键对应的 CUDA 实现替换为 Triton 实现:

注册示意(简化自 FlagGems 对 ATen 算子的注册路径)
_lib = torch.library.Library("aten", "IMPL")
@torch.library.impl(_lib, "softmax.Tensor", "CUDA")
def softmax(input, dim, half_to_float=False):
return flag_gems_softmax_kernel(input, dim)

 

图片

用户侧只有两种开关,用法来自官方文档、可直接运行:

import flag_gems
flag_gems.enable()
全局启用:被支持的 torch.* 调用自动派发到 FlagGems
或只在一个代码块内启用,便于做 A/B 基准与精度对比
with flag_gems.use_gems():
output = model(x)

机制上还有一处容易被忽略的开销:Triton 原生 runtime 每次调用都要在 Python 侧重算缓存键、走一遍调度逻辑。FlagGems 用 LibEntry 自己管理内核缓存——按 shape/dtype/stride 算轻量键,命中直接启动,未命中才编译(以下为课件给出的机制示意):

class LibEntry:
def init(self, fn):
self.fn = fn
self._cache = {}
独立管理的内核缓存
def call(self, *args, **kwargs):
key = self._compute_key(args, kwargs)
轻量缓存键
if key not in self._cache:
self._cache[key] = self.fn.run(*args, **kwargs)
首次:编译
else:
self._cache[key](*args, **kwargs)
命中:直接启动

给这条路径的定位是"后续 Python 开销几乎为零"。跨芯片部分用调度键路由解决:运行时探测可用设备,按 CUDA / XPU / PrivateUse1(自定义芯片的通用键)路由,同一套 Triton 代码库覆盖不同后端,目前支持的硬件后端超过 10 种。在此之上,还提到三类高级调度机制,各自回答一个具体问题:顺序多级调度解决"一个键处理完还有下一个"(屏蔽已处理键、重新派发);启发式选择解决"这个 shape 该用哪条算法路径"(结合形状等负载指标与流处理器数量等硬件属性自适应选路);内核动态实例化解决"没写过的维度组合怎么办"(即时生成并缓存专用内核)。

配套的设计原则同样针对具体矛盾:持久化缓存与预调优消除首次执行的初始化延迟;自适应分块按输入维度选择计算块,在不同序列长度下兼顾填充开销与带宽利用率;多级抽象让高层做快速原型、中层调并行与分块、底层做寄存器级的专家优化。这些对应课时 17 总结的三组权衡——动态形状与硬件对齐、直观布局与最优访存、黑盒 API 与细粒度调优。

 

五、写在最后

回到开头的账:朴素 softmax 的 8MN+4M 显存流量里,只有 2MN 是数学上必须发生的,融合把差额拿了回来,实测 2.43×–3.9×,逼近 4× 的理论上限。但两个反面案例说明,这笔账只有在布局一致、寄存器预算充足时才成立;而从“一个快 kernel”到“用户模型变快”,中间还隔着调度注入、缓存管理、多硬件抽象三道工程。

FlagGems 把这三道全部填平:02 节那颗最高快 3.9×、带宽冲到 1.4 TB/s 的 softmax kernel,加上库里的其余算子,通过 flag_gems.enable() 两行代码就能直接接管现有 PyTorch 模型的对应调用——不需要改模型代码,不需要自己写 kernel,也不需要绑定某一种 GPU。融合优化的性能收益,就这样原封不动地落到了用户的业务代码上。

 

参考与来源

  1. 《智能计算系统软硬件基础》课时 15《算子融合》、课时 17《算子库的架构设计》课件(FlagOS 社区)——本文结构与全部技术点的主要来源

  2. Triton 官方教程 02 Fused Softmax(triton-lang.org)——kernel 与 Host 代码原文、基准脚本;性能数据为课件基于该脚本的实测:M=4096 固定,N∈[256, 12672]、步长 128,FP32,triton.testing.do_bench 取中位数,带宽按读+写双向流量折算;课件与官方页面均未标注 GPU 型号(实测数据,非标称带宽)

  3. openxla/xla Discussion #766(2023-01-18,NVIDIA 工程师)——布局不一致融合回退:fused_computation.1116 耗时 21.63ms,一致布局 2.43ms(Stable Diffusion 基准)

  4. pytorch/pytorch Issue #121857(2024-03-13)——Fused AdamW 回退:A40 单卡、bf16、512M 参数、PyTorch 2.2.0,85→68 TFLOPS;fused kernel 占用率 67% vs foreach 100%,寄存器用量接近翻倍

  5. FlagGems 仓库与官方文档(github.com/flagos-ai/FlagGems,v5.4.0,2026-09-28)——enable()/use_gems()/flag_gems.ops 用法原文;支持后端超过 10 种

  6. ezyang,"Let's talk about the PyTorch dispatcher"(2020-09)——dispatcher 机制

  7. NVIDIA CUDA 归约优化讲义(reduction.pdf)、Stanford CS149——归约成本分析与 Brent 定理

 

关于众智FlagOS社区

为解决不同 AI 芯片大规模落地应用,北京智源研究院联合众多科研机构、芯片企业、系统厂商、算法和软件相关单位等国内外机构共同发起并创立了众智 FlagOS 社区,目前已经有 100多家成员单位。

FlagOS 是一款专为异构 AI 芯片打造的开源、跨芯系统软件栈,支持 AI 模型一次开发即可无缝移植至各类硬件平台,大幅降低迁移与适配成本。它包括大型算子库、跨芯AI 编译器、并行训推框架、跨芯通信库等核心开源项目,致力于构建「模型-系统-芯片」三层贯通的开放技术生态,通过"一次开发跨芯迁移"释放硬件计算潜力,打破不同芯片软件栈之间生态隔离。

官网:https://flagos.io

GitHub 项目地址:https://github.com/flagos-ai

GitCode 项目地址:https://gitcode.com/flagos-ai

SkillHub: https://skillhub.flagos.io

Logo

欢迎来到FlagOS开发社区,这里是一个汇聚了AI开发者、数据科学家、机器学习爱好者以及业界专家的活力平台。我们致力于成为业内领先的Triton技术交流与应用分享的殿堂,为推动人工智能技术的普及与深化应用贡献力量。

更多推荐