🏠 总目录📚 本教程 算子融合与编译 ← →

AI基础设施 · 07

同一段计算,为什么拆成几个 kernel 就多搬了数据?

中间张量跨 kernel 边界可能增加读写。用同一例子区分融合、编译和 CUDA Graph,并把首次等待与稳定耗时分开记。

读完能判断:沿原中间结果路径区分融合收益、graph break 与启动开销。

📑 本页目录(点开跳转)

07 · 算子融合与编译

⏱ 主线约 30 分钟 | ⭐ 先算中间张量,再验证提速


🎯 一句话

先把两个数组对应位置相加,再把负数变为 0。分两次做时,第二次得拿到完整的加法结果。若同一个内核能在算出某个位置的和之后立即取最大值,就可以直接写最终结果。第 6 章改变数字的精度,本章固定精度,接着问中间值必须搬到哪里。


🔥 一、问题:kernel 边界可能增加显存读写与启动

把加法和取最大值分别交给 GPU。每次提交的设备程序叫内核(Kernel)。先假设一个算子对应一次内核启动,中间结果没有其他使用者。把可一起完成的算子放到同一个内核,称为算子融合(Operator Fusion)。

同一组输入,观察中间和放在哪里

分开:读 x、y → 加法写出 tmp → ReLU 读 tmp → 写结果
融合:读 x、y → 片上求和并做 ReLU → 写结果

令 x、y 是长度同为 n 的数组,i 是从 0 到 n − 1 的元素下标。输出 zi = max(0, xi + yi)。这个取最大值的规则叫修正线性单元(ReLU),负数变 0,非负数保留。取 x = [−3, 2, 4]、y = [1, 3, −7],对应相加得 [−2, 5, −3],最终写 [0, 5, 0]。每个位置独立,所以不需要等整个中间数组写完再处理同一位置。

一百万个 FP32 元素,两种假设执行方式
账目分开融合
读 x、y8 MB8 MB
写、读 tmp8 MB0 MB
写 z4 MB4 MB
逻辑读写20 MB12 MB
内核启动2 次1 次

复算字节。设 b 是每个元素的字节数。n = 1,000,000、FP32 的 b = 4 字节,所以一个数组占 n × b = 4,000,000 字节 = 4 MB。分开执行的加法读两份、写一份,记 3 × 4 = 12 MB。ReLU 读一份、写一份,记 2 × 4 = 8 MB,合计 20 MB。融合只读两份并写最终一份,合计 3 × 4 = 12 MB,少搬两份中间数组。

这笔逻辑读写按程序里被读取或写出的数组计。若假设这些字节全部经过显存(HBM),且两版都能用 1 TB/s(1012 字节/秒)搬运,按第 3 章的字节数 ÷ 带宽,20 MB ÷ 1 TB/s = 20 μs,12 MB ÷ 1 TB/s = 12 μs(1 μs 是百万分之一秒)。差 8 μs 只是这个假设下的搬运时间差。L2 缓存可能承接中间数据,额外内存事务或寄存器不足引起的溢出也可能增加流量。用第 4 章的 Roofline 分析时,要把实际 HBM 字节配上 HBM 带宽。

两次启动变成一次,也可能缩短主机提交的等待。实际节省多少要看启动与执行能否重叠、内核效率和依赖关系,不能把两笔假设收益直接相加。若中间和还要交给别的算子,或下一步必须先汇总所有元素,编译器也可能保留写出、分开执行或选择不同融合边界。

用标准 Python 复算小输入和字节表。先把两种路径各算一次并核对结果。再用 elements * bytes_per_element 算一个数组的大小,分别乘上 5 次和 3 次完整数组访问。小例用整数验证数学等价,字节表按独立的大数组模型计。

x = [-3, 2, 4]
y = [1, 3, -7]
tmp = [a + b for a, b in zip(x, y)]
separate = [max(0, value) for value in tmp]
fused = [max(0, a + b) for a, b in zip(x, y)]
assert separate == fused == [0, 5, 0]

