CUDA Graph 实战:kernel launch 开销消除原理、stream capture 用法与捕获限制全解
更新时间:2026-09-30。在 CUDA Stream 异步重叠 里,我们关心的是多条流怎么把 kernel 和拷贝在时间上排开;在 CUDA Stream 与异步拷贝 里,重点是 H2D/D2H 拷贝和计算的流水化。这两篇解决的是「GPU 内部忙不忙」的问题,而这一篇换个战场:当瓶颈不在 GPU 算力、而在 CPU 提交 kernel 的速度 时,CUDA Graph 是怎么把几百次 launch 压成一次的。
本文要回答的问题
- 一次 kernel launch 在 CPU 侧到底花多少钱,什么场景下它会成为主瓶颈?
- CUDA Graph 把「启动」变成「重放」,省掉的究竟是哪几段开销?
- stream capture 的标准写法是什么,捕获期、实例化、重放三个阶段各做什么?
- 动态 shape、
cudaDeviceSynchronize、捕获期cudaMalloc为什么会直接让捕获失败? - LLM 推理框架(vLLM、TensorRT-LLM)为什么只在 decode 阶段用 CUDA Graph,prefill 却不用?
一、瓶颈在哪:CPU 提交 kernel 的隐藏成本
一次 kernel<<<grid, block>>> 看起来只是一行代码,但 CPU 侧要走完一条不短的路径:运行时要校验参数、查上下文、准备命令缓冲、把启动命令写进 ring buffer、敲门铃寄存器通知 GPU。一次 launch 的 CPU 侧成本大约是 3-10 微秒,具体取决于驱动版本、GPU 代次和是否开了 MPS。这个数字在 kernel 本身跑几百微秒时无所谓,但当 kernel 只跑 5-20 微秒时,画风就完全变了。
算一笔账。某个 LLM decode step 要启动 60 个小 kernel(每层 RMSNorm、RoPE、attention、MLP 若干),每个 kernel GPU 侧执行 8 微秒。CPU 侧每次 launch 花 6 微秒,看似 6 < 8 能盖住,但 launch 是串行的:CPU 提交第 k+1 个 kernel 前,驱动还有入队、依赖检查的固定开销,实测下来 CPU 提交完 60 个 kernel 需要约 500 微秒,而 GPU 实际干活只要 480 微秒——CPU 成了流水线里更慢的那一段,GPU 时不时断粮,SM 利用率掉到 60% 以下。这种「kernel 又小又密」的场景,正是 CUDA Graph 的主场。
判断自己是不是这类瓶颈,有个零成本的办法:打开 Nsight Systems 抓一段,看 GPU 时间线上相邻 kernel 之间有没有几十微秒的空隙、同时 CPU 时间线上的 CUDA API 调用是不是密密麻麻连成一片。两个特征同时出现,基本可以确诊「提交受限」(launch bound);反过来,如果 kernel 一个贴一个排得很满、GPU 利用率 90% 以上,那是计算受限,CUDA Graph 救不了你,该去优化 kernel 本身。
上图对比了两种模式的本质差别:普通流模式下每次 launch 都要 CPU 走一遍完整提交流程,kernel 越小,CPU 路径占比越高;CUDA Graph 模式下,拓扑结构和 kernel 参数在捕获期就冻结成一张图,重放时 CPU 只发一条「执行这张图」的命令,驱动把整张图的命令缓冲一次推给 GPU。
二、CUDA Graph 是什么:把启动序列编译成一张可重放的图
CUDA Graph 的定义很朴素:把一组 kernel 启动、memcpy、memset 以及它们之间的依赖关系,记录成一张有向无环图(DAG),实例化成一个 cudaGraphExec_t 句柄,之后用一次 cudaGraphLaunch 整体重放。它干的事情和编译器把源码编成机器码是同构的——把解释执行变成编译执行:普通模式是 CPU 逐条「解释」launch 指令,图模式是先把指令序列「编译」成图,重放就是执行编译产物。
省掉的开销具体有四段:参数校验与上下文查找(每个 kernel 一次,图里只在实例化时做一次)、命令缓冲的逐条构建(图在实例化时一次性构建好)、提交路径上的驱动锁与同步点(重放路径大幅精简)、以及 kernel 之间的依赖解析(图里直接用边表达,GPU 硬件按拓扑排序调度,不需要 CPU 介入)。实测收益:一个 64 节点的小 kernel 图,普通模式 CPU 提交约 400-500 微秒,图重放只要 10-20 微秒,CPU 侧开销降低一个数量级以上。GPU 侧 kernel 间隙也变小,因为图的启动命令是预先排好的,GPU 取指执行几乎没有气泡。
还有个容易被忽略的好处:图内的依赖是显式的边,GPU 可以在满足依赖的前提下自动并发执行独立分支——你手写多流 + 事件才能表达的并行结构,捕获时只要发生在不同流上,图会把拓扑原样保留,重放时由硬件调度器自然展开。
三、stream capture:三阶段标准用法
流捕获(stream capture)是最常用的建图方式:不改 kernel 代码,只把原来提交到某个流上的一段工作「录」下来。整个生命周期三个阶段:捕获、实例化、重放。
cudaGraph_t graph;
cudaGraphExec_t graphExec;
cudaStream_t captureStream;
cudaStreamCreate(&captureStream);
// 阶段一:捕获——这段代码里的 launch 不真正执行,只被记录
cudaStreamBeginCapture(captureStream, cudaStreamCaptureModeGlobal);
rmsnorm<<<g, b, 0, captureStream>>>(x, w1, n);
rope<<<g, b, 0, captureStream>>>(q, k, pos);
attention<<<g, b, 0, captureStream>>>(q, k, v, out, seq_len);
mlp<<<g, b, 0, captureStream>>>(out, w2, w3);
cudaStreamEndCapture(captureStream, &graph);
// 阶段二:实例化——驱动校验拓扑、预分配命令缓冲(一次性成本)
cudaGraphInstantiate(&graphExec, graph, NULL, NULL, 0);
// 阶段三:重放——之后每一步只调这一句
for (int step = 0; step < steps; ++step) {
cudaGraphLaunch(graphExec, mainStream);
}
cudaStreamSynchronize(mainStream);三个关键认知。第一,捕获期内 kernel 不执行:BeginCapture 之后提交到该流的工作只是被记录参数和依赖,GPU 上一个指令都不跑,所以别指望捕获期能读到 kernel 的输出,也别在捕获区域里写依赖运行结果的 host 分支。第二,实例化是重活,毫秒级,只做一次;之后重放几千几万次都走轻路径,这就是「摊销」的含义。第三,重放时参数是冻结的——kernel 的指针参数、grid/block 尺寸都是捕获那一刻的值,想换输入数据,必须写到同一块显存地址(指针不变、内容变),这是所有框架用固定显存池喂图的原因。
还有几个容易踩的编码细节:捕获必须在非默认流上进行(legacy 默认流不允许捕获,代码里要显式 cudaStreamCreate);捕获流上提交的依赖顺序会被完整记录,但如果你想表达分支并行,可以在捕获期内 fork 出多条子流、用事件连回主流,图会把这套拓扑保留下来;EndCapture 的返回值一定要检查,捕获期任何非法操作都在这里集中报出来,忽略返回值是上坑下最直接的路径。
这张图把三阶段的成本特征讲清楚了:实例化贵但只做一次,重放便宜且高频,整个模型的收益就来自「把贵的部分摊销掉」。固定显存池是配套工程,因为指针冻结,所有要变化的数据都必须原地更新。
如果图内有一部分参数确实要变(比如 seq_len 变化导致 grid 尺寸变化),CUDA 提供了 cudaGraphExecKernelNodeSetParams 做节点参数热更新,以及 CUDA 12 引入的「conditional node / device graph launch」等机制。但工程上的主流做法更简单暴力:按形状分桶,每个 shape 捕一张图,运行时按 batch/序列长度选图,下文第五节展开。
四、捕获限制:四条红线一碰就裂
stream capture 不是万能的,以下四类操作在捕获期出现就会让 cudaStreamEndCapture 返回错误,或者更糟——静默生成一张语义错误的图。
逐条说。同步调用是红线中的红线:捕获的本质是「记录一段异步工作流」,而 cudaDeviceSynchronize 要求 CPU 等 GPU 跑完——捕获期 GPU 根本没在跑,这个等待语义无意义,所以 CUDA 直接判非法。很多捕获失败不是你自己的代码同步了,而是某个库里藏了同步:老版本 cuBLAS 的某些 heuristic 路径、THC/torch 早期的 .item()、.cpu() 都会触发隐式同步。排查方法是开 cudaStreamCaptureModeGlobal 让任何线程的非法操作都报错,或者更宽松地用 ThreadLocal / Relaxed 模式定位肇事者。
动态内存的坑在于:捕获期 cudaMalloc 返回的地址要记录进图的参数里,但捕获期并不执行,分配时机和地址生命周期都没法保证。正确姿势两种:要么捕获前把显存全部分配好(固定显存池),要么用 cudaMallocAsync 配合 mempool——CUDA 11.2 之后 cudaMallocAsync 在捕获期是合法的,分配动作会被记成图里的 alloc 节点,重放时从池子里分配。
动态 shape 最隐蔽,因为它不一定报错,而是静默错误。典型场景:grid = (batch * heads + 255) / 256,捕获时 batch=4,图冻结了 grid;重放时 batch=8,kernel 还是按 batch=4 的 grid 跑,一半数据没算,结果错了但程序不崩。凡是依赖运行时值的 grid/block 尺寸、依赖 host 变量的指针参数,都要警惕。对策就是分桶捕获:batch 1/2/4/8/16 各捕一张,运行时选桶;不规整的 shape 落到普通模式兜底。
未接管的 API 是个收缩中的名单:CUDA 版本越新,图内合法操作越多(host node、child graph、conditional node 陆续加入),但第三方库内部实现不可见,稳妥做法是把要捕获的区域收缩到纯 kernel 序列,库调用放图外,或者先小范围试捕、校验重放结果与逐 launch 模式逐位一致再上量。
五、LLM 推理:decode 阶段的标配优化
LLM 推理是 CUDA Graph 最成功的落地场景,原因恰好命中前面所有条件:decode 阶段每步只处理一个 token,kernel 又小又多(一个 70B 模型 80 层,每层 5-8 个 kernel,一步 decode 四五百次 launch),每次 launch 的 GPU 执行时间只有几微秒——CPU 提交速度直接决定 token 生成速度的上限。vLLM、TensorRT-LLM、SGLang 全部把 CUDA Graph 作为 decode 路径的标配。
上图解释了为什么框架只给 decode 用图。prefill 处理整个 prompt,attention kernel 跑几百微秒甚至毫秒级,launch 开销占比不到 1%,用图没收益还要背 shape 分桶的复杂度;decode 每步一个 token,小 kernel 密集,正是图的主场。在 PagedAttention 与 vLLM 推理服务 里我们讲过 vLLM 用分页 KV cache 解决显存碎片,而它的执行层另一个支柱就是 decode 走 CUDA Graph:按 batch size 分桶捕获,每个 bucket 的图在 warmup 阶段就实例化好,运行时把新的 token id 和 KV cache 元数据写进固定地址,然后 cudaGraphLaunch 一步到位。收益直接体现在 TPOT(Time Per Output Token,每输出 token 耗时)上,典型模型能降 20%-40%,而 TTFT(首 token 时间)不受影响。
工程上还有两个细节值得抄作业。一是** warmup 捕获**:服务启动时对每个 bucket 跑一次完整前向并捕获,此时显存池、cuBLAS workspace 都已就位,避免服务期才捕获撞上分配。二是回退路径:遇到没捕过的 shape(比如 batch 33)或者图内不支持的算子,框架静默回落到普通逐 launch 模式,只损失性能不损失正确性——这个「图是优化、不是语义」的边界意识,是自己写图代码时也该守住的。
六、上手清单:什么时候该用、怎么验证生效
决策可以压缩成三条判据:单 kernel 平均 GPU 执行时间低于 20 微秒、一次迭代 launch 次数超过几十次、迭代形状(shape 组合)数量有限可分桶——三条全中,CUDA Graph 大概率值回票价;kernel 本来就跑几百微秒的计算密集型场景,不用折腾。
验证收益的正确姿势是用 Nsight Systems 看时间线:开图之前,应该能看到 GPU track 上 kernel 之间有明显气泡,CPU track 上 launch API 调用连绵不断;开图之后,kernel 排布变得致密,CPU 侧每次迭代只剩一个 cudaGraphLaunch。只看端到端延迟容易被噪声骗,时间线上「气泡消失」才是图生效的直接证据。
正确性验证同样不能省:同一份输入,先跑普通模式记一份输出,再跑图模式,两者逐位比对(浮点场景允许最后一个 ulp 以内的差异,因为调度顺序可能微调归约顺序)。这一步能抓住绝大多数「静默错误」类问题——比如忘了某个指针指向的 host 变量在重放前已经变了。把这套比对做成 CI 里的常驻用例,后续每次改图内算子都能自动兜底。
| 场景特征 | 普通流模式 | CUDA Graph |
|---|---|---|
| kernel 平均时长 | >100 us,launch 开销可忽略 | <20 us,launch 占比高 |
| 单次迭代 launch 数 | 个位数 | 几十到几百 |
| 输入 shape | 每次都变 | 有限集合可分桶 |
| 代码里的同步/分配 | 无法去除 | 能改造成异步 + 预分配 |
| 典型代表 | 训练大 step、prefill | LLM decode、小模型推理、控制回路 |
这一篇在知识体系里的位置
CUDA Graph 解决的是「提交侧」瓶颈,和它正交的还有两条优化线:GPU 内部的并行排布,见 CUDA Stream 异步重叠 与 CUDA Stream 与异步拷贝——图捕获甚至可以和多流配合,把多流拓扑录进图里;kernel 本身的算子级优化(算子融合、量化、引擎级调度)见 TensorRT 推理优化。落到完整服务上,PagedAttention 与 vLLM 推理服务 展示了 CUDA Graph 与分页 KV cache、连续批处理怎么拼成一个高吞吐推理引擎。
总结
CUDA Graph 把一串 kernel launch 从「CPU 逐条解释执行」变成「一次捕获、整体重放」,省掉每次 launch 的参数校验、命令构建和依赖解析开销;它只对「小 kernel 密集、shape 可分桶、无同步无动态分配」的场景有效——LLM decode 是最典型代表——使用时守住固定指针、分桶捕获、保留回退路径三条纪律,就能把 CPU 提交从流水线里摘出去,让 GPU 不再等饭。