AI基础设施 · 07
同一段计算,为什么拆成几个 kernel 就多搬了数据?
中间张量跨 kernel 边界可能增加读写。用同一例子区分融合、编译和 CUDA Graph,并把首次等待与稳定耗时分开记。
读完能判断:沿原中间结果路径区分融合收益、graph break 与启动开销。
📑 本页目录(点开跳转)
07 · 算子融合与编译
⏱ 主线约 30 分钟 | ⭐ 先算中间张量,再验证提速
🎯 一句话
先把两个数组对应位置相加,再把负数变为 0。分两次做时,第二次得拿到完整的加法结果。若同一个内核能在算出某个位置的和之后立即取最大值,就可以直接写最终结果。第 6 章改变数字的精度,本章固定精度,接着问中间值必须搬到哪里。
🔥 一、问题:kernel 边界可能增加显存读写与启动
把加法和取最大值分别交给 GPU。每次提交的设备程序叫内核(Kernel)。先假设一个算子对应一次内核启动,中间结果没有其他使用者。把可一起完成的算子放到同一个内核,称为算子融合(Operator Fusion)。
同一组输入,观察中间和放在哪里
令 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]。每个位置独立,所以不需要等整个中间数组写完再处理同一位置。
| 账目 | 分开 | 融合 |
|---|---|---|
| 读 x、y | 8 MB | 8 MB |
| 写、读 tmp | 8 MB | 0 MB |
| 写 z | 4 MB | 4 MB |
| 逻辑读写 | 20 MB | 12 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」这条依赖,捕获它之后,后端才有机会选择融合。
图里看到什么,后端才有机会优化什么
- TorchDynamo 在执行 Python 时捕获可识别的张量操作,生成图并记录形状、类型等适用条件(guards)。
- AOTAutograd 在常见训练编译链中安排前向和反向图;推理不用生成训练梯度。
- 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 结果作为参考。若测训练,还要对齐前向、梯度与更新范围。浮点计算可以因累加顺序或中间值精度而出现舍入差异,按任务的精度要求选容差。
先验证,再分开记录冷启动和稳定运行
- 先验正确。核对形状、类型和逐元素差异。若参考值是 5.0,绝对容差为 0.0001、相对容差为 0.001,允许差值是 0.0001 + 0.001 × 5.0 = 0.0051。候选 5.001 的差值 0.001 在本例容差内。用
torch.testing.assert_close时可明确传这两个阈值,换数据类型要重新定。 - 单列首次等待。记录首次调用到完成的端到端时间,标明编译缓存是否已热。不同形状会触发重编译时,把那部分等待也记录下来。
- 再测稳定段。两版都预热到稳定。墙钟计时前后同步被测 CUDA 设备,避免把异步入队当作执行完成。若只测设备区间,可用同一流上的 CUDA 事件并等待结束事件完成。
- 多次重复。在同一计时范围下报告重复次数、中位数和离散程度。看 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 可能影响同步或图捕获,按日志确认 |
✅ 检查点
- 第一节每个数组是 4 MB。分开与融合各读写多少逻辑字节?
- 若临时数组在 L2 命中,为什么不能仍说 HBM 少了 8 MB?
- 捕获到一张图,为什么还可能生成多个内核?
- 换形状后日志报重编译,与遇到数据依赖控制流而断图有什么不同?
- 首次多花 30 ms,每次稳定调用只省 0.1 ms,多久抵平?
- 为什么 GPU 计时要等设备执行完成?比较性能之前还要验什么?
- 若把原本两个内核直接录入 CUDA Graph,重放时会自动少一次中间数组读写吗?
- 什么时候值得比较手写 Triton?
👀 答案
- 分开读两个输入、写读一份中间数组、写一个输出,5 × 4 = 20 MB。融合剩 3 × 4 = 12 MB。
- 逻辑账按数组访问计,L2 命中会降低某些访问的显存流量,实际 HBM 读写要用设备计数验证。
- 图表示依赖。不同依赖、形状和后端约束会影响可合并的范围,也可能选已有库。
- 重编译是已有图的适用条件不匹配。断图是走到无法继续捕获的操作,后面仍可能继续捕获。
- 30 ÷ 0.1 = 300 次稳定调用时抵平,之后才净省;若又重编译,额外等待还要另算。
- 设备可能尚未执行完已入队的工作。先核对形状、类型、输出误差,训练还要查梯度和更新,再比较稳定执行与首次耗时。
- 不会。重放改变提交方式,录入的内核边界和中间数组仍在;减少中间数组要靠实际发生的融合。
- 已有实现和编译路径不能解决实际热点时,结合数据流上限、实现与维护成本,再在同一输入上验证手写方案。
本节回顾
先记住这三件事
- 先按数组列读写账,再到实际存储层核对流量;能融合时,中间值可能不必写出去。
- 捕获、编译和重放解决的开销各不相同。断图看捕获边界,重编译看适用条件。
- 先核对数值,再分开测首次、稳定执行和服务延迟。下一章用注意力中间矩阵看分块怎样减少搬运。
下一节 👉 08-FlashAttention.md ⭐