elements = 1_000_000
bytes_per_element = 4
array_bytes = elements * bytes_per_element
print(fused)
print(5 * array_bytes, 3 * array_bytes)

输出先是 [0, 5, 0],再是 20000000 12000000(字节)。可改元素个数或字节数重新算账。这段程序不调用 GPU,也没有测量速度。

选读:把逐元素操作放进矩阵乘的尾部

例如 y = gelu(x @ W + b) * scale。矩阵乘先产生一个输出块,随后加偏置、做激活再乘比例。支持这些尾部操作的库可能在写回该块前完成部分处理,这叫尾部融合(epilogue fusion)。是否能合并到同一个内核取决于形状、精度、后端和数值约束。若多个内核仍需交换数据,就按实际边界逐笔记账。


🪄 二、torch.compile:捕获、编译与复用

# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
import torch
model = torch.compile(model)          # ⭐ 就这一行

上面的调用把模型交给编译器。第一次运行时,能识别的张量操作会被捕获,然后再决定哪些操作可以放在同一个内核。用本章的加法与 ReLU 来看,计算图里有「加法 → ReLU」这条依赖,捕获它之后,后端才有机会选择融合。

图里看到什么,后端才有机会优化什么

  1. TorchDynamo 在执行 Python 时捕获可识别的张量操作,生成图并记录形状、类型等适用条件(guards)。
  2. AOTAutograd 在常见训练编译链中安排前向和反向图;推理不用生成训练梯度。
  3. Inductor 是默认优化后端,按设备和操作选择融合、自生成内核或调用已有库。捕获成一张图仍可能运行多个内核。
模式 说明
default 默认在编译成本和运行性能间取平衡
reduce-overhead 在可捕获的 CUDA 路径用 CUDA Graph 减少重复提交,可能需要额外缓冲
max-autotune 尝试更多候选内核配置,编译可能更久,运行收益看实测

模式描述和使用条件见 PyTorch API。是否值得采用,取决于图能否复用、执行瓶颈和任务实际运行多久。

⚠️ 五个要区分的症状

坑 症状 解法
graph break ⭐ 一段 Python 没被捕获,可捕获的片段仍可能编译 TORCH_LOGS="graph_breaks" 查在哪断的
动态形状反复重编译 输入不满足已有图的条件,又生成适用的版本 先看 recompiles 原因,再比较动态形状设置或分桶补齐
代码里有 .item() / print 可能同步或触发 graph break,依版本与配置而变 需要保留的日志移到编译区域外,再确认读标量的同步
数据依赖的控制流 if x.sum() > 0: 依赖张量数据,常见设置下可能切断捕获 先确认两分支的数值与副作用,再考虑张量运算或受支持的控制流
首次编译很慢 冷启动比稳定执行慢 另报首次延迟,不把编译等待混入稳定段
# ⭐ 排查 graph break 的标准做法
TORCH_LOGS="graph_breaks,recompiles" python train.py

断图和重编译是两件事。断图(graph break)是捕获走到暂时不能纳入图的操作,默认设置下可能执行那段 Python 后继续捕获。重编译是新调用没有满足已编译图的条件。某一维长度改变不一定断图,已有图也可能支持多种长度。先用上面的日志分清两者,再对照 PyTorch 动态形状说明。

用同一段加法与 ReLU 做对照。先固定输入、形状、类型、设备和输出需求,保留 eager 结果作为参考。若测训练,还要对齐前向、梯度与更新范围。浮点计算可以因累加顺序或中间值精度而出现舍入差异,按任务的精度要求选容差。

