kernel launch 开销:小 kernel 启动成本怎么测,什么时候该融合、什么时候上 CUDA Graph
更新时间:2026-10-03。GPU 编程这条线我们已经聊过执行侧的优化:Occupancy 与寄存器压力 讲单个 kernel 内部怎么喂饱 SM,CUDA Stream 异步重叠 讲多个 kernel 怎么排开互相掩盖。但这两篇都假设 kernel 本身足够「重」——跑几十微秒以上,启动那几微秒摊薄后无所谓。真实模型里大量 elementwise、归一化、reshape 类小 kernel 单次只跑 2-5 微秒,这时 kernel launch 开销(每次向 GPU 提交 kernel 的固定 CPU 侧成本)就从背景噪声变成主角。这篇讲这笔开销从哪来、怎么测准,以及消除它的两条路线——算子融合与 CUDA Graph 捕获与回放——各自的边界在哪。
本文要回答的问题
- 一次 kernel launch 的固定开销由哪几部分构成?典型数值是多少?
- 测量启动开销时有哪些坑,为什么说「空 kernel 循环计时」会严重低估?
- 什么样的 kernel 算「小 kernel」,判定该不该融合的量化边界在哪?
- 融合与 CUDA Graph 都能消启动开销,两者的适用场景怎么分?
- 融合过头有什么代价?为什么说融合不是越多越好?
一、启动开销从哪来:一次 launch 的解剖
一次 kernel<<<grid, block>>>(args) 看起来只是一行代码,背后却要走完一条固定流水线:运行库校验参数与流状态、把 kernel 参数和启动描述符打包、通过 ioctl 或用户态环形缓冲把启动命令写进 GPU 的命令队列、GPU 前端取命令后做 grid 初始化与调度分发。这条路径的成本与 kernel 本身跑多久完全无关——跑 1 微秒的 kernel 和跑 1 毫秒的 kernel,提交成本几乎一样。
经验数值上,现代 CUDA 平台上一次 launch 的 CPU 侧提交成本约 3-5 微秒,叠加 GPU 侧启动与收尾后端到端「空转」约 5-10 微秒;CUDA Graph 回放单个节点可压到 1-2 微秒。这个数量级意味着一个简单判据:kernel 执行时间低于约 10 微秒时,启动开销占比就超过 50%,kernel 越小亏得越狠。一个逐元素激活 kernel 算 2 微秒、启动花 6 微秒,等于每干 1 份活交 3 份「过路费」。
上图把一次 launch 拆成五段。要点是只有中间一段在干活,两头都是固定税费;kernel 越大税费摊得越薄,kernel 越小整条流水线越像「为了开一张发票跑一趟税务局」。
二、怎么测:别用空 kernel 循环骗自己
测启动开销最直觉的写法是 for 循环里发一万次空 kernel、除以一万——这个数会漂亮得离谱(常低到 2 微秒以下),因为它测的是「CPU 提交进队列的吞吐」,不是「端到端延迟」。队列有深度时,launch 是异步的:CPU 把命令丢进队列就返回,真正的串行瓶颈被流水线掩盖了。两个更诚实的测法:
**测法一,每轮 launch 后强制同步。**每次 launch 后调 cudaStreamSynchronize 再计时,强迫流水线排空,这时单次的端到端成本(提交 + 执行 + 完成信号回传)才暴露出来。典型结果是 5-10 微秒,比异步循环法高 2-3 倍。
测法二,用 profiler 看时间轴空隙。Nsight 性能分析 的时间轴上,kernel 之间的 gap 就是启动与调度的真实开销——而且是在你的真实模型、真实流结构下的开销,比合成 benchmark 可信得多。看 gap 时注意区分「启动开销」与「等依赖」:前一个 kernel 没跑完时后一个在排队,那不是 launch 贵,是依赖没解开。
还有一个常见误读:CPU 侧 wall time 显示 launch 调用只花 2 微秒,就断言启动开销不大。错——那只是把命令塞进队列的耗时;如果 GPU 端 kernel 队列已经排空、下一个 kernel 要等命令跨 PCIe/片上互连到达,这部分延迟体现在 GPU 时间轴的 gap 里,不体现在 CPU 计时里。两份账要对着看。
三、融合的决策边界:省启动次数,但不止省启动次数
消除启动开销的第一条路线是算子融合(kernel fusion):把一串连续小 kernel 合成一个,启动次数从 N 降到 1。但融合的收益账本上启动开销只是第一项,往往还不是最大的一项:中间结果不落显存通常更值钱——两个 kernel 融合后,第一个的输出不必写回全局内存再被第二个读回,省掉一整圈显存带宽,而 elementwise 类 kernel 恰恰都是带宽瓶颈。加上启动开销,一笔典型账是这样:
| 收益项 | 未融合 N 个小 kernel | 融合后 1 个 |
|---|---|---|
| 启动开销 | N × 5-10 us | 1 × 5-10 us |
| 中间结果显存读写 | 每步一次写 + 一次读 | 寄存器/共享内存内消化 |
| 缓存局部性 | 跨 kernel 数据早已出 L2 | 同一数据片上复用 |
量化决策边界可以用一条朴素规则:候选 kernel 串里单 kernel 执行时间越短、kernel 个数越多、中间张量越大,融合越赚。反过来,矩阵乘、卷积这类单 kernel 就跑几百微秒的算子,融合省的那几微秒启动开销是零头,价值只在省显存往返——这类算子另有专门优化路径,见 GEMM Split-K 与 Stream-K 调度。
工程上最甜的融合点是逐元素链和归一化组合:bias add + GELU、RMSNorm + RoPE + 残差加 这类模式。RMSNorm 与 RoPE 融合成单 kernel 的实战见 RMSNorm 与 RoPE 融合 kernel;用 Triton 快速搭融合 kernel 并用 autotune 扫配置的方法见 Triton kernel 与 autotune。PyTorch 侧 torch.compile 的 Inductor 后端做的就是自动识别这类可融合子图——它生成的融合 kernel 本质上就是手工融合思路的编译器版。
四、融合不是免费的:三个反方向代价
融合决策要是只看收益,就会把不该融的也融了。三个真实的代价:
**第一,并行度坍缩。**小 kernel 各自启动时 grid 尺寸可以按各自的数据量配;融合成一个 kernel 后 grid 必须一刀切,中间某个阶段算子本身并行度低(比如归约的收尾段),会拖着整个 kernel 的 occupancy 下沉——启动开销省了,执行效率亏了。用 Occupancy 与寄存器压力 的方法检查融合后 kernel 的占用率,是必要的验证步骤。
**第二,寄存器与共享内存压力。**融合 kernel 要在片上同时容纳多个阶段的中间状态,寄存器用量往往是各阶段之和的上界,超标后要么 spill 到本地内存(比不融合还慢),要么被迫降 block 尺寸。
**第三,失去流间并行。**未融合的小 kernel 如果分布在不同流上,原本可以靠 CUDA Stream 异步重叠 互相掩盖;融合成一个大 kernel 后反而串行化了。融合的收益必须和「本可重叠掉的时间」对冲着算。
五、CUDA Graph:不改 kernel,改启动方式
第二条路线不动 kernel 本身,而是把「一串 kernel 的启动过程」整体录下来再回放。CUDA Graph 先通过捕获把一段 kernel 序列及其依赖关系固化成图,之后每次执行用一次 cudaGraphLaunch 整体提交——N 次 launch 的 CPU 侧成本被压成 1 次,GPU 侧节点间调度开销也大幅缩水。机制细节见 CUDA Graph 捕获与回放,这里只划它和融合的适用边界。
direction: down
shape: "kernel 序列形状是否固定"
graph: "优先 CUDA Graph\n零侵入、启动开销一次付清"
bw: "带宽瓶颈是否主导"
fuse: "做算子融合\n省显存往返是主收益"
both: "两者叠加\n先融合减节点、再 Graph 压启动"
说明1: "LLM decode 主流组合:\ntorch.compile 融合加 CUDA Graph 回放" { shape: text }
shape -> graph: "固定(推理 decode 典型)"
shape -> bw: "不固定或还需省带宽"
bw -> fuse: "是"
bw -> both: "既要带宽也要压启动"
both -- 说明1
shape.style: { fill: "#EAF2FE"; stroke: "#3B6FD4" }
bw.style: { fill: "#EAF2FE"; stroke: "#3B6FD4" }
graph.style: { fill: "#FEF3E2"; stroke: "#E08A1E" }
fuse.style: { fill: "#FEF3E2"; stroke: "#E08A1E" }
both.style: { fill: "#E9F8F0"; stroke: "#2E9E6B" }上图是两条路线的分流逻辑,核心判据两条。其一,形状是否固定:CUDA Graph 要求每次回放的 kernel 序列、参数指针、grid 形状完全一致,动态 shape 或含 CPU 分支的序列录不进去;LLM decode 阶段每步形状天然固定,是 Graph 的完美场景。其二,主瓶颈是什么:Graph 只省启动与调度,不省显存带宽——如果小 kernel 串的痛点在中间结果的显存往返,只有融合能治。所以生产系统的答案通常是叠加:先融合把节点数砍下来(还顺手治了带宽),再用 Graph 把剩余节点的启动开销一次付清。vLLM、TensorRT-LLM 的 decode 路径都是这个组合。
两条路线的对照收在下表:
| 维度 | 算子融合 | CUDA Graph |
|---|---|---|
| 省启动开销 | 是(N 次到 1 次) | 是(提交与调度都压) |
| 省显存带宽 | 是,常为主收益 | 否 |
| 侵入性 | 高,要改/写 kernel | 低,不改 kernel 本体 |
| 形状要求 | 无 | 严格固定 |
| 典型场景 | elementwise 链、归一化组合 | decode 循环、固定迭代步 |
这一篇在知识体系里的位置
本篇属 GPU 编程「启动与调度开销」环节:上游是 CUDA 线程层次 grid 与 block(kernel 怎么被组织)与 CUDA Stream 异步重叠(多个 kernel 的调度空间);同层对照 CUDA Graph 捕获与回放(另一条消除路线)与 Nsight 性能分析(测量工具);下游延伸是融合 kernel 的具体写法——RMSNorm 与 RoPE 融合 kernel 和 Triton kernel 与 autotune。
总结
kernel launch 开销是每次提交的 3-10 微秒固定税费,kernel 执行时间低于约 10 微秒时它就反客为主;测量要靠「同步后计时」和 Nsight 时间轴 gap,别被异步循环的虚假低值骗了。消除它有两条路:融合把 N 次启动并为 1 次、顺带省掉中间结果的显存往返,但要防并行度坍缩和寄存器爆炸;CUDA Graph 不动 kernel、把整段启动录下来一次回放,代价是形状必须固定。生产里的标准答案是叠加——先融合减节点,再 Graph 压启动,decode 路径因此能把每步几十次 launch 的开销打到接近零。