先验证,再分开记录冷启动和稳定运行

  1. 先验正确。核对形状、类型和逐元素差异。若参考值是 5.0,绝对容差为 0.0001、相对容差为 0.001,允许差值是 0.0001 + 0.001 × 5.0 = 0.0051。候选 5.001 的差值 0.001 在本例容差内。用 torch.testing.assert_close 时可明确传这两个阈值,换数据类型要重新定。
  2. 单列首次等待。记录首次调用到完成的端到端时间,标明编译缓存是否已热。不同形状会触发重编译时,把那部分等待也记录下来。
  3. 再测稳定段。两版都预热到稳定。墙钟计时前后同步被测 CUDA 设备,避免把异步入队当作执行完成。若只测设备区间,可用同一流上的 CUDA 事件并等待结束事件完成。
  4. 多次重复。在同一计时范围下报告重复次数、中位数和离散程度。看 profiler 中实际内核数和对应阶段,必要时查显存流量。线上还要另看请求时延。

例如假设编译比 eager 多花 30 ms 的一次性开销,之后每次稳定执行从 0.7 ms 降到 0.5 ms。每次省 0.7 − 0.5 = 0.2 ms。若两版后续都稳定且不重编译,30 ÷ 0.2 = 150 次稳定调用后才刚抵平;第 151 次才开始净省。这里把首次额外等待和后续稳定执行分别记账,数字只是示意。

对照依据:PyTorch 编译与同步计时示例、PyTorch 数值校验、CUDA 带宽测量。


✍️ 三、Triton:需要手写时的选择

import triton, triton.language as tl

@triton.jit
def fused_add_relu(x_ptr, y_ptr, out_ptr, n, BLOCK: tl.constexpr):
    pid = tl.program_id(0)
    offs = pid * BLOCK + tl.arange(0, BLOCK)
    mask = offs < n
    x = tl.load(x_ptr + offs, mask=mask)      # ⭐ 一次读
    y = tl.load(y_ptr + offs, mask=mask)
    out = tl.maximum(x + y, 0.0)              # 加法和 relu 在寄存器里完成
    tl.store(out_ptr + offs, out, mask=mask)  # ⭐ 一次写

上面的 Triton 内核是第一节加法与 ReLU 的设备实现片段。pid 指当前程序实例,BLOCK 是每个实例负责的位置数。offs 算出位置,mask 让不足一整块的尾部避免越界,最后每个有效位置写一次。片段只定义内核,实际运行还需准备设备张量和启动参数。下表比较两种写法对程序员暴露的层次。

Triton CUDA
语言 Python 风格的内核语言 常用 CUDA C++
你要管的 block 级别 thread 级别
布局与调度 编译器处理许多底层选择,仍需检查布局与访存 可显式控制线程组织、共享内存和同步
性能 用同形状、同精度与基线比较 也受实现和硬件限制
上手 先理解数据块与掩码 再深入线程和内存细节

⭐ 什么时候值得手写:

① torch.compile 试过了,profiler 显示某个 kernel 仍是瓶颈
② 这个模式框架里没有(比如自定义的稀疏注意力)
③ 你能算出理论上限,且当前实现离它很远(第 4 章)

❌ 不满足这三条 → 别写,成本不划算

这三条是筛选手写投入的线索。即使理论空间很大,也要考虑可移植性、维护与数值验证成本。


📦 四、现成的融合实现(优先用这些)

要点

先看现成库能否满足目标,再比较编译路径和手写投入。

来源 提供什么
FlashAttention 融合的注意力(第 8 章)⭐
F.scaled_dot_product_attention PyTorch 内置接口,按设备、类型、形状和配置选择适用后端
Apex / TransformerEngine 融合 LayerNorm、融合 Adam、FP8 支持
xFormers 各种注意力变体
torch.optim 的融合选项 例如支持的 AdamW(fused=True) 路径
# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
# ⭐ 融合优化器:把 Adam 的几十个小 kernel 合成一个
import torch
opt = torch.optim.AdamW(model.parameters(), lr=3e-4, fused=True)
#                                                    ↑ 常有 5-10% 提升

上例保留了原优化器写法。注释中的内核数量与收益只是示意,实际受设备、类型、参数组织和版本影响。PyTorch AdamW、PyTorch SDPA。


🧊 五、CUDA Graph:减少重复提交

同样两次运算,改变的开销不同

融合:把加法和 ReLU 放进一个内核,减少中间数组的写、读,并少一次内核启动。

CUDA Graph:录下内核和依赖,之后重放整组工作来减少逐项提交。若录下的是两个内核,重放仍可以是两个,中间数组照旧存在。

重放时需要保持已捕获工作所依赖的执行结构、内存地址等条件。常见做法是向固定缓冲写入新值,或按输入形状选适用的图。不能捕获的操作需另走路径;是否重放要看实际环境。PyTorch CUDA Graph 说明。

# 🧩 骨架:`model` 来自你自己的代码,这一段只看写法
import torch
model = torch.compile(model, mode="reduce-overhead")   # ⭐ 自动用 CUDA Graph

reduce-overhead 在满足条件的 CUDA 路径可以使用图重放。看到时间线上 GPU 有空档,先把同一时刻的主机提交、数据准备、同步和通信对齐。确认空档与逐个内核的提交有关后,再做重放对照。单看 CPU 忙或 GPU 空不能确定原因。


🔗 和站内其他章的关系

相关的地方 这里的位置
第 3 章 逐元素算术强度 0.17 逐元素操作可能受搬运限制;融合可减少中间数据的逻辑读写
第 2 章 Shared Memory 有机会把临时值留在寄存器或共享内存
第 4 章 一堆小 kernel profiler 里融合机会的信号
第 8 章 FlashAttention 用分块与在线归一化减少中间注意力矩阵的显存往返
《机器学习与深度学习基础》15 PyTorch 实战手册 提速三件套 那里教你加上 torch.compile,本章讲它为什么有效、以及五个让它白加的坑 ⭐
《机器学习与深度学习基础》11 训练调试手册 训练循环里打印中间值 .item() 或 print 可能影响同步或图捕获,按日志确认

✅ 检查点

  1. 第一节每个数组是 4 MB。分开与融合各读写多少逻辑字节?
  2. 若临时数组在 L2 命中,为什么不能仍说 HBM 少了 8 MB?
  3. 捕获到一张图,为什么还可能生成多个内核?
  4. 换形状后日志报重编译,与遇到数据依赖控制流而断图有什么不同?
  5. 首次多花 30 ms,每次稳定调用只省 0.1 ms,多久抵平?
  6. 为什么 GPU 计时要等设备执行完成?比较性能之前还要验什么?
  7. 若把原本两个内核直接录入 CUDA Graph,重放时会自动少一次中间数组读写吗?
  8. 什么时候值得比较手写 Triton?
👀 答案
  1. 分开读两个输入、写读一份中间数组、写一个输出,5 × 4 = 20 MB。融合剩 3 × 4 = 12 MB。
  2. 逻辑账按数组访问计,L2 命中会降低某些访问的显存流量,实际 HBM 读写要用设备计数验证。
  3. 图表示依赖。不同依赖、形状和后端约束会影响可合并的范围,也可能选已有库。
  4. 重编译是已有图的适用条件不匹配。断图是走到无法继续捕获的操作,后面仍可能继续捕获。
  5. 30 ÷ 0.1 = 300 次稳定调用时抵平,之后才净省;若又重编译,额外等待还要另算。
  6. 设备可能尚未执行完已入队的工作。先核对形状、类型、输出误差,训练还要查梯度和更新,再比较稳定执行与首次耗时。
  7. 不会。重放改变提交方式,录入的内核边界和中间数组仍在;减少中间数组要靠实际发生的融合。
  8. 已有实现和编译路径不能解决实际热点时,结合数据流上限、实现与维护成本,再在同一输入上验证手写方案。

本节回顾

先记住这三件事

下一节 👉 08-FlashAttention.md ⭐

条件与依据

本章两条路径是明确边界下的演示。后端可能融合尾部、拆分执行或保留中间值。应以实际生成的内核和计数器核对。

官方文档

打卡记录保存在你的浏览器里,首页能看到总进度