PDL 详解:让相邻 GPU kernel 首尾重叠——原理、写法、各框架实践与踩坑总结
面向刚入门的推理框架开发者,从"decode 阶段 kernel 之间的空档"讲起,说清 Programmatic Dependent Launch(PDL)的准确语义;在 B300 上把 PDL 的每个特性(放行位置、等待语义、链条、跨 stream 事件、CUDA Graph 的三种端口、资源限制)逐项实测,给出 CUDA C++、PyTorch、Triton、CuTe DSL 四套可运行的例子和数据;精读 CUDA 官方文档、CuTe DSL 教程和 CUTLASS 的官方写法,梳理二十多个推理框架和计算库的用法与默认值,并把各家踩过的坑整理成可以直接照做的规则和检查清单。
这篇文章写给做 LLM 推理框架和 GPU kernel 的开发者,尤其是第一次接触 PDL 的人。读完之后,你应该能回答五个问题:
- PDL 解决什么问题,大概能带来多少收益;
- “等待”和”放行”这两个调用到底保证了什么、没保证什么;
- 怎么给一个 kernel 正确地加上 PDL,怎么确认它真的生效了;
- 用 CUDA C++、PyTorch、Triton、CuTe DSL 分别怎么写,各有什么坑;
- 主流框架和计算库是怎么用的,踩过哪些坑。
资料来源与版本
| 来源 | 版本 |
|---|---|
| CUDA 官方文档 | CUDA 13.4 Programming Guide、PTX ISA 9.4 |
| CUTLASS | main,4.8.1(e13f5cd4,2026-10-28) |
| TensorRT-LLM | 73ee6b0b19(2026-08-31) |
| vLLM / SGLang / PyTorch | 8e92248f79 / 8bb776dc48 / 66bec7c1d3b(2026-08-30 ~ 31) |
| llama.cpp / TokenSpeed | 458681e1d / 1271aad8(2026-08-31) |
| FlashInfer | 0.6.18(pip 包),部分内容看 GitHub main |
| CCCL、XLA、DeepGEMM 等 | GitHub main,2026-10 ~ 11 |
| 实测软件环境 | NGC 容器 nvcr.io/nvidia/pytorch:26.10-py3:CUDA 13.4、PyTorch 2.15 预览版(2.15.0a0+875d815502)、Triton 3.8.0、CUTLASS DSL(nvidia-cutlass-dsl)4.8.0 |
实测的范围:
- 真机实测在一张 NVIDIA B300(Blackwell Ultra,计算能力 10.3)上完成,软件全部来自上面这个公开的 NGC 容器。第 4、5 节的数字都是我在这台机器上测的,核心代码都贴在文中,可以直接复现。
- 编译和老 GPU 上的行为在一张 RTX 3090 Ti(sm_86)上验证。
- 其他性能数字来自注明出处的 PR 或官方 blog,不是我测的。
- 我的数字来自很小的、刻意构造的 kernel,目的是把每个特性单独看清楚。真实模型的收益要以端到端测试为准。
0. 先给结论
如果只有五分钟,读这一节就够了。
- PDL 解决的是相邻两个短 kernel 之间的空档:GPU 侧的启动等待、前一个 kernel 的”尾巴”、后一个 kernel 的准备工作。它对 decode 和小 batch 有用,对 prefill 这种大 kernel 基本没用。
- 它需要三处配合:后一个 kernel 启动时加一个属性;后一个 kernel 里调用”等待”;前一个 kernel 里(可选)调用”放行”。
- “等待”等的是上一个 kernel 全部结束、结果写回显存,不是等它发出放行信号。B300 实测:前一个 kernel 一开始就放行、20 μs 后才写结果,后一个 kernel 在等待之后读,一次都没错;在等待之前读,100% 读到旧值。
- “放行”只决定后一个 kernel 什么时候能开始被调度,本身不保证任何数据可见。每个 block 里只要一个线程调用就算这个 block 放行了,但必须所有 block(包括还没被调度上 SM 的)都放行,后一个 kernel 才能启动。
- 等待之前只能做和上一个 kernel 输出无关的事。 在等待之前读了上一个 kernel 的输出,是各框架里最常见的 PDL bug。
- 用 PDL 启动的 kernel 必须调用等待,哪怕它不读上一个 kernel 的输出。否则在 A → B → C 里,C 可能在 A 还在运行时就启动;C 在自己的等待之前碰 A 的数据,就会读到旧值(B300 上 100% 复现,PyTorch #199166 就是这样出错的)。
- 编译器会移动代码。
__restrict__、__ldg、不带 memory clobber 的内联汇编、Triton 的软件流水,都可能让读和等待的先后顺序变得和源码不一样。要看反汇编确认。Triton 里把等待放在循环之前,不要放在循环里。 - 收益规律:每个 kernel 边界省下的大约是一段固定的时间。 B300 + CUDA Graph 实测,每个边界大约省 0.3 μs:1 μs 级的小 kernel 能快 20%~30%,100 μs 级的 kernel 不到 1%。公开数据里,decode 端到端通常快 1%~5%。
- 和 CUDA Graph 一起用效果最好。 不用 CUDA Graph 时,小 kernel 卡在 CPU 发射速度上,PDL 基本没收益。中间夹一个不带 PDL 的 kernel 或 memset,那一段的重叠就没了。
- 等待之前做的事不是越多越好。 B300 实测:GEMV 在等待之前把整层权重预取进 L2,小层快 31%,大层反而慢 16%~28%。预取要限量,放行时机也要实测。
- 跨 stream 的”programmatic 事件”和图里的”launch completion 端口”是同一套机制的扩展,但语义差别很大:有的对等待可见,有的不可见(第 4.6、4.7 节)。用之前一定要看清楚。
- 默认开,但要留关闭开关和规模门槛,并在 CI 里用”晚写入”的测试专门抓等待之前的读。
1. PDL 要解决什么问题
1.1 decode 阶段:很多很短的 kernel
decode 阶段每一步只给每个请求生成一个 token。batch 小的时候,每个 kernel 只跑几微秒到几十微秒。一个 decoder 层通常要依次跑十几个 kernel:RMSNorm、QKV 投影、RoPE、attention、输出投影、AllReduce、MoE 路由、专家 GEMM……几十层的模型,一步 decode 要跑几百上千个 kernel。
每两个相邻 kernel 之间,都有三种浪费:
- 启动空档。 同一个 stream 上,GPU 默认要等前一个 kernel 完全结束(所有 block 跑完、写入对后面可见),才开始启动下一个。这中间有一段固定开销。
- 前一个 kernel 的”尾巴”。 kernel 的 block 是一波一波分到 SM 上的。最后一波通常填不满所有 SM,剩下的 SM 只能空等。
- 后一个 kernel 的”开场”。 每个 kernel 开头都有一段和上一个 kernel 结果无关的准备工作:算索引、初始化 shared memory 和 barrier、预取 TMA 描述符、加载模型权重……这些本来可以提前做。
NVIDIA 在 Llama 4 Maverick 的 blog 里对前两点的描述是:”两个连续 kernel 之间有一些很小的空隙,GPU 在这里是空闲的”,以及”第一个 kernel 快结束时,可能只有部分 SM 还在跑剩下的 block,其余 SM 空着”。
对一个 3 μs 的 kernel,1 μs 的固定开销占了三分之一;对一个 300 μs 的 prefill GEMM,这点开销可以忽略。这就是为什么 PDL 主要是 decode 的优化。
1.2 一个类比:接力赛的交接区
把相邻两个 kernel 想成接力赛的两棒:
- 默认规则:下一棒必须等上一棒跑到终点、把棒交出去,才从起跑线开始热身、起跑。
- 用了 PDL:上一棒快到的时候(放行),下一棒可以先进交接区热身(准备工作);但必须等真正接到棒(等待返回),才能开始跑(读上一个 kernel 的结果)。
热身的时候不能碰接力棒——等待之前不能读上一个 kernel 的输出。这一条是整篇文章最重要的规则。
1.3 时间线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
time ─────────────────────────────────────────────────────────────►
Without PDL
A [##########################~~~~]
| A done, memory flushed
B ..[pppp][##################]
gap prologue main
With PDL
A [##########################~~~~]
| every block of A has triggered
B [pppp].......[##################]
prologue wait main
| wait returns: A done, memory flushed
#:kernel 的主体;~:尾巴(只有少数 SM 在干活);p:准备工作;..:空档或等待。- 用了 PDL 之后,B 的准备工作和 A 的尾巴重叠了,启动空档也藏进了 A 的运行时间里。
- B 的主体仍然在 A 完全结束之后才开始。PDL 不改变数据依赖,只让”不依赖数据的部分”提前。
CUTLASS 的 CuTe DSL 官方教程(programmatic_dependent_launch.py)用三段来画同一件事:P0 准备、P1 主体计算、P2 收尾。
1
2
3
4
5
6
7
8
9
10
11
12
13
# P0: Prologue, P1: Main compute, P2: Epilogue
P0 P1 P2
K1: |=====|+++++|-----|
<-----> K2 can start early
(K1's P2 overlaps with K2's P0)
P0 P1 P2
K2: |=====| |+++++|-----|
^
|
wait for K1 to complete
教程里还说了一句很关键的话:当准备和收尾受限于不同的资源(比如一个吃显存带宽、一个吃算力)时,重叠的效果最好。
1.4 和 CUDA Graph、kernel 融合是什么关系
| 手段 | 解决什么 | 和 PDL 的关系 |
|---|---|---|
| CUDA Graph | CPU 侧的发射开销:把几百个 kernel 打包成一次提交 | 互补。图里 kernel 之间仍然是”前一个结束、后一个才开始”,PDL 解决的是 GPU 侧这个等待。官方文档明确支持在图里用 PDL(见 2.7 节)。 |
| kernel 融合 | 直接去掉 kernel 边界 | 互补。能融合的先融合;融合不了的边界再用 PDL 软化。NVIDIA 的 Llama 4 blog 把融合和 PDL 列为两项独立优化。 |
| 多 stream 并行 | 两个没有依赖的 kernel 同时跑 | 不同问题。PDL 处理的是有依赖的相邻 kernel。 |
llama.cpp 引入 PDL 的 PR #22522 对 PDL 和 CUDA Graph 的关系总结得很直接:”两者的收益是叠加的(PDL + CG > CG > PDL)”。
1.5 能快多少:公开数据
| 来源 | 场景 | 结果 |
|---|---|---|
| 本文 B300 实测(第 4、5 节) | 各种小 kernel 串成的链,CUDA Graph 下 | 每个 kernel 边界省约 0.3 μs;1 μs 级 kernel 快约 27%;PyTorch Inductor 的 decode 小模块快 8%~11% |
| TRT-LLM tech blog 1 | DeepSeek-R1,8×B200,单并发 | 打开 PDL 这一步:168 → 173 tokens/s/user(+3.0%) |
| vLLM #64494 | Qwen3.8-27B-NVFP4,B300 | 单并发每 token 耗时 5.424 → 5.169 ms(−4.7%);并发 64 时在噪声范围内 |
| vLLM #59737 | MiniMax-M3 路由→门控两个 kernel,GB200 | 这一段 5.330 → 4.844 μs(−9.1%);端到端每 token 耗时只降 0.6%~1.2% |
| FlashInfer #8032 | mm_bf16,GB300 | 很小的 GEMM:1.70 → 1.19 μs;53 μs 的 GEMM:只快 0.9% |
| llama.cpp #22522 | RTX PRO 6000 | 生成阶段 1.03~1.22 倍;prefill 约 1.0 倍 |
| CCCL #3114 / #6639 | 2^16 个元素 | merge sort −16%(H200),scan −19.5%(B200);2^28 个元素时约为 0 |
| XLA #38544 | gemma3_1b | B200 1.33 倍,H100 1.08 倍;多数其他模型 1.00~1.01 倍 |
| LMDeploy #4861 | split-K paged attention,H200,CUDA Graph 下 | batch 1:−4.8%;batch 32:−0.4% |
CuTe DSL 教程 fp16_gemm_6.py | 反量化 → GEMM,--mnk 256,8192,128 | 注释:”最多可达 1.16 倍” |
几点说明:
- 规律很清楚:kernel 越短,收益越大。 FlashInfer 和 CCCL 的数据最能说明这一点:同一个优化,小问题快 15%~40%,大问题几乎没变化。
- 单个 kernel 的提升会被端到端稀释。 vLLM #59737 里一段 kernel 快了 9%,端到端只快了 1% 左右。
- NVIDIA 官方 blog 里没有 PDL 单独的数字。 Llama 4 blog 的”4 倍”、MoE blog 的”最高 2.8 倍”,都是 PDL 和其他优化一起得到的,不能算到 PDL 头上。
- 上表多数来自 PR 作者自己的测量,没有经过统一的复现。
2. PDL 的机制和准确语义
2.1 三个组成部分
| 角色 | 写在哪里 | CUDA C++ | PTX 指令 | sm_90 / sm_100 机器码 |
|---|---|---|---|---|
| 启动属性 | 主机代码,加在后一个 kernel 的启动上 | cudaLaunchKernelEx + cudaLaunchAttributeProgrammaticStreamSerialization(字段 programmaticStreamSerializationAllowed = 1) | — | — |
| 等待 | 后一个 kernel 里 | cudaGridDependencySynchronize() | griddepcontrol.wait | ACQBULK |
| 放行 | 前一个 kernel 里(可选) | cudaTriggerProgrammaticLaunchCompletion() | griddepcontrol.launch_dependents | PREEXIT |
最后一列是我在本地编译后用 cuobjdump -sass 看到的(见第 3 节)。
初学者最容易弄反的一点:启动属性加在后一个 kernel 上。它的意思是”允许我和同一个 stream 里排在我前面的那个 kernel 部分重叠”。
2.2 等待:等的是”上一个 kernel 全部结束”
CUDA Programming Guide(PDL 章节)示例代码里的注释:
Will block until all primary kernels the secondary kernel is dependent on have completed and flushed results to global memory
PTX ISA 的说法更严格:griddepcontrol.wait 会等到”所有前置 grid 都已完成,并且它们的所有内存操作都已执行完毕、对当前 grid 可见”。
翻成白话:等待返回时,上一个 kernel 已经彻底跑完,它写过的所有数据(包括放行之后才写的)你都能读到。
2.3 放行:只决定”后一个 kernel 什么时候能开始”
Programming Guide 的原话:
The CUDA driver can launch the secondary kernel when all primary thread blocks have launched and executed cudaTriggerProgrammaticLaunchCompletion. If the primary kernel doesn’t execute the trigger, it implicitly occurs after all thread blocks in the primary kernel exit.
也就是说:
- 前一个 kernel 的每一个 block 都执行了放行(或者已经退出),后一个 kernel 才可能开始启动。 只有一部分 block 放行是不够的。
- 不调用放行也完全正确,只是等于在每个 block 退出时才放行,能重叠的时间就少了。DeepGEMM 就是这样做的:只在 kernel 里等待,从不显式放行。
- 一个 block 里多次调用放行,和调用一次效果一样。PTX 的原话是:”同一个 CTA 里的线程重复执行这条指令,除了第一次之外没有额外效果”。
CUDA 头文件里对放行的说明是:”它本身不提供任何内存可见性保证”。放行不是”我的数据准备好了”,只是”你可以开始准备了”。
这几条我都在 B300 上逐条测过(4.2 节):每个 block 只让 0 号线程放行,效果和所有线程都放行一样;只要有一半 block 不放行,后一个 kernel 就要等这一半 block 退出才启动。
进阶补充:PTX ISA 9.4 新增了一条规则——在放行之前加一个 release fence,可以和后一个 grid 的开始建立同步关系。这是比较新的高级用法,主流框架基本没用。本文的规则一律按”等待之后才读”来写,这是最稳妥的。
2.4 没有隐式等待:链条问题
Programming Guide 写得很明确:后一个 kernel 的 block 可能在前一个 kernel 的数据可见之前就启动了,所以”必须始终使用 cudaGridDependencySynchronize 或其他方式”来保证数据可用。也就是说,用 PDL 启动的 kernel 如果自己不调用等待,就完全不会等。
这会带来一个很隐蔽的问题。看三个相邻的 kernel:
1
2
A(算激活值,提前放行) → B(用 PDL 启动,只往另一块 buffer 写零,不读 A,所以没写等待)
→ C(用 PDL 启动,读 A 的输出)
- B 不等待,所以 B 可以在 A 还没跑完时就跑完。B 一退出就等于放行,C 就可以启动了;
- 所以 C 可能在 A 还在计算的时候就开始执行。
我在 B300 上把这个场景完整测了一遍(4.4 节):
- C 启动的时间比 A 结束早了约 17 μs,确实是在 A 运行期间就开始了;
- C 如果在自己的等待之前读 A 的输出,100% 读到旧值;
- C 如果在等待之后才读,结果全部正确,而且等待是在 A 结束之后才返回的。中间连着三个都不等待的 kernel,结果也一样。
最后一条和 PTX 的描述一致:griddepcontrol.wait 等的是”所有仍在运行的前置 grid”(all prerequisite grids in flight)。所以更准确的说法是:断掉的不是 C 的等待,而是”C 一启动,A 就一定已经结束”这个假设。 只要 C 在等待之前做了任何依赖 A 的事,就会出错。
PyTorch Inductor 的 #199166 正是这样出的错。Inductor 为了多重叠一点,只在”读直接前一个 kernel 写过的 buffer”之前插入等待,读更早的 kernel 的输出时,就把读放在等待之前。它默认”前一个 kernel 已经等过它前面的 kernel”。中间那个只写零的 kernel 没有等待,这个默认就不成立了。
- 修复是 #199445 和 #199812,2026 年 10 月合入 PyTorch 主干。
- 我用 issue 里的复现脚本,在 B300 上跑了 NGC 26.10 容器里的 PyTorch。这个版本基于 2026-09-09 的上游代码,不含这两个修复,结果 20 次调用里有 18 次算错(5.2 节)。
- #201585(调研时仍未关闭)是同一个问题的变体:中间的 kernel 因为大小为 0 被跳过了。
CUTLASS 的 PDL 文档把这一点写成了它对外的承诺:”所有支持 PDL 的 CUTLASS kernel 都会等待前一个 kernel 把输出写回内存,并通知下一个 kernel 开始。”它同时提醒,和其他 PDL kernel 混用时,对方也要遵守同样的约定。
规则有两条:
- 只要一个 kernel 用 PDL 启动,它就必须调用等待,不读上一个 kernel 输出的 kernel 也要在退出前调用一次;
- 等待之前只能读整个推理过程中都不会变的数据,不能因为”前一个 kernel 没写这块 buffer”,就认为它已经准备好了。
2.5 一个常见误解
不少框架代码里的注释把等待理解成”等到上一个 kernel 发出放行信号就返回”。SGLang 的 gemm_ar.cuh 同一个文件里两处注释的说法甚至互相矛盾。另外,TRT-LLM #15729、FlashInfer #3835 这两个 PR 也用”过早放行导致等待提前返回”来解释自己遇到的问题。
这和官方文档、PTX 规范都对不上:等待永远等到上一个 kernel 完全结束。 过早放行影响的是性能(后一个 kernel 太早占用 SM 资源,挤占前一个 kernel),不会让等待提前返回。读别人的代码和 PR 时,遇到这种说法要留个心眼:现象可能是真的,但原因多半是”某处在等待之前读了数据”。
2.6 硬件与版本要求
| 项目 | 要求 |
|---|---|
| 真正的重叠执行 | 计算能力 9.0 及以上(Hopper、Blackwell)。官方原话:”这些 API 至少需要计算能力 9.0 才能提供重叠执行。” |
cudaLaunchKernelEx + PDL 启动属性 | CUDA 11.8 |
设备端 cudaGridDependencySynchronize() / cudaTriggerProgrammaticLaunchCompletion() | CUDA 12.0(11.8 只能用内联 PTX) |
| CUDA Graph 里的 PDL 依赖边 | CUDA 12.3 |
PTX griddepcontrol | PTX ISA 7.8,sm_90 及以上 |
跨 stream 的 programmatic 事件(cudaLaunchAttributeProgrammaticEvent) | 计算能力 9.0 及以上;事件必须用 cudaEventDisableTiming 创建 |
launch completion 事件(cudaLaunchAttributeLaunchCompletionEvent) | 任何计算能力都能用(它不属于”等待”能看到的那套依赖,见 2.8 节) |
版本信息是对比 NVIDIA 各版本运行时头文件得出的。
另外,PDL 的重叠是”机会性的”。官方原话:”重叠执行是机会性的,不保证发生……依赖这种并发执行是不安全的,可能导致死锁。” 所以绝不能写出”前一个 kernel 等后一个 kernel 做某件事”的逻辑,比如前一个 kernel 自旋等待后一个 kernel 写的标志位。
2.7 在 CUDA Graph 里
- 用 stream capture 抓图时,PDL 关系会自动变成图里的”programmatic 依赖边”。 官方文档给了对应关系。我在 RTX 3090 Ti 和 B300 上都验证过:抓出来的边类型是
cudaGraphDependencyTypeProgrammatic,出口端口是cudaGraphKernelNodePortProgrammatic。 - 手工建图时,用
cudaGraphEdgeData指定边的类型和端口。官方文档说,非默认的边数据目前唯一的用途就是 PDL。 - programmatic 边只能连在两个 kernel 节点之间。 前一个节点是 memset 或 memcpy 时,抓图得到的是普通边(本地测试结果)。
- 在 B300 上,同样的 PDL 关系放进 CUDA Graph 比直接在 stream 上跑还要快一点:后一个 kernel 的等待返回得更早(4.7 节)。
- kernel 节点有三种出口端口。跨 stream 的 programmatic 事件被抓进图里之后,也会变成 programmatic 边。这些细节见下一节。
2.8 PDL 的完整接口一览
很多文章只讲”一个启动属性 + 两个设备函数”。其实 CUDA 里和 PDL 相关的接口一共有这些,我把每一项都在 B300 上测过:
| 接口 | 写在哪 | 作用 | 后一个 kernel 的等待能看到吗 | B300 实测 |
|---|---|---|---|---|
cudaLaunchAttributeProgrammaticStreamSerialization | 后一个 kernel 的启动 | 允许和同一 stream 里的前一个 kernel 重叠 | 能 | 4.2 节 |
cudaGridDependencySynchronize() / griddepcontrol.wait | kernel 里 | 等待:前置 grid 全部结束、写入可见 | — | 4.3 节 |
cudaTriggerProgrammaticLaunchCompletion() / griddepcontrol.launch_dependents | kernel 里 | 放行:只影响后一个 kernel 什么时候能启动 | — | 4.2 节 |
cudaLaunchAttributeProgrammaticEvent(字段 triggerAtBlockStart 取 0 或 1) | 前一个 kernel 的启动;另一个 stream 用 cudaStreamWaitEvent 等这个事件 | 跨 stream 的 PDL。取 0 时,所有 block 放行(或退出)后触发;取 1 时,每个 block 一开始执行就自动放行 | 能 | 直接在 stream 上用:没有重叠;抓进 CUDA Graph 后:有重叠(4.6 节) |
cudaLaunchAttributeLaunchCompletionEvent | 前一个 kernel 的启动 | 所有 block 都开始执行之后触发事件,老 GPU 也能用 | 不能 | 后一个 kernel 的等待直接返回,100% 读到旧值(4.6 节) |
图边:Programmatic 端口 + Programmatic 类型 | 手工建图 | 等价于 stream 上的 PDL | 能 | 4.7 节 |
图边:LaunchCompletion 端口 + Programmatic 类型 | 手工建图 | 前一个 kernel 的所有 block 一开始执行就放行,前一个 kernel 不需要调用放行 | 能 | 数据正确,重叠最多(4.7 节) |
图边:LaunchCompletion 端口 + Default 类型 | 手工建图 | 同上,但只管启动顺序 | 不能 | 100% 读到旧值(4.7 节) |
记住一个判断方法:带”programmatic”字样的依赖,后一个 kernel 的等待都能看到;只有”launch completion”本身(事件或普通类型的边)看不到。 CUDA 头文件对 launch completion 事件的说明是:它”名义上和 triggerAtBlockStart 为 1 的 programmatic 事件差不多,只是对 cudaGridDependencySynchronize() 不可见,而且可以在计算能力低于 9.0 的 GPU 上用”。CuTe DSL 的官方教程 launch_completion_and_programmatic_events.py 也是这么写的。
3. 最小可运行示例
3.1 代码
两个 kernel:前一个算 y = x * 2,后一个算 z = y + w。其中 w 是常量,和前一个 kernel 无关,可以在等待之前读。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <cstdio>
#include <cuda_runtime.h>
// 前一个 kernel(primary):y = x * 2
__global__ void producer(const float* x, float* y, int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n) y[i] = x[i] * 2.0f;
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 900
// 放行:后一个 kernel 可以开始启动了。
// 注意:这不代表上面写的 y 已经对后一个 kernel 可见。
cudaTriggerProgrammaticLaunchCompletion();
#endif
}
// 后一个 kernel(secondary):z = y + w
__global__ void consumer(const float* y, const float* w, float* z, int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
// 准备工作:只读和 producer 无关的数据。
float wi = (i < n) ? w[i] : 0.0f;
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 900
// 等待:producer 全部结束、写回显存之后才返回。
cudaGridDependencySynchronize();
#endif
// 读 producer 的输出必须放在等待之后。
if (i < n) z[i] = y[i] + wi;
}
int main() {
const int n = 1 << 20;
float *x, *y, *w, *z;
cudaMalloc(&x, n * sizeof(float)); cudaMalloc(&y, n * sizeof(float));
cudaMalloc(&w, n * sizeof(float)); cudaMalloc(&z, n * sizeof(float));
cudaStream_t s; cudaStreamCreate(&s);
dim3 block(256), grid((n + 255) / 256);
// 前一个 kernel 正常启动
producer<<<grid, block, 0, s>>>(x, y, n);
// 后一个 kernel 带 PDL 属性启动
cudaLaunchConfig_t cfg = {};
cfg.gridDim = grid; cfg.blockDim = block; cfg.dynamicSmemBytes = 0; cfg.stream = s;
cudaLaunchAttribute attr[1];
attr[0].id = cudaLaunchAttributeProgrammaticStreamSerialization;
attr[0].val.programmaticStreamSerializationAllowed = 1;
cfg.attrs = attr; cfg.numAttrs = 1;
cudaLaunchKernelEx(&cfg, consumer, (const float*)y, (const float*)w, z, n);
cudaStreamSynchronize(s);
return 0;
}
真实框架会把启动部分包成一个辅助函数。TensorRT-LLM 的是 launchWithPdlWhenEnabled(cpp/tensorrt_llm/common/envUtils.h),根据环境变量决定属性设成 0 还是 1。
3.2 编译:老架构要加保护
如果把 #if __CUDA_ARCH__ >= 900 去掉,同时为 sm_86 和 sm_90 编译,ptxas 会直接报错:
1
error : Instruction 'griddepcontrol' requires .target sm_90 or higher
设备端的等待和放行函数本身不做架构判断,多架构编译时必须自己加保护。 TRT-LLM 就因为 PDL 默认打开后在 SM89 上编译失败,专门提了修复(#16332)。
3.3 怎么确认 kernel 里真的有 PDL:看机器码
1
cuobjdump -sass -arch sm_90 pdl_demo | grep -E "Function|LDG|ACQBULK|PREEXIT|STG"
本地编译后 consumer 的结果:
1
2
3
LDG.E R0, desc[UR4][R2.64] // 读 w:在等待之前,和 producer 重叠
ACQBULK // griddepcontrol.wait
... // 读 y、写 z:在等待之后
producer 里能看到 PREEXIT(放行)。sm_100 和 sm_103(B300)的机器码里也是这两条指令;这段程序在 B300 上运行通过。
这个检查方法很实用:很多”开了 PDL 却没效果”的问题,是因为 kernel 里根本没编译进等待和放行(比如 CUTLASS 没开编译宏,见 7.4 节)。可以把”关键 kernel 的机器码里必须有 ACQBULK“写进 CI。
3.4 在老 GPU 上运行会怎样
在 RTX 3090 Ti(sm_86)上运行上面的程序:cudaLaunchKernelEx 返回成功,结果正确,两个 kernel 按普通顺序执行。属性被静默忽略了。
功能上没问题,但有一个性能上的坑:用 CUDA Graph 抓图时,这条 PDL 关系仍然会被记录成一条 programmatic 依赖边(本地测试抓到的边类型确实是 programmatic)。vLLM 的 #65059 测到,在 A100 上这条多余的边每次回放要多花 0.6~1.1 μs;只在 SM90 及以上才加 PDL 属性之后,A100 的 decode 快了 6.5%~13.6%。所以启动端最好自己判断架构,不要把属性无条件地加上去。
4. 在 B300 上逐项实测
前面讲的都是”文档怎么说”。这一节把 PDL 的每个特性放到一张 B300 上,一项一项测出来。所有程序都用 nvcc -O3 -arch=sm_103 编译。
4.1 实验方法:给每个 block 打时间戳
做法很简单:两个 kernel,每个 block 开始和结束时都读一次 GPU 的全局时钟 %globaltimer(单位是纳秒,所有 SM 共用一个时钟),记到显存里。
- 前一个 kernel(下文简称 P):每个 SM 放一个 block,正好一波。每个 block 先(按需)放行,再忙等 20 μs,最后才写结果。这就是 FlashInfer 测试里用的”晚写入”思路:如果后一个 kernel 读早了,一定读到旧值。
- 后一个 kernel(下文简称 S):记下开始时间,调用等待,记下等待返回的时间,再读 P 的结果,和正确值比较,统计”错读”。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
__device__ __forceinline__ uint64_t now() {
uint64_t t; asm volatile("mov.u64 %0, %%globaltimer;" : "=l"(t)); return t;
}
__global__ void primary(int trigger_early, uint64_t spin_ns, int val, int* data, uint64_t* t_end) {
if (trigger_early) cudaTriggerProgrammaticLaunchCompletion(); // 一开始就放行
uint64_t t0 = now(); while (now() - t0 < spin_ns) {} // 再忙 20 μs
data[blockIdx.x * blockDim.x + threadIdx.x] = val; // 最后才写结果
__syncthreads();
if (threadIdx.x == 0) t_end[blockIdx.x] = now();
}
__global__ void secondary(int read_before_wait, int val, const int* data, int* bad,
uint64_t* t_start, uint64_t* t_wait) {
if (threadIdx.x == 0) t_start[blockIdx.x] = now();
int i = blockIdx.x * blockDim.x + threadIdx.x;
int early = read_before_wait ? data[i] : 0; // 错误示范:等待之前读
cudaGridDependencySynchronize();
if (threadIdx.x == 0) t_wait[blockIdx.x] = now();
int v = read_before_wait ? early : data[i];
if (v != val) atomicAdd(bad, 1);
}
(只为 sm_103 编译,所以这里省掉了 __CUDA_ARCH__ 保护;多架构编译时要加上,见 3.2 节。)
下面的表格里有两个时间:
- S 启动 − P 结束:S 最早的 block 开始的时间,减去 P 最后一个 block 结束的时间。负数表示两个 kernel 重叠了,数字越负,重叠越多。
- S 等待返回 − P 结束:S 的等待最早在什么时候返回。这个数应该永远是正的,越小越好。
每种情况跑 15 次取中位数。不同次之间的波动在 0.1~0.3 μs。
测之前一定要先预热。 CUDA 默认按需加载 kernel(lazy loading)。第一次启动时,后一个 kernel 还没加载,根本看不到重叠:我有一次忘了预热,后一个 kernel 在前一个结束 6.6 μs 之后才启动。所以无论是这种微基准,还是框架里的性能对比,都要先跑几遍再计时。
4.2 放行放在哪,后一个 kernel 什么时候启动
| 情况 | S 启动 − P 结束 | S 等待返回 − P 结束 |
|---|---|---|
| 不加 PDL 属性(对照组) | +0.99 μs | +1.15 μs |
| 加 PDL 属性,P 从不放行(退出时隐式放行) | +0.48 μs | +0.74 μs |
| 加 PDL 属性,P 在最后放行 | +0.38 μs | +0.67 μs |
| 加 PDL 属性,P 一开始就放行(所有线程都调用) | −18.8 μs | +0.67 μs |
| 加 PDL 属性,P 一开始就放行(每个 block 只有 0 号线程调用) | −19.1 μs | +0.74 μs |
| 加 PDL 属性,P 只有一半 block 放行(另一半多跑两倍时间) | +0.48 μs | +0.74 μs |
| PDL 属性的值设为 0,P 一开始就放行 | +0.93 μs | +1.12 μs |
从这张表能读出五件事:
- 不放行也有收益。 等待返回的时间从 1.15 μs 降到 0.74 μs,省下的大约 0.4 μs 就是”启动空档”被藏起来的部分。所以 DeepGEMM 那种”只等待、不放行”的写法也是有意义的。
- 放行再早,等待也不会提前返回。 P 一开始就放行,S 在 P 开始后不到 2 μs 就启动了,比 P 结束早了约 19 μs。但 S 的等待照样在 P 结束后 0.67 μs 才返回。这直接证明了 2.5 节说的那个误解是错的。
- 一个 block 里有一个线程放行就够了。 只让 0 号线程调用,效果和所有线程都调用一样。
- 少一个 block 放行都不行。 只有一半 block 放行时,S 要等另一半 block 退出才能启动,和完全不放行没有区别。
- 属性值为 0 就等于没开。 这正是框架用来做全局开关的方式(比如 TRT-LLM 的
launchWithPdlWhenEnabled)。
还有一个多波的情况值得单独说。把 P 改成 4 波:每个 block 用 150 KB shared memory,一个 SM 只能放一个,block 数是 SM 数的 4 倍。P 一开始就放行,S 也要等到约 62 μs,也就是第 4 波开始的时候才启动。总时长约 81.6 μs,每波约 20 μs。
“所有 block 都放行”包括还没被调度上 SM 的 block。 所以对于一个多波的大 kernel,”一开始就放行”实际上只在最后一波起作用。
4.3 等待到底保证了什么
P 都是一开始就放行、最后才写结果:
| S 的写法 | 错读比例 |
|---|---|
| 等待之后才读 | 0 |
| 等待之前读 | 100%(全部读到旧值) |
| 根本不调用等待 | 100% |
| (对照)P 不放行,S 也不调用等待 | 0,碰巧正确,不能依赖 |
前三行就是第 0 节第 3、5 条的直接证据。
最后一行要特别说明:P 不放行时,等于每个 block 在退出时放行,此时它的写入已经发出,S 在 P 结束后约 0.45 μs 才启动,所以这次碰巧全读对了。但 PTX 规范写得很清楚,只有等待才保证”前置 grid 的所有内存操作都已完成并对当前 grid 可见”。没有等待时读对了,只是运气。
4.4 链条:A → B → C 到底会不会断
A 一开始就放行、最后才写结果;B 是一个只写别的 buffer 的小 kernel;C 读 A 的结果。B、C 都用 PDL 启动。
| 情况 | C 启动 − A 结束 | C 等待返回 − A 结束 | C 读 A 的结果:错读 |
|---|---|---|---|
| B 不等待;C 在等待之后读 | −17.1 μs | +0.74 μs | 0 |
| B 不等待;C 在等待之前读 | −17.2 μs | +0.74 μs | 100% |
| B 等待;C 在等待之前读 | +1.3 μs | +1.5 μs | 0 |
| B 用普通方式启动(不带 PDL) | +1.6 μs | +1.8 μs | 0 |
| A → B1 → B2 → B3(都不等待)→ C,C 在等待之后读 | −13.7 μs | +0.77 μs | 0 |
A 和 C 之间夹一个 4 字节的 cudaMemsetAsync | +4.5 μs | +4.7 μs | 0 |
- B 不等待时,C 会在 A 运行期间启动(第 1、2 行,C 比 A 结束早了 17 μs)。C 在等待之前碰 A 的数据,就全错。这就是 PyTorch #199166 的情况。
- C 的等待本身没有断。 等待之后读,结果全对,中间隔三个不等待的 kernel 也一样。这和 PTX 说的”等待所有仍在运行的前置 grid”一致。
- B 等待之后,C 就不可能在 A 结束前启动(第 3 行)。所以 B 的等待保护的是”下游 kernel 在等待之前做的事”。这也是为什么规则要求每个 PDL kernel 都等待:它让”我启动时,再往前的 kernel 都已经结束”这个假设成立。
- 在 stream 上夹一个 memset 很贵。 一个 4 字节的
cudaMemsetAsync让间隔变成 4.5 μs,比一个普通 kernel 边界(约 1 μs)还长得多。热路径上需要清零的话,用一个小 kernel 并让它参与 PDL,通常更划算。不过这个结论是在 stream 上测的,CUDA Graph 里要另外实测。
4.5 资源:后一个 kernel 挤不进来会怎样
PDL 的重叠有一个物理前提:S 的 block 要能和 P 的 block 同时待在一个 SM 上。
| 情况(P 一开始就放行) | S 启动 − P 结束 | S 等待返回 − P 结束 |
|---|---|---|
| P、S 都不用 shared memory | −18.9 μs | +0.67 μs |
| P、S 各用 150 KB shared memory(一个 SM 放不下两个) | +0.03 μs | +0.67 μs |
| 同上,不开 PDL | +0.99 μs | +1.12 μs |
- S 挤不进来时,”提前启动、提前做准备”就没有了:S 只能在 P 的 block 退出、腾出位置的那一刻才启动。
- 但 PDL 仍然有用:S 的等待返回从 1.12 μs 提前到 0.67 μs。启动已经提前排好了,P 一退出 S 就能马上补上。
这也解释了 CUTLASS 维护者在 #2778 里说的现象:”两个 GEMM 前后相连时,通常因为 shared memory 不够,根本重叠不起来。”
4.6 跨 stream:programmatic 事件和 launch completion 事件
用法如下(以 programmatic 事件为例):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
cudaEvent_t ev;
cudaEventCreateWithFlags(&ev, cudaEventDisableTiming); // 必须关掉计时,否则启动报错
cudaLaunchAttribute a;
a.id = cudaLaunchAttributeProgrammaticEvent;
a.val.programmaticEvent.event = ev;
a.val.programmaticEvent.flags = 0;
a.val.programmaticEvent.triggerAtBlockStart = 0; // 0:等所有 block 放行;1:每个 block 一开始执行就算放行
cfg.stream = s1; cfg.attrs = &a; cfg.numAttrs = 1;
cudaLaunchKernelEx(&cfg, primary, /* 参数 */);
cudaStreamWaitEvent(s2, ev, 0);
secondary<<<grid, block, 0, s2>>>(/* 参数 */); // 里面照样要先等待再读
// launch completion 事件:把 id 换成 cudaLaunchAttributeLaunchCompletionEvent,
// 字段换成 a.val.launchCompletionEvent.event / .flags
实测结果:
| 情况 | S 启动 − P 结束 | S 等待返回 − P 结束 | 错读 |
|---|---|---|---|
普通事件(cudaEventRecord + cudaStreamWaitEvent,对照组) | +3.1 μs | +3.2 μs | 0 |
programmatic 事件,直接在 stream 上用(四种组合:triggerAtBlockStart 取 0 或 1,S 带或不带 PDL 属性) | +3.0 ~ +3.2 μs | +3.1 ~ +3.3 μs | 0 |
| launch completion 事件,S 调用等待 | −18.7 μs | −18.6 μs | 100% |
| 把 programmatic 事件抓进 CUDA Graph | −19.6 μs | +0.54 μs | 0 |
| 把 launch completion 事件抓进 CUDA Graph | −19.9 μs | −19.7 μs | 100% |
这一组结果有点出乎意料,值得仔细看:
- 直接在 stream 上用 programmatic 事件,我没有测到任何重叠。 它的表现和普通事件一样,S 要等 P 完全结束约 3 μs 后才启动。CUDA 头文件对它的描述本来就是”允许、但不保证并发执行”。所以不能指望它在 eager 模式下带来收益。
- 抓进 CUDA Graph 以后,programmatic 事件就有用了。 抓出来的是一条 programmatic 类型、出口端口为
Programmatic的边,和同一 stream 上的 PDL 完全一样,重叠和正确性也一样。CuTe DSL 的官方教程演示 programmatic 事件时,也是放在torch.cuda.graph里做的。 - launch completion 事件只管”启动顺序”,不管数据。 它在 P 的所有 block 都开始执行时触发,S 马上启动,但 S 的等待根本不等 P,于是全部读到旧值。抓进图里以后是一条普通类型、出口端口为
LaunchCompletion的边,语义不变。它适合的场景是”确保 A 的所有 block 都已经在 SM 上了,再启动 B”,比如两个需要同时驻留、互相通信的 kernel。绝不能拿它来传数据。
4.7 CUDA Graph 里的三种出口端口
手工建图时,可以给边指定出口端口和类型:
1
2
3
4
5
cudaGraphEdgeData e = {};
e.from_port = cudaGraphKernelNodePortProgrammatic; // 或 cudaGraphKernelNodePortLaunchCompletion / Default
e.to_port = 0;
e.type = cudaGraphDependencyTypeProgrammatic; // 或 cudaGraphDependencyTypeDefault
cudaGraphAddDependencies(graph, &node_p, &node_s, &e, 1);
(CUDA 12.3 ~ 12.x 里带 edgeData 参数的版本叫 cudaGraphAddDependencies_v2;本文用的 CUDA 13.4 头文件里,cudaGraphAddDependencies 本身就带这个参数。)
| 边 | P 是否调用放行 | S 启动 − P 结束 | S 等待返回 − P 结束 | 错读 |
|---|---|---|---|---|
| stream 上的 PDL 抓图得到的边 | 一开始放行 | −19.6 μs | +0.54 μs | 0 |
手工:Programmatic 端口 + Programmatic 类型 | 一开始放行 | −19.6 μs | +0.54 μs | 0 |
手工:LaunchCompletion 端口 + Programmatic 类型 | 不放行 | −19.9 μs | +0.58 μs | 0 |
| 手工:默认端口 + 默认类型(对照组) | 一开始放行 | +0.74 μs | +0.86 μs | 0 |
手工:LaunchCompletion 端口 + Default 类型 | 不放行 | −19.7 μs | −19.6 μs | 100% |
- CUDA Graph 里的 PDL 比 stream 上更快一点。 等待返回从 0.67 μs 降到 0.54 μs;连对照组的普通边界也从 0.99 μs 降到 0.74 μs。
LaunchCompletion端口 +Programmatic类型很有意思:前一个 kernel 不需要写任何放行代码,后一个 kernel 也能最早启动,而且数据正确。 它适合”前一个 kernel 来自闭源库、改不了代码”的情况。代价和”一开始就放行”一样:后一个 kernel 的 block 会很早占住 SM 资源,可能拖慢前一个 kernel,要实测。LaunchCompletion端口 +Default类型,API 不会报错,但没有任何数据保证。 这是最危险的组合,代码评审时要特别留意。
4.8 能省多少:一串 kernel 的端到端测试
前面几节用的是刻意放慢的 kernel。这一节换成真实一点的场景:把 200 个相互依赖的 kernel 串起来,测平均每个 kernel 的时间。
测试 1:逐元素 kernel 链。 每个 kernel 计算 y = x * w + 0.001,x 是上一个 kernel 的输出,w 是常量(相当于权重,在等待之前读):
1
2
3
4
5
6
7
8
9
10
11
12
__global__ void ew_k(const float4* x, const float4* w, float4* y, int n4, int trig) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
bool ok = i < n4;
float4 wv = ok ? w[i] : make_float4(0.f, 0.f, 0.f, 0.f); // 权重:等待之前读
if (trig == 1) cudaTriggerProgrammaticLaunchCompletion(); // 方案 1:一开始放行
cudaGridDependencySynchronize();
float4 xv = ok ? x[i] : make_float4(0.f, 0.f, 0.f, 0.f); // 上一个 kernel 的输出
float4 r = make_float4(xv.x * wv.x + 1e-3f, xv.y * wv.y + 1e-3f,
xv.z * wv.z + 1e-3f, xv.w * wv.w + 1e-3f);
if (trig == 2) cudaTriggerProgrammaticLaunchCompletion(); // 方案 2:写回之前放行
if (ok) y[i] = r;
}
单位:μs / kernel,取 20 次的中位数。
| 元素个数 | 每个 kernel 读写量 | stream | stream + PDL | CUDA Graph | Graph + PDL(不放行) | Graph + PDL(一开始放行) | Graph + PDL(写回前放行) | 最多省 |
|---|---|---|---|---|---|---|---|---|
| 4K | 0.05 MB | 2.07 | 1.97 | 1.12 | 0.82 | 0.90 | 0.82 | 0.31 μs(27%) |
| 64K | 0.8 MB | 1.97 | 1.96 | 1.15 | 0.84 | 1.10 | 0.84 | 0.32 μs(27%) |
| 1M | 12.6 MB | 2.32 | 1.97 | 1.85 | 1.50 | 1.65 | 1.70 | 0.35 μs(19%) |
| 4M | 50 MB | 4.87 | 4.87 | 4.35 | 4.01 | 4.61 | 4.86 | 0.34 μs(8%) |
| 16M | 201 MB | 30.22 | 28.95 | 29.58 | 29.38 | 28.61 | 28.72 | 0.96 μs(3%) |
| 64M | 805 MB | 115.08 | 114.03 | 114.44 | 114.22 | 113.80 | 113.66 | 0.78 μs(0.7%) |
- CUDA Graph 下,每个 kernel 边界大约省 0.3 μs。 1 μs 级的 kernel 能快 27%,100 μs 级的只快 0.7%。这就是”PDL 省的是固定时间”。
- 不用 CUDA Graph 时,小 kernel 基本没收益。 4K 和 64K 两行,stream 上开不开 PDL 都是约 2 μs 一个 kernel:瓶颈是 CPU 发射 kernel 的速度,GPU 一直在等 CPU,没有空档可以藏。这和 LMDeploy #4861 的观察一致。
- 放行位置没有通用答案。 4M 这一行,”一开始放行”(4.61)比不开 PDL(4.35)还慢,”不放行”反而最快。这时 kernel 有好几波,后一个 kernel 在等待之前读
w,会和前一个 kernel 的最后一波抢显存带宽。到了 16M,”一开始放行”又成了最快的。这和 vLLM #64494”按问题大小决定放行时机”的结论一致。
测试 2:decode 风格的 GEMV 链,以及”等待之前预取权重”。 每层计算 y = W_l · x(fp32,W 是 D×D),一个 warp 算一行。可选地在等待之前,用一条 cp.async.bulk.prefetch.L2 指令把本 warp 要用的那一行权重预取进 L2(CUTLASS example 63 的思路,见 6.4 节):
1
2
3
4
5
6
7
const float* wr = W + (size_t)row * K;
if (prefetch_bytes > 0 && row < M && lane == 0) // 权重不变,可以在等待之前预取
asm volatile("cp.async.bulk.prefetch.L2.global [%0], %1;"
:: "l"(wr), "r"(prefetch_bytes) : "memory");
if (trig) cudaTriggerProgrammaticLaunchCompletion();
cudaGridDependencySynchronize();
// ……之后照常读 x 和 W,做点积
每一层的权重各不相同,32 层(D ≤ 2048)或 8 层(D ≥ 4096)为一组,在 CUDA Graph 里重复 4 遍。单位:μs / 层。
| D | 每层权重 | 不开 PDL | PDL 不放行 | PDL 一开始放行 | + 预取 1/8 行 | + 预取 1/2 行 | + 预取整行 | + 预取整行,不放行 |
|---|---|---|---|---|---|---|---|---|
| 1024 | 4.2 MB | 5.31 | 5.14 | 4.98 | 4.95 | 4.60 | 3.64 | 4.20 |
| 2048 | 16.8 MB | 8.45 | 8.32 | 8.16 | 8.10 | 8.16 | 8.54 | 8.14 |
| 4096 | 67 MB | 17.01 | 16.67 | 16.92 | 17.62 | 19.33 | 20.69 | 19.75 |
| 8192 | 268 MB | 61.67 | 61.30 | 61.37 | 62.22 | 64.86 | 79.16 | 73.22 |
这张表是整个实验里最有教育意义的一张:
- 小层(4 MB):预取整行权重让每层快了 31%(5.31 → 3.64 μs),远超单纯的 PDL(6%)。这时前一层的 GEMV 很短,显存带宽有富余,下一层的权重正好可以趁这个时间搬进 L2。
- 大层(67 MB、268 MB):预取整行反而让每层慢了 16%~28%。 我没有用 Nsight Compute 逐项拆分,比较合理的解释是两点:
- 前一层 GEMV 本身就在用满显存带宽读自己的权重,提前预取下一层,只是在抢同一份带宽;
- 一次预取几十上百 MB,远超 L2 的容量,预取进来的数据还没用到就被挤掉,等于白读一遍。
- 预取量和放行时机都要调。 这正是 CUTLASS example 63 提供
prefetch_ratio和overlap_ratio两个参数、并建议”按端到端时间调优”的原因。
4.9 实测小结
- 放行再早,等待也会等前一个 kernel 完全结束;放行只影响后一个 kernel 什么时候能启动。
- 每个 block 有一个线程放行就够;但所有 block(包括还没上 SM 的)都要放行。
- 不放行也能省下约 0.4 μs 的启动空档;CUDA Graph 里每个边界大约省 0.3 μs。
- 链条会断的是”启动时间”的假设,不是等待本身。等待之前只能碰不变的数据。
- 后一个 kernel 挤不进 SM 时,只剩”藏起启动空档”这一部分收益。
- 跨 stream 的 programmatic 事件要放进 CUDA Graph 才有重叠;launch completion 事件和端口在默认类型下不保证数据。
- “等待之前做准备”不是越多越好:预取太多会和前一个 kernel 抢带宽、抢 L2,反而变慢。
5. PyTorch、Triton、CuTe DSL 实战
这一节给出三套工具各自的写法、正确性测试和性能数据,环境同上(B300,NGC PyTorch 26.10 容器)。
5.1 Triton
写法。 kernel 里用 tl.extra.cuda.gdc_wait() 和 tl.extra.cuda.gdc_launch_dependents();启动时传 launch_pdl=True。launch_pdl 是一个编译选项:同一个 kernel 开和不开会编译成两份。编译结果的 kernel.metadata.launch_pdl 能看到它是否生效。
正确性测试(晚写入)。 前一个 kernel 一开始就放行,用 %globaltimer 忙等 20 μs 再写结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import triton
import triton.language as tl
@triton.jit
def _now():
return tl.inline_asm_elementwise("mov.u64 $0, %globaltimer;", "=l", [],
dtype=tl.int64, is_pure=False, pack=1)
@triton.jit
def producer_late(out_ptr, val, spin_ns, N, BLOCK: tl.constexpr):
tl.extra.cuda.gdc_launch_dependents() # 故意一开始就放行
t0 = _now()
t = t0
while t - t0 < spin_ns: # 再忙一段时间
t = _now()
offs = tl.program_id(0) * BLOCK + tl.arange(0, BLOCK)
tl.store(out_ptr + offs, tl.full([BLOCK], 0, tl.int32) + val, mask=offs < N) # 最后才写
@triton.jit
def consumer(in_ptr, out_ptr, N, READ_BEFORE_WAIT: tl.constexpr, BLOCK: tl.constexpr):
offs = tl.program_id(0) * BLOCK + tl.arange(0, BLOCK)
mask = offs < N
if READ_BEFORE_WAIT:
x = tl.load(in_ptr + offs, mask=mask) # 错误示范
tl.extra.cuda.gdc_wait()
else:
tl.extra.cuda.gdc_wait()
x = tl.load(in_ptr + offs, mask=mask)
tl.store(out_ptr + offs, x, mask=mask)
producer_late[grid](buf, it, 20000, N, BLOCK=1024)
consumer[grid](buf, out, N, READ_BEFORE_WAIT=False, BLOCK=1024, launch_pdl=True)
跑 50 轮:等待之后读,0 个元素读错;等待之前读,96% 的元素读到旧值。剩下 4% 碰巧读对,可能是因为那几个 block 启动得晚,读的时候前一个 kernel 已经写完了。
看机器码。 对一个”读 w → 等待 → 读 x → 放行 → 写回”的 Triton kernel,用 cuobjdump -sass 查看 kernel.asm["cubin"],sm_103 上的顺序和源码一致:
1
2
3
4
5
LDG.E.128 ... // 读 w(等待之前)
ACQBULK // gdc_wait
LDG.E.128 ... // 读 x(等待之后)
PREEXIT // gdc_launch_dependents
STG.E.128 ... // 写回
软件流水:等待放在循环外。 我用 Triton #11905 里的写法(K 循环里先读权重、再 gdc_wait()、再读激活,然后做 tl.dot)在 B300 上测了 Triton 3.8.0:
| 写法 | 结果 |
|---|---|
等待在循环里,num_stages=2 或 3 | 编译失败:pipeliner doesn't know how to predicate this op |
等待在循环里,num_stages=1(不做流水) | 编译通过,20 次全对 |
等待只放在循环之前,num_stages=2 或 3 | 编译通过,循环正常流水(TTGIR 里有 6~8 个异步拷贝,都在等待之后),20 次全对 |
在 SM90 + Triton 3.7.1 上,同样的写法会悄悄算错(#11905)。修复 #11906 的做法是:含等待的循环不做流水。在 B300 + Triton 3.8.0 上,它直接编译报错。不同的硬件和版本表现不一样,但结论一样:在 Triton 里,把 gdc_wait() 放在循环之前。 循环里每次读的都是上一个 kernel 的输出,等一次就够了。
性能。 100 个 RMSNorm kernel(bf16,H = 4096)串成一条链:权重 g 在等待之前读,读完 x 就放行。CUDA Graph 下,单位是 μs / kernel:
| 行数 | 不加 GDC | 加 GDC,不开 PDL | 加 GDC,开 PDL | 节省 |
|---|---|---|---|---|
| 1 | 1.41 | 1.46 | 1.18 | 0.23 μs(16%) |
| 16 | 1.45 | 1.49 | 1.37 | 0.08 μs(6%) |
| 128 | 1.53 | 1.58 | 1.43 | 0.10 μs(7%) |
| 1024 | 3.36 | 3.20 | 2.99 | 0.37 μs(11%) |
| 8192 | 22.02 | 21.92 | 21.70 | 0.32 μs(1.5%) |
“加 GDC、不开 PDL”这一列说明:kernel 里有等待和放行指令、但启动时没加属性,开销在 0.05 μs 以内,可以放心地让同一份 kernel 同时支持开和关。
5.2 PyTorch
自定义 CUDA 算子:用 load_inline 接入 PDL
PyTorch 自己的逐元素算子不用 PDL 启动(下面的检查确认了这一点),但你写的 CUDA 扩展可以用。要点只有一个:一定要在 PyTorch 的当前 stream 上启动,否则 CUDA Graph 抓不到,和前后的 PyTorch 算子之间也没有顺序保证。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from torch.utils.cpp_extension import load_inline
cuda_src = r"""
#include <torch/extension.h>
#include <ATen/cuda/CUDAContext.h>
__global__ void scale_k(const float* x, const float* w, float* y, int n, int trig) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
float wi = i < n ? w[i] : 0.f; // 权重:等待之前读
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 900
cudaGridDependencySynchronize();
#endif
float xi = i < n ? x[i] : 0.f;
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 900
if (trig) cudaTriggerProgrammaticLaunchCompletion(); // 输入读完就放行
#endif
if (i < n) y[i] = xi * wi + 1e-3f;
}
void scale(torch::Tensor x, torch::Tensor w, torch::Tensor y, bool pdl, bool trig) {
int n = x.numel();
cudaLaunchConfig_t cfg = {};
cfg.gridDim = dim3((n + 255) / 256); cfg.blockDim = dim3(256);
cfg.stream = at::cuda::getCurrentCUDAStream(); // 关键:PyTorch 的当前 stream
cudaLaunchAttribute a[1];
a[0].id = cudaLaunchAttributeProgrammaticStreamSerialization;
a[0].val.programmaticStreamSerializationAllowed = pdl ? 1 : 0;
cfg.attrs = a; cfg.numAttrs = 1;
C10_CUDA_CHECK(cudaLaunchKernelEx(&cfg, scale_k, (const float*)x.data_ptr<float>(),
(const float*)w.data_ptr<float>(), y.data_ptr<float>(), n, (int)trig));
}
"""
ext = load_inline(name="pdl_scale_ext", functions=["scale"], cuda_sources=cuda_src,
cpp_sources="void scale(torch::Tensor x, torch::Tensor w, torch::Tensor y, bool pdl, bool trig);")
100 个这样的算子串成链(每个 4096 个 float),用 torch.cuda.graph 抓图后回放,单位是 μs / 次:
| 情况 | 时间 |
|---|---|
| 不开 PDL | 1.10 |
| 开 PDL,不放行 | 0.81 |
| 开 PDL,读完输入就放行 | 0.79 |
不开 PDL,每两个算子之间插一个 PyTorch 的 add_ | 1.67 |
开 PDL,每两个算子之间插一个 PyTorch 的 add_ | 1.40 |
插入 PyTorch 自己的算子以后,PDL 的收益从 0.31 μs 降到 0.27 μs(按每个自定义算子算)。PyTorch 的逐元素 kernel 不用 PDL 启动,它前后的两个边界里,只有”它 → 你的 kernel”这一个还能享受 PDL。
谁已经在用 PDL:用 CUDA Graph 的边来查
这是一个很实用的诊断方法:把一段代码抓成 CUDA Graph,看相邻 kernel 之间的边是不是 programmatic 类型。PyTorch 的 CUDAGraph(keep_graph=True) 可以拿到原始的 cudaGraph_t:
1
2
3
4
5
6
7
8
9
10
11
import cuda.bindings.runtime as rt
g = torch.cuda.CUDAGraph(keep_graph=True) # 保留原始图,才能用 raw_cuda_graph()
with torch.cuda.graph(g):
f() # 要检查的代码
raw = rt.cudaGraph_t(g.raw_cuda_graph())
_, frm, to, edges, n = rt.cudaGraphGetEdges(raw, 0) # 第一次调用只拿数量
_, frm, to, edges, n = rt.cudaGraphGetEdges(raw, n)
for a, b, e in zip(frm, to, edges):
print("PROGRAMMATIC" if e.type == 1 else "default", "port", e.from_port)
# kernel 名字:cuda.bindings.driver 的 cuGraphKernelNodeGetParams + cuFuncGetName
我检查了”自定义 PDL 算子 → A @ W(bf16,走 cuBLAS)→ 自定义 PDL 算子 → PyTorch add_ → 自定义 PDL 算子”这一串:
| 边 | 类型 |
|---|---|
| 自定义算子 → cuBLAS GEMM | programmatic |
| cuBLAS GEMM → 自定义算子 | programmatic |
| 自定义算子 → PyTorch 逐元素 kernel | 普通 |
| PyTorch 逐元素 kernel → 自定义算子 | programmatic |
第一行说明:在 B300 + CUDA 13.4 上,cuBLAS 的 GEMM kernel 本身就是用 PDL 启动的。 这和 cuBLAS 发布说明里”部分 kernel 在 sm_90 及以上支持 PDL”对得上。它带来两个直接的后果:
- 你的 kernel 后面如果紧跟着一个 cuBLAS GEMM,GEMM 可能在你的 kernel 运行期间就启动。只要 cuBLAS 在读你的输出之前等待了,这就是安全的。cuBLAS 曾经在这里出过错(等待之前读
alpha/beta,见 7.1 节),所以 cuBLAS 的补丁版本要跟上。 - 反过来,你的 PDL kernel 跟在 cuBLAS 后面时,cuBLAS 可能会提前放行,所以你的 kernel 必须在读 GEMM 结果之前等待。
PyTorch Inductor:triton.enable_pdl
打开方式有两种:环境变量 TORCHINDUCTOR_ENABLE_PDL=1,或者 torch.compile(fn, options={"triton.enable_pdl": True}),默认关闭。打开后,Inductor 生成的 Triton kernel 会自动带上等待和放行,并且以 launch_pdl=True 启动。
下面是 rms_norm → silu → 乘以 w 生成的 kernel(节选):
1
2
3
4
5
6
7
8
9
10
11
tl.extra.cuda.gdc_wait() # 第一个 load 之前就等待
for r0_offset in tl.range(0, r0_numel, R0_BLOCK):
tmp0 = tl.load(in_ptr0 + ...) # x
...
for r0_offset in tl.range(0, r0_numel, R0_BLOCK):
tmp6 = tl.load(in_ptr0 + ...) # x
tmp14 = tl.load(in_ptr1 + ...) # rms_norm 的 gamma
tmp25 = tl.load(in_ptr2 + ...) # w
...
tl.store(out_ptr1 + ..., tmp26, ...)
tl.extra.cuda.gdc_launch_dependents() # 所有 load 都做完之后放行
注意 gamma 和 w 的读取都在等待之后。Inductor 不知道哪个输入是”不会变的权重”,所以不会把它们挪到等待之前。它拿到的收益主要是”藏起启动空档”,而不是”提前加载权重”。
在一个 decode 风格的小模块上测试:16 层,每层是 rms_norm → mm → silu → mm → 残差相加,H = 2048,bf16。mm 走 cuBLAS。用 torch.cuda.graph 抓图后回放:
| batch | 关 PDL | 开 PDL | 提升 |
|---|---|---|---|
| 1 | 238.8 μs | 218.6 μs | 8.4% |
| 8 | 210.0 μs | 190.1 μs | 9.5% |
| 64 | 208.0 μs | 185.0 μs | 11.0% |
折算下来,每个 kernel 边界大约省 0.25~0.3 μs,和前面的测试一致。能省这么多有一个前提:cuBLAS 的 GEMM 本身也是用 PDL 启动的(上面查到的)。所以打开 Inductor 的 PDL 之后,Triton kernel 和 cuBLAS GEMM 之间两个方向的边界基本都能用上 PDL。
但打开之前一定要确认版本。 用 PyTorch #199166 里的复现脚本,在这个容器的 PyTorch(基于 2026-09-09 的上游代码)上跑:20 次调用里有 18 次结果错误,而且误差每次调用都会放大。修复 #199445 和 #199812 分别在 2026-10-12 和 2026-10-30 合入主干。也就是说,在 B300 上用 NGC 26.10 的 PyTorch 打开 triton.enable_pdl,会碰到这个 bug。 Inductor 的 PDL 默认关闭,是有道理的。
5.3 CuTe DSL
接口(nvidia-cutlass-dsl 4.8.0):
- kernel 里:
cute.arch.griddepcontrol_wait()、cute.arch.griddepcontrol_launch_dependents()。我看了 4.8.0 的源码,这两个函数都是带~{memory}clobber、标记了副作用的内联汇编,不会出现 7.4 节”坑 2”那种编译器把读挪到前面的问题。 - 启动时:
.launch(..., use_pdl=True)。4.8.0 的launch还直接支持programmatic_event=、programmatic_event_flags=、programmatic_event_trigger_at_block_start=、launch_completion_event=、launch_completion_event_flags=,覆盖了 2.8 节表里的所有启动属性。
自己写一个晚写入测试:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import cutlass
import cutlass.cute as cute
import cuda.bindings.driver as cuda
@cute.kernel
def producer(buf: cute.Tensor, value: cutlass.Int32, spin: cutlass.Int32):
tidx, _, _ = cute.arch.thread_idx()
bidx, _, _ = cute.arch.block_idx()
cute.arch.griddepcontrol_launch_dependents() # 一开始就放行
acc = cutlass.Float32(0.0)
for _ in cutlass.range(spin): # 忙一段时间
acc = acc * cutlass.Float32(0.5) + cutlass.Float32(1.0)
if acc > cutlass.Float32(-1.0): # 恒成立,只是让循环不被优化掉
buf[tidx, bidx] = value # 最后才写
@cute.kernel
def consumer(buf: cute.Tensor, out: cute.Tensor, read_before_wait: cutlass.Constexpr[bool]):
tidx, _, _ = cute.arch.thread_idx()
bidx, _, _ = cute.arch.block_idx()
if cutlass.const_expr(read_before_wait):
v = buf[tidx, bidx] # 错误示范
cute.arch.griddepcontrol_wait()
out[tidx, bidx] = v
else:
cute.arch.griddepcontrol_wait() # 正确性的边界
out[tidx, bidx] = buf[tidx, bidx]
@cute.jit
def pair(buf: cute.Tensor, out: cute.Tensor, value: cutlass.Int32, spin: cutlass.Int32,
stream: cuda.CUstream, read_before_wait: cutlass.Constexpr[bool]):
grid = (cute.size(buf, mode=[1]), 1, 1)
block = (cute.size(buf, mode=[0]), 1, 1)
producer(buf, value, spin).launch(grid=grid, block=block, stream=stream)
consumer(buf, out, read_before_wait).launch(grid=grid, block=block, stream=stream, use_pdl=True)
用 cute.compile 编译后,分别直接调用 30 次,以及放进 torch.cuda.graph 回放 30 次:等待之后读,两种方式都是 0 错;等待之前读,两种方式都是 100% 读到旧值。
官方教程在 B300 上的结果。 CUTLASS v4.8.0 的 examples/python/CuTeDSL/dsl_tutorials/programmatic_dependent_launch.py 计算 w = u + v、y = w + x 两个 kernel,自带 CUDA Graph 基准测试:
| 尺寸 | 不开 PDL | 开 PDL(--use_pdl) | 提升 |
|---|---|---|---|
| 256 × 256 | 5.41 μs | 4.76 μs | 12% |
| 1024 × 1024 | 10.36 μs | 9.72 μs | 6% |
| 4096 × 4096 | 86.54 μs | 85.40 μs | 1.3% |
同一目录下的 launch_completion_and_programmatic_events.py 在 B300 上也跑通了,包括 runtime 和 driver 两种事件类型,trigger_at_block_start 取 0 和 1 都试过。
读这个 PDL 教程时有一个细节值得注意:第一个 kernel(w = u + v)也用 use_pdl=True 启动,但它没有调用等待。 在教程里这没问题,因为基准测试每一轮用的是不同的 buffer,它和前一轮的 kernel 之间没有数据关系。但如果你照搬到真实框架里,前一个 kernel 是谁、会不会还在读写这些 buffer,你是不知道的。按本文的规则,应该补上等待。
5.4 四种写法对照
| CUDA C++ | Triton | CuTe DSL | PyTorch Inductor | |
|---|---|---|---|---|
| 等待 | cudaGridDependencySynchronize() | tl.extra.cuda.gdc_wait() | cute.arch.griddepcontrol_wait() | 自动插入 |
| 放行 | cudaTriggerProgrammaticLaunchCompletion() | tl.extra.cuda.gdc_launch_dependents() | cute.arch.griddepcontrol_launch_dependents() | 自动插入 |
| 启动 | cudaLaunchKernelEx + 启动属性 | kernel[grid](..., launch_pdl=True) | .launch(..., use_pdl=True) | triton.enable_pdl / TORCHINDUCTOR_ENABLE_PDL=1 |
| 跨 stream 事件 | 启动属性 | 不支持 | programmatic_event=、launch_completion_event= | 不支持 |
| 最要小心的坑 | __restrict__、__ldg、内联汇编不带 memory clobber | 等待放在流水循环里 | 照搬教程时漏掉第一个 kernel 的等待 | 旧版本的 #199166;权重不会被提前读 |
| B300 实测(CUDA Graph) | 每个边界省约 0.3 μs | RMSNorm 链快 1.5%~16% | 官方教程快 1%~12% | decode 小模块快 8%~11% |
6. 官方范例精读
NVIDIA 的 cuda-samples(v13.4)里没有 PDL 的示例,搜遍所有 PDL 相关的 API 都没有结果。真正有参考价值的官方范例集中在 CUDA Programming Guide 和 CUTLASS 里。
6.1 CUDA Programming Guide
PDL 章节给的示例结构和第 3 节的代码一样:前一个 kernel 做完主要工作后放行;后一个 kernel 先做准备工作,然后等待,再读前一个 kernel 的结果。它举的准备工作例子是”把 buffer 清零或者加载常量”。完整的启动配置写法在第 3.1.4 节。
6.2 CuTe DSL 教程
CUTLASS 仓库里的 programmatic_dependent_launch.py 是最适合初学者的官方材料:
- 两个 kernel:
w = u + v,然后y = w + x; - 后一个 kernel 先读和前一个无关的
x,再调用cute.arch.griddepcontrol_wait(),然后读依赖前一个 kernel 的w; - 启动时传
use_pdl=True; - 教程提醒:不用 CUDA Graph 的话,主机侧的开销会把重叠效果盖住。
CuTe DSL 的文档(media/docs/pythonDSL/ts_general/ts_pdl.rst)把等待称为”正确性边界”(correctness boundary),这个说法很准确。
同一个目录下还有一个较新的教程 launch_completion_and_programmatic_events.py,专门演示 2.8 节表里的两种事件属性:
- launch completion 事件:所有 block 开始执行时触发,任何计算能力都能用;
- programmatic 事件:
trigger_at_block_start=0时要每个 block 自己调用放行,取 1 时每个 block 一开始就自动放行,而且”对下一个 kernel 的griddepcontrol_wait()可见”。
这两个教程我都在 B300 上跑过,结果和需要注意的细节见 5.3 节。
6.3 CUTLASS GEMM:专家怎么放”等待”和”放行”
CUTLASS 的 Hopper GEMM 是 warp specialization 结构:不同的 warp 分工做不同的事(有的负责用 TMA 搬数据,有的负责矩阵乘,有的负责写回结果)。以 include/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized_cooperative.hpp(main 分支)为例:
| 位置 | 做什么 | 和 PDL 的关系 |
|---|---|---|
| 第 413~414 行附近 | 预取 TMA 描述符 | 在等待之前:描述符只和参数有关 |
| 第 558 行附近 | 等待 cluster 内的 barrier / pipeline 初始化完成 | 在等待之前:只和 kernel 自身有关 |
| 第 570 行 | 调度 warp 调用 wait_on_dependent_grids() | 调度器可能读上一个 kernel 写的数据 |
| 第 605 行 | 搬运输入的 warp 调用等待,然后才开始 load() | 每种角色在自己第一次读依赖数据之前等待 |
| 第 722 行 | 搬运 epilogue 输入的 warp 调用等待 | 同上 |
| 第 830 行 | 计算 warp 在最后一块的矩阵乘结束后、写回结果之前,调用 launch_dependent_grids() | 放行放在”主要计算刚结束、写回还没开始”的时候 |
第 828 行的注释值得记住:
The timing of calling this function only influences performance, not functional correctness.
这正是 2.3 节说的:放行的位置只影响性能,正确性完全靠后一个 kernel 的等待保证。
Blackwell 的 sm100_gemm_tma_warpspecialized.hpp 套路一样:先等 pipeline 初始化,再让每个需要读依赖数据的 warp 角色各自等待,最后由 MMA warp 放行。
CUTLASS 的接口:
- 设备端:
cutlass::arch::wait_on_dependent_grids()/launch_dependent_grids()(include/cutlass/arch/grid_dependency_control.h); - 编译宏:
-DCUTLASS_ENABLE_GDC_FOR_SM90=1或CUTLASS_ENABLE_GDC_FOR_SM100; - 主机端:
gemm.run(stream, nullptr, /*launch_with_pdl=*/true)。
6.4 CUTLASS example 63:等待时把权重预取进 L2
example 63 是”等待之前做什么”的最佳示范。README 里说:
The kernel can optionally prefetch a portion of weights (operand
A) into L2 cache while the rest of the warps are waiting on the previous kernel to finish writing and flush its memory. An example of this is normalization or reduction kernels that are immediately followed by a GEMM.
也就是:GEMM 的 A 是模型权重(推理时不变),B 是激活(上一个 kernel 刚算出来)。等待上一个 kernel 的时候,专门的 warp 先把一部分权重搬进 L2。
源码里(collective/sm90_mma_tma_gmma_ss_warpspecialized_with_prefetch.hpp)有三处注释把逻辑讲得很清楚:
- 第 422 行:”We have to wait on dependent grids because of B.”(因为 B 依赖上一个 kernel,所以要等)
- 第 515 行:”we assume
A(weights) are static.”(权重被假定为不变,所以加载 A 不等待) - 第 599 行:”…unflushed global memory prior to this instruction”(加载 B 之前必须等待,保证不会碰到还没写回的内存)
两个可调参数:
overlap_ratio(默认 0.5):放行有多早,0.5 表示大约一半 K 方向的 tile 加载完时放行;prefetch_ratio(默认 −1.0):预取多少权重,−1 表示”其他搬运 warp 一过等待就停止预取”。
README 建议按端到端时间(一个或几个 transformer 层)对这两个参数做调优。另外,加载权重时用 EvictFirst 缓存提示,加载激活时用 EvictLast。README 没有给性能数字,只说”主要的提升预计体现在端到端应用中”。
一个必须注意的前提:example 63 假定 A 是静态权重。 如果你的”权重”其实是每次新建的张量,这个假设就不成立了。SGLang 的 #38290 就是这样出的问题:router 的 bias 被当作固定权重在等待之前加载,但调用方传进来的是每次新建的张量,结果输出变成一串 !,用插桩抓图和反汇编确认了是 NaN。
6.5 CUTLASS example 93:低延迟 GQA 解码
examples/93_blackwell_low_latency_gqa 是 attention 版本的同一个思路(tgv_gqa.cuh):
- 第 560 行附近:”only do griddepcontrol.wait on Q loading, Q is dependent on previous kernel”——只有加载 Q 时等待,因为 Q 是上一个 kernel 算出来的;
- 第 606 行附近:加载 K、V 时不等待——KV cache 在这一步里不是上一个 kernel 写的;
- 放行放在 KV 搬运 warp 的末尾。
这里要特别小心:KV cache 能不能在等待之前读,取决于你的框架里”上一个 kernel”是什么。如果上一个 kernel 恰好负责把新 token 的 K、V 写进 cache,那就不能照搬。
6.6 官方范例的共同套路
| 阶段 | 放什么 |
|---|---|
| 等待之前 | 算索引;初始化 shared memory、barrier、pipeline、TMEM;预取 TMA 描述符;加载整个推理过程中不会变的数据(权重) |
| 等待 | 每种 warp 角色在自己第一次读依赖数据之前等待;不需要所有线程在开头一起等 |
| 放行 | 主要计算结束后、写回结果之前;或者按问题大小调节(example 63 的 overlap_ratio) |
7. 怎么写:规则与各种写法
7.1 等待之前能做什么、不能做什么
可以做:
- 算索引、读 kernel 参数(按值传进来的标量);
- 初始化 shared memory、barrier;
- 预取 TMA 描述符;
- 读在整个推理过程中都不会被改写的数据,比如模型权重、RMSNorm 的 gamma。
不能做:
- 读上一个 kernel 的输出(激活、残差、量化 scale、路由结果);
- 读”看起来像权重,其实是每次新建”的张量(SGLang #38290);
- 通过指针读的标量。 NVIDIA 自己的 cuBLAS 也犯过这个错:某些 GEMM 在等待之前读了
alpha、beta指针指向的值,如果前一个 PDL kernel 在放行之后才写好这两个值,就会读到旧值。这个问题在 cuBLAS 13.6.1 补丁里修复(补丁说明,编号 CUB-10409); - 写上一个 kernel 可能还在读的 buffer。 比如在等待之前把一块 workspace 清零,而上一个 kernel 还在用它。这是”读后写”冲突,和前面几种方向相反,同样危险。
判断标准只有一条:这块数据在上一个 kernel 运行期间,有没有可能被改写或被读取? 只要有可能,就放到等待之后。
7.2 放行放在哪
| 位置 | 例子 | 优点 | 风险 |
|---|---|---|---|
| kernel 一开始 | ONNX Runtime 的 FP4 GEMV;部分 TRT-LLM / vLLM 的 Triton kernel | 重叠最多 | 后一个 kernel 的 block 过早占用 SM 资源,可能拖慢前一个 kernel |
| 等待之后马上放行 | TRT-LLM AllReduce 融合 kernel 的一种模式 | 让下一个 GEMM 在整个 AllReduce 期间都能做准备 | 同上 |
| 主要计算结束、写回之前 | CUTLASS GEMM;TRT-LLM MoE kernel(注释:”在写回进行中就启动后续 kernel”) | 前一个 kernel 的主要工作不受干扰 | 重叠变少 |
| kernel 最后 | FlashInfer 的 RMSNorm | 最保守 | 重叠最少 |
| 不放行(等于退出时放行) | DeepGEMM | 最简单 | 只省下一点启动空档(B300 实测约 0.4 μs,4.2 节) |
没有通用答案:
本文 4.8 节的 B300 实测:同一个逐元素 kernel,400 万元素时”一开始放行”比不开 PDL 还慢 6%;到了 1600 万元素,它又成了最快的。
- CUTLASS 维护者在 #2778 里说,放行过早会干扰正在运行的 kernel;两个 GEMM 前后相连时,通常因为 shared memory 不够,根本重叠不起来。
- llama.cpp 的 PR 作者说放行位置是”反复试出来的”,放在 kernel 底部”几乎总是没收益”,在
mul_mat_vec_q里加放行甚至变慢了。 - vLLM 的 #64494 发现大 M 时过早放行在 M=8192 下最多多花 22 μs,于是按问题大小决定放行时机。
实用建议:先放在”主要计算结束、写回之前”,然后在真实的 decode 场景下按端到端时间调。
7.3 各种写法速查
| 工具 | 启动端 | kernel 内 |
|---|---|---|
| CUDA C++ | cudaLaunchKernelEx + cudaLaunchAttributeProgrammaticStreamSerialization | cudaGridDependencySynchronize() / cudaTriggerProgrammaticLaunchCompletion() |
| CUTLASS C++ | 编译宏 CUTLASS_ENABLE_GDC_FOR_SM90/SM100;gemm.run(..., launch_with_pdl) | cutlass::arch::wait_on_dependent_grids() / launch_dependent_grids() |
| CuTe DSL | .launch(..., use_pdl=True) | cute.arch.griddepcontrol_wait() / griddepcontrol_launch_dependents() |
| Triton | kernel[grid](..., launch_pdl=True) | tl.extra.cuda.gdc_wait() / gdc_launch_dependents() |
| TileLang | 编译器自动加启动属性 | T.pdl_sync() / T.pdl_trigger() |
| ThunderKittens | Config::USE_PDL | kittens::pdl::wait() / arrive() |
| JAX Pallas(Mosaic GPU) | 自动 | plgpu.griddepcontrol_wait() / launch_dependents() |
| CCCL(CUB 内部) | 自动 | _CCCL_PDL_GRID_DEPENDENCY_SYNC() / _CCCL_PDL_TRIGGER_NEXT_LAUNCH() |
| llama.cpp(内部) | ggml_cuda_kernel_launch | ggml_cuda_pdl_sync() / ggml_cuda_pdl_lc() |
一个 Triton 的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import triton
import triton.language as tl
@triton.jit
def add_kernel(x_ptr, w_ptr, out_ptr, n, BLOCK: tl.constexpr):
offs = tl.program_id(0) * BLOCK + tl.arange(0, BLOCK)
mask = offs < n
w = tl.load(w_ptr + offs, mask=mask) # 常量:可以在等待之前读
tl.extra.cuda.gdc_wait() # 等上一个 kernel 结束
x = tl.load(x_ptr + offs, mask=mask) # 上一个 kernel 的输出
tl.extra.cuda.gdc_launch_dependents() # 放行下一个 kernel
tl.store(out_ptr + offs, x + w, mask=mask)
add_kernel[grid](x, w, out, n, BLOCK=1024, launch_pdl=True)
Triton 文档说明,gdc_wait 和 gdc_launch_dependents 在没有开 PDL 时执行也是安全的。这两个接口在 2025 年 4 月合入 Triton。
更完整的、在 B300 上测过的 Triton、PyTorch、CuTe DSL 例子见第 5 节。
7.4 编译器会”帮倒忙”:四个和编译相关的坑
坑 1:编译宏没开,等待和放行变成空代码。 CUTLASS 的 wait_on_dependent_grids() 在没有定义 CUTLASS_ENABLE_GDC_FOR_SM90/SM100 时什么都不做。启动端照样设了 PDL 属性,kernel 里却没有等待,就会读到旧数据。TRT-LLM 的 #9530(Qwen3-235B 精度问题)修复时,除了给一个路由 kernel 补上等待和放行,还专门加上了这两个编译宏。
坑 2:内联汇编没写 memory clobber。 如果自己写 asm volatile("griddepcontrol.wait;");,没有 ::: "memory",编译器不知道这条指令和内存有关,可以把后面的读挪到它前面。TRT-LLM 的 #9799(DeepSeek-V3 MoE 输出空 logits)就是这个原因,修复方式是改用 cudaGridDependencySynchronize()。CUTLASS 自己也改过:3.6.0 的 wait_on_dependent_grids() 里是 asm volatile("griddepcontrol.wait;"),现在 main 分支是 asm volatile("griddepcontrol.wait;" ::: "memory")。
坑 3:__restrict__ 和 __ldg。 这两个写法等于告诉编译器”这块数据在本 kernel 运行期间不会变”,编译器会用只读的非一致性加载(PTX 里的 ld.global.nc,机器码里是 LDG.E.CONSTANT)。但用了 PDL 之后,后一个 kernel 开始运行时,上一个 kernel 可能还在写这块数据,这个前提不成立了,编译器可以据此把读挪到等待之前。这个坑被至少五个项目各自独立发现:
- llama.cpp #24030:”Avoid PDL race conditions by disabling
__restrict__when PDL is used”; - DeepEP 的源码注释:”PDL is used, please do not use
__ldg“; - FlashMLA 的源码里有类似的注释;
- TileLang 遇到
__ldg和pdl_sync同时出现会直接编译失败; - XLA 在一个提前放行的 kernel 之后,会禁用”不变量加载”优化。
我在本地对比了四种写法在 sm_90 上的机器码(nvcc -O3 -arch=sm_90),源码都是”先读 w,再等待,再读 y“:
| 写法 | 机器码里的顺序 |
|---|---|
| 普通指针 | 读 w(LDG.E)→ ACQBULK → 读 y → 写 z |
所有指针加 __restrict__ | ACQBULK → 读 w、读 y(都变成 LDG.E.CONSTANT)→ 写 z |
等待之后用 __ldg(&y[i]) | 读 w → ACQBULK → 读 y(LDG.E.CONSTANT) |
| 内联汇编不带 memory clobber | 和普通指针一样 |
在这个很小的例子里,编译器没有把任何读挪到等待之前;但加了 __restrict__ 之后,它把我们本想在等待之前做的 w 读挪到了等待之后,重叠就没了。这说明两件事:编译器确实会跨着等待指令调整顺序,而且方向不一定是你预期的;源码的顺序不可信,要看机器码。 上面那些项目遇到的,是编译器在更复杂的代码里把读挪到了等待之前。
坑 4:Triton 的软件流水。 循环里调用 gdc_wait 时,Triton 的软件流水优化曾经把 cp.async 加载挪到等待之前(Triton #11905),修复方式是不对含等待的循环做流水(#11906)。TRT-LLM 的一些 Triton kernel 也专门用带 memory clobber 的等待来规避类似问题。我在 B300 + Triton 3.8.0 上测了同样的写法:等待放在流水循环里时直接编译失败;只把等待放在循环之前,流水照常进行,结果正确(5.1 节)。结论:在 Triton 里把等待放在循环之前。
8. 真实 bug 分类
把各项目遇到的 PDL 问题按原因归类:
| 类别 | 例子 | 现象 |
|---|---|---|
| 等待之前读了上一个 kernel 的输出 | TRT-LLM #14668 + CUTLASS #3279:sm103 GEMM 里负责加载 scale factor 的那个 warp 从不等待 | DeepSeek-R1 NVFP4 在 GB300 上 GSM8K 91.93(修复后 95.34);插桩发现 2.31% 的 scale factor 读到了垃圾值 |
| SGLang #38290:router bias 在等待之前读 | 输出变成一串 !(NaN) | |
cuBLAS CUB-10409:等待之前读 alpha/beta 指针 | 可能读到旧值 | |
| FlashInfer #5081:AllReduce 融合 kernel 在等待之前构造读取残差、gamma 的对象 | 修复时把构造挪到等待之后,并加了专门测试 | |
| 用 PDL 启动的 kernel 没有等待 | TRT-LLM #9530:路由 kernel 用 PDL 启动却从不等待 | Qwen3-235B 精度下降 |
| FlashAttention #2481:缺少等待 | GB200 上几步内就出错,H100 上 3000 多步才出现一次,静默写坏 dQ/dK | |
| 链条断裂 | PyTorch #199166:中间一个只写零的 kernel 不等待 | 第三个 kernel 在第一个还在计算时读数据 |
| 编译器移动了读 | TRT-LLM #9799(内联汇编)、llama.cpp #24030(__restrict__)、Triton #11905(软件流水) | 精度问题、NaN |
| 编译宏没开 | TRT-LLM #9530 | 启动有 PDL,kernel 里没有等待 |
| 跨库组合 | TransformerEngine #2489:cuBLAS 的 GEMM 后面接 cuDNN 的 RMSNorm | NaN;cuDNN 确认”kernel 里少了几处 PDL 同步”,在 cuDNN 9.18 修复 |
| TransformerEngine #2001 给 8 个连续的量化 kernel 加 PDL,快了 1.22 倍,之后因输出错误被回退(#2114) | 输出错误 | |
| 通信 kernel | vLLM AllReduce+RMSNorm 融合:one-shot Lamport AllReduce 在 token ≤ 16 时提前放行(代码注释里记录了 NaN) | NaN |
| FlashInfer #3835、#4172:MoE 收尾和 FP4 MoE 的卡死 | 卡死(根因未确认,修复未合入) |
几条从这张表里能得到的教训:
- 新硬件会让潜伏的 bug 暴露得更快。 FlashAttention #2481 在 H100 上几乎看不出来,在 GB200 上几步就出错。在一代硬件上”跑了很久没问题”,不代表代码是对的。
- 你不知道上一个 kernel 是谁。 TransformerEngine #2489 里,前一个 kernel 来自 cuBLAS,后一个来自 cuDNN,两个库各自都”看起来没问题”。所以每一个用 PDL 启动的 kernel 都必须在第一次读依赖数据之前等待,不能假设上一个 kernel 会配合。
- 这类 bug 不报错,只表现为精度下降、偶发 NaN 或乱码。 必须靠专门的测试来抓(见第 12 节)。
9. 什么时候有用,什么时候没用
9.1 有用的情况
- decode、小 batch,kernel 只有几微秒到几十微秒;
- 在 CUDA Graph 里运行(主机侧开销已经去掉,GPU 侧的空档成为主要矛盾);
- 后一个 kernel 有分量足够的准备工作:加载权重、预取 TMA 描述符、初始化 barrier;
- 前一个 kernel 有明显的”尾巴”(最后一波 block 填不满 SM)。
9.2 没用或变慢的情况
| 情况 | 证据 |
|---|---|
| 大 kernel(prefill、大 GEMM) | CCCL 2^28 元素时收益约为 0;FlashInfer 53 μs 的 GEMM 只快 0.9%;llama.cpp prefill 约 1.0 倍 |
| 大问题上过早放行 | vLLM #64494:M=8192 时最多多花 22 μs,所以按大小决定 |
| 不在 CUDA Graph 里(eager 模式) | LMDeploy #4861:eager 模式 batch 1 从 14.5 μs 变成 16.4 μs;vLLM #64981:首 token 时间 +3%;本文 4.8 节:小 kernel 卡在 CPU 发射速度上,开不开 PDL 都是约 2 μs 一个 |
| 中间夹一个不带 PDL 的 kernel 或 memset | CUTLASS #2963;vLLM #31777(LoRA 两个 kernel 中间夹了一个普通 GEMM);CCCL 把”所有 kernel 都用 PDL 启动,否则……”写成了性能审查规则 |
| 老 GPU 上加了属性 | vLLM #65059:A100 上 CUDA Graph 多一条边,每次回放多 0.6~1.1 μs |
| 中等 batch、部分模型 | vLLM #64981:FP8 模型在并发 8 时慢了 0.9%~1.4% |
| 等待之前预取太多 | 本文 4.8 节:GEMV 每层权重 67~268 MB 时,在等待之前预取整行权重,每层慢 16%~28% |
| 后一个 kernel 挤不进 SM(shared memory 不够) | 本文 4.5 节:只剩下藏起启动空档的那部分收益(约 0.45 μs) |
stream 上夹一个 cudaMemsetAsync | 本文 4.4 节:间隔变成 4.5 μs,比普通 kernel 边界(约 1 μs)长得多 |
| 跨 stream 直接用 programmatic 事件 | 本文 4.6 节:eager 模式下没有测到重叠,要抓进 CUDA Graph 才有 |
| 和多 stream 重叠互相干扰 | SGLang #39941 在 SM103 上关掉一个小 router 的 PDL,快了 3.6%;同一条规则后来让 DeepSeek-V4-Pro 慢了 4.5%~5.1%(#42074) |
最后一条说明:按”架构 + 某个 kernel”写死的开关规则很脆弱,换个模型就可能反过来。 能用问题大小这种可解释的门槛,就不要用经验性的特例。
用问题大小做门槛的例子:CCCL 的 radix sort 只在元素数 ≤ 2^24 时用 PDL;FlashAttention 3 在 batch ≤ 992 时用;SGLang 的 MoE 默认只在 token 数 ≤ 8192 时用(SGLANG_TRTLLM_MOE_PDL_MAX_TOKENS)。
9.3 怎么确认 PDL 生效了
NVIDIA 的 Nsight Systems 文档里没有专门讲 PDL;CuTe DSL 教程里只有一句”可以用 nsys 观察到重叠执行”。下面几种方法是实践中常用的,前两种最可靠:
- 看机器码:
cuobjdump -sass里后一个 kernel 有ACQBULK、前一个有PREEXIT。这能排除”宏没开、kernel 里根本没有等待”的情况。 - 开关对比:用框架的环境变量(如
TRTLLM_ENABLE_PDL=0)关掉 PDL,在 CUDA Graph 下对比 decode 的每 token 耗时。 - 看时间线:Nsight Systems 里,同一个 stream 上后一个 kernel 的色块在前一个 kernel 结束之前就开始了。
- 看图的边:
cudaGraphGetEdges返回的边类型是 programmatic。在 PyTorch 里可以用CUDAGraph(keep_graph=True)拿到原始图,一次性查出整段代码里哪些边界用上了 PDL、哪些断了(5.2 节)。 - 打时间戳:在 kernel 里读
%globaltimer,直接算出后一个 kernel 比前一个早启动了多少、等待什么时候返回(4.1 节)。这是验证”放行位置”和”资源能否同时驻留”最直接的办法。
10. 各框架与计算库怎么用
10.1 推理框架
| 项目 | 开关 | 默认 | 特点 |
|---|---|---|---|
| TensorRT-LLM | 环境变量 TRTLLM_ENABLE_PDL,设为 0 关闭 | SM90 及以上默认开(#9695,2025-12) | C++ 统一用 launchWithPdlWhenEnabled;约 41 个文件的 kernel 支持,覆盖通信、norm、量化、MoE、GEMM、attention、top-k |
| FlashInfer | 各 API 的 enable_pdl 参数 | 多数为 None,表示自动(device_support_pdl():SM90 及以上开);mm_bf16、rope 量化等默认关 | 早期用环境变量,#1446 改成显式参数 |
| vLLM | 没有全局开关 | 用 FlashInfer 时跟随其自动判断;13 个自带 CUDA kernel 固定开;LoRA 默认关 | 关闭 LoRA PDL:VLLM_LORA_DISABLE_PDL |
| SGLang | is_arch_support_pdl() | SM90 及以上开 | SGLANG_DEEPGEMM_PDL;SGLANG_TRTLLM_MOE_PDL_MAX_TOKENS=8192 |
| PyTorch Inductor | TORCHINDUCTOR_ENABLE_PDL,或 torch.compile(options={"triton.enable_pdl": True}) | 关 | 生成代码时自动插入等待和放行(见下文);B300 上 decode 小模块快 8%~11%,但要用含 #199445、#199812 修复的版本(5.2 节) |
| TokenSpeed | --disable-pdl | Hopper 及以上开 | 打开时,如果用户没设置,会顺带设 TORCHINDUCTOR_ENABLE_PDL=1 和 TRTLLM_ENABLE_PDL=1 |
| llama.cpp | GGML_CUDA_PDL=0 关闭 | 开 | 约 25 个 kernel 文件;每个 kernel 运行时检查 PTX 版本 ≥ 90;PDL 开启时去掉 __restrict__ |
| LMDeploy | — | TurboMind 部分 SM90 kernel 固定开;PyTorch 引擎在 SM90 及以上开 | 还会调用 DeepGEMM 的 set_pdl(True) |
| ONNX Runtime | ORT_ENABLE_PDL 等多个变量 | 移植自 TRT-LLM 的 MoE 默认关;部分 FP4 GEMV 默认开 | CUDA contrib 算子 |
| XLA / JAX | --xla_gpu_enable_pdl、--xla_gpu_enable_pdl_launch | 都是开 | 每个生成的 kernel 开头等待;Triton GEMM 在主循环和 epilogue 之间放行 |
| unsloth | — | 在特定条件下主动关掉 vLLM LoRA 的 PDL | 规避 vLLM #30872(gdc_wait 影响 CUDA Graph 抓图) |
| Dynamo、Megatron-LM | — | 本地代码里没有用到 | — |
几个值得单独说的设计:
PyTorch Inductor:自动插入。 Inductor 生成 Triton kernel 时,会分析这个 kernel 读写的 buffer:在第一个可能和上一个 kernel 冲突的读或写之前插入等待,在读完输入之后插入放行,最后只保留第一个等待和最后一个放行(torch/_inductor/codegen/triton.py)。这是”让机器保证正确性”的思路,比靠人记规则可靠得多。
TensorRT-LLM:pdlSafe。 trtllm-gen GEMM 可以对每个输入分别指定是否等待(mGridWaitForPrimaryA/B)。启动时只有当 kernel 至少会等待一个输入,才加 PDL 属性(GemmInterface.h)。这样就不会出现”启动带了 PDL、kernel 里却不等待”。
FlashInfer:两种判断规则。 norm 类算子写的是 if enable_pdl is None or enable_pdl:,即使调用方显式传了 True 也会再检查一次 GPU 架构;而 activation、sampling 等只在 None 时才自动判断。这种细节上的不一致,在大项目里很常见,用的时候要看清楚。
10.2 计算库与 kernel DSL
| 项目 | 是否使用 | 开关与默认 | 说明 |
|---|---|---|---|
| CUTLASS | 是 | 编译宏 + launch_with_pdl 参数 | 见第 6 节 |
| CCCL(CUB / Thrust) | 是 | 计算能力 ≥ 9.0 时默认开;CCCL_DISABLE_PDL 关闭 | scan、merge sort、radix sort、transform 等;radix sort 只在 ≤ 2^24 个元素时用 |
| cuBLAS | 是 | 没有对外开关 | CUDA 13.0 Update 1 起:”部分 cuBLAS kernel 在 sm_90 及以上支持 PDL”。B300 + CUDA 13.4 上抓图确认:bf16 GEMM 是用 PDL 启动的(5.2 节) |
| NCCL | 是 | 没有开关 | 2.27.3 起,对称内存集合通信 kernel 在计算能力 ≥ 9.0、驱动 ≥ 12.3 时自动用 PDL 启动 |
| cuDNN frontend | 是 | 开源 CuTe DSL kernel 的 use_pdl,多数默认关 | #1961:CUDA Graph 下 +0.6%~+3.5%,输出逐位相同 |
| DeepGEMM | 是 | deep_gemm.set_pdl(True),默认关 | 约 27 个 kernel 只等待、不显式放行 |
| DeepEP | 是 | epilogue kernel 固定开 | 先初始化 mbarrier 再等待;注释警告不要用 __ldg |
| FlashMLA | 是 | split-KV 合并 kernel 固定开 | decode kernel 本身不用 PDL 启动,注释:”因为可能的编译器 bug,不用 PDL” |
| FlashAttention 3 / 4 | 是(部分) | FA3 用 CUTLASS 编译宏;FA4 use_pdl | FA3:变长调度 → attention、split-KV → 合并 |
| quack | 是 | GEMM 默认 use_pdl=True | 等待和放行的位置和 CUTLASS C++ 一致 |
| ThunderKittens | 是 | Config::USE_PDL,默认关 | B200/B300 的 mxfp8/nvfp4 GEMM |
| TileLang | 是 | 编译器只给含 T.pdl_sync() 的 kernel 加启动属性 | 从设计上避免”有属性没等待” |
| Mirage MPK | 部分 | 静态 megakernel 有钩子,生成的启动代码没有加属性 | 常驻版 MPK:不支持 PDL |
| TransformerEngine | 否 | 加过又回退 | 见第 8 节 |
| TensorRT(独立)、MSCCL++、NVSHMEM、Liger-Kernel | 没找到 | — | 公开代码和文档里没有找到使用证据 |
CCCL 的数据最有教学意义。 同一个 PDL 改动,2^16 个元素时 merge sort 快 16%、scan 快 19.5%、radix sort 快 16%,到 2^28 个元素时几乎没变化。它把”PDL 省的是固定时间”这件事展示得非常清楚。
NCCL 和 cuBLAS 已经在悄悄用 PDL 了。 这意味着你的 kernel 前后很可能就是一个 PDL kernel,而你没有开关可以控制它。这再次说明:自己的 kernel 用 PDL 启动时,一定要等待。
10.3 一个端到端例子:AllReduce 之后的 GEMM 提前加载权重
TRT-LLM 的 DeepSeek-R1 低延迟 tech blog 里描述了一个很好的组合:
- AllReduce 融合 kernel 有一个模板参数
TriggerCompletionAtEnd,决定放行放在最后还是等待之后马上放行; - TRT-LLM 的多个模型(如
modeling_gpt_oss.py、modeling_nemotron_h.py)有意传入trigger_completion_at_end=False。AutoDeploy 里的注释说明了用意:”PDL early trigger: fire launch-completion before the reduce loop so the next projection GEMM’s weight-load prologue overlaps the AR tail”(trtllm_dist.py,调研时的版本;这个文件在之后的main里被移动了),也就是让下一个 GEMM 在 AllReduce 运行期间就开始加载权重; - blog 里说,后面的 Fuse_A_GEMM “把大部分权重预取进了 shared memory(由 PDL 实现,并与 one-shot AllReduce 重叠)”。
拆开看:
- AllReduce 是通信密集的,GEMM 加载权重是显存带宽密集的,两者用的资源不完全一样,重叠得起来;
- 权重在推理中不变,可以安全地在等待之前加载;
- GEMM 读 AllReduce 的输出(激活)之前等待,正确性有保证。
这正好对应了第 6 节总结的官方套路:等待之前加载不变的数据,等待之后读依赖的数据,前一个 kernel 尽早放行。
11. 其他芯片厂商与替代方案
11.1 其他厂商有没有类似机制
| 厂商 | 结论 | 依据 |
|---|---|---|
| AMD(ROCm / HIP) | 没有设备端的对应机制 | HIPIFY 的 CUDA→HIP 映射表把 cudaLaunchAttributeProgrammaticStreamSerialization 和 cudaLaunchAttributeProgrammaticEvent 标为不支持;cudaGridDependencySynchronize 等设备函数没有对应条目;HIP 头文件的启动属性枚举里也没有。HIP 映射了图里的 programmatic 边类型,但抓图时使用这类边会返回”不支持”,只是接口上的占位。 |
| Intel(Level Zero) | 没有找到 | ze_api.h(v1.35.0)里没有相关接口 |
| Google TPU / XLA | 没有找到对应机制 | XLA 在 TPU 上的思路是把计算编译、融合成整体程序 |
| 华为昇腾、Apple Metal | 未能核实 | 没有拿到可靠的官方资料,这里不下结论 |
AMD 有一个思路相近但不同的功能:启动属性 hipLaunchAttributeExtDynDataPrefetch,作用是”在 kernel 执行前把数据预取进 L2”。它和 CUTLASS example 63 的权重预取目的类似,但是由主机端发起,不涉及跨 kernel 的重叠,不能算 AMD 版的 PDL。
对框架设计的意义:如果你的框架要同时支持 NVIDIA 和 AMD,PDL 相关的代码必须是”可以整体关掉”的,并且关掉之后正确性不能依赖它。
11.2 替代方案
| 方案 | 怎么解决同一个问题 | 和 PDL 的关系 |
|---|---|---|
| kernel 融合 | 直接去掉边界 | 互补,能融合先融合 |
| 常驻 GPU 的大内核(megakernel) | 整个前向只启动一次 kernel,内部自己调度任务 | 更彻底,但工程量大得多 |
| Stream-K | 解决一个 GEMM 内部最后一波 block 填不满 SM 的问题 | 不同层面:Stream-K 处理单个 kernel 的尾巴,PDL 处理两个 kernel 之间 |
| CUDA Graph | 去掉主机侧发射开销 | 互补,官方支持一起用 |
两篇 megakernel 工作都直接评价了 PDL:
- Hazy Research 的 No Bubbles(2025-05):”我们发现它仍然会带来不必要的停顿,因为 PDL 的同步机制(
cudaGridDependencySynchronize)非常粗……我们必须等所有的 Q、K、V 都算完才能开始 attention,而不是哪个 head 算好了就开始哪个。” 他们在 H100 上测到,一次 kernel 启动在 stream 上约 2.1 μs,用 CUDA Graph 约 1.3 μs。 - Mirage Persistent Kernel(MPK):”采用 PDL 需要大量的工程投入,因为它从根本上改变了 kernel 的结构和控制流。”
11.3 PDL 的局限和下一步
两篇工作抱怨的是同一件事:PDL 的等待是整个 grid 级别的——后一个 kernel 必须等前一个 kernel 的所有 block 都结束,哪怕它只需要其中一小块数据。
NVIDIA 自己也在往这个方向改进。Rubin 架构 blog 用一张图对比了”Blackwell 的批量触发(bulk triggering)”和”Rubin 的 tile 级触发(tile-level triggering)”。截至本文写作时,我没有找到 tile 级触发的公开编程接口,所以这里只记录方向,不做展开。
12. 给框架设计者的建议
如果你在设计或维护一个推理框架,下面这些是从各家经验里总结出来的做法。
1. 开关分三层。
- 全局开关:一个环境变量或启动参数,能一键关掉(
TRTLLM_ENABLE_PDL=0、GGML_CUDA_PDL=0、--disable-pdl、CCCL_DISABLE_PDL); - 架构判断:只在计算能力 ≥ 9.0 时加启动属性(避免老 GPU 上 CUDA Graph 多出的边);更严格的做法是检查 kernel 实际编译的 PTX 版本(llama.cpp 的做法);
- 每个 kernel 的判断:这个 kernel 是否”PDL 安全”,以及问题大小是否在收益区间内。
2. 把”启动属性”和”kernel 里有等待”绑在一起,不要让两件事分开配置。 这是最重要的一条。三种已有的做法:
- TileLang:编译器发现 kernel 里有
pdl_sync才加启动属性; - TRT-LLM trtllm-gen:kernel 至少等待一个输入才用 PDL 启动(
pdlSafe); - PyTorch Inductor:根据读写分析自动插入等待。
反面情况是:启动属性由调用方的参数决定,kernel 里有没有等待由另一个人维护(或者由一个编译宏决定)。两边一旦不同步,就是 TRT-LLM #9530 那种问题。
3. 每个 PDL kernel 的开头写清楚三件事:等待之前读了哪些数据、为什么它们在上一个 kernel 运行期间不会变;放行放在哪、为什么;有没有用 __restrict__ / __ldg。这些决定在代码里很难看出来,出问题时第一个要查的就是它们。
4. 专门的正确性测试。 FlashInfer main 分支的 tests/test_helpers/pdl.py 提供了一个很好的思路:写一个”晚写入”的前一个 kernel——一开始就放行,然后空转一段时间,最后才写数据。后一个 kernel 只要在等待之前读了这块数据,就一定读到旧值。再配合 NaN 哨兵值(先把输出 buffer 填成 NaN),可以稳定地抓到”等待之前读”的问题。PyTorch 的 test_pdl_mutation 也是同类测试。本文 4.1 节和 5.1、5.3 节分别给出了 CUDA C++、Triton、CuTe DSL 版本的晚写入测试:在 B300 上,等待之前读的错误能 96%~100% 稳定复现。测试里还要包括 A → B → C 这种”中间隔一个不等待的 kernel”的情况,PyTorch #199166 就是只有这种情况才会暴露。
5. 机器码检查进 CI。 对关键 kernel 跑 cuobjdump -sass,检查 ACQBULK 存在,并且依赖数据的 LDG 在它之后。
6. 性能验收看端到端。 在 CUDA Graph 下,对比开关 PDL 的 decode 每 token 耗时,覆盖小、中、大几档并发。单 kernel 的提升不代表端到端的提升,中等 batch 甚至可能变慢。
7. 用问题大小做门槛,少用”某架构 + 某 kernel”的特例。 特例规则换个模型就可能反过来(SGLang #39941 → #42074)。
8. 用 CUDA Graph 的边做”PDL 覆盖率”检查。 把一个 decode step 抓成图,统计 kernel 之间 programmatic 边的比例,并列出所有普通边两端的 kernel 名字。普通边就是 PDL 链条断开的地方(中间夹了 memset、库函数、或者没开 PDL 的 kernel),这是找”下一个该优化哪里”最快的办法(5.2 节)。
9. 等待之前的预取要限量、可调。 像 CUTLASS example 63 那样,把预取量和放行时机做成参数,按端到端时间调。B300 实测,同一个预取策略在小层上快 31%,在大层上慢 28%(4.8 节)。
10. 跨 stream 和图里的高级用法要先看语义。 programmatic 事件在 eager 模式下可能没有重叠;launch completion 事件和 LaunchCompletion 端口在默认类型下不保证数据(4.6、4.7 节)。框架里如果用到,最好封装成”只允许 programmatic 类型”的接口。
flowchart TD
A{"GPU 计算能力 ≥ 9.0?"} -- 否 --> X["不加 PDL 属性<br/>没有收益,CUDA Graph 里还会多一条边"]
A -- 是 --> B{"kernel 很短,前后也是短 kernel?<br/>(几到几十 μs,如 decode)"}
B -- 否 --> Y["收益通常很小<br/>先测端到端,再决定;考虑按问题大小设门槛"]
B -- 是 --> C{"等待之前有值得提前做的事?<br/>权重、TMA 描述符、barrier 初始化"}
C -- 否 --> D["仍可开:能省一点启动空档"]
C -- 是 --> E["开"]
D --> F["检查:kernel 里有等待;依赖数据都在等待之后读;<br/>没有 __restrict__ / __ldg 读依赖数据;机器码里有 ACQBULK"]
E --> F
13. 检查清单
kernel 内部
- 用 PDL 启动的 kernel 一定调用了等待,哪怕它不读上一个 kernel 的输出
- 所有读上一个 kernel 输出的地方(包括通过指针读的标量)都在等待之后
- 等待之前读的数据,在整个推理过程中确实不会变(不是”每次新建的张量”)
- 等待之前没有写上一个 kernel 可能还在读的 buffer
- warp specialization 的 kernel 里,每种需要读依赖数据的 warp 角色都各自等待了
- 读依赖数据时没有用
__restrict__/__ldg - 自己写的内联汇编带了
::: "memory" - 没有”前一个 kernel 等后一个 kernel”的逻辑
- 等待之前的预取量有上限,并且经过实测
- Triton kernel 的等待放在循环之前,不在流水循环里
编译与启动
- 多架构编译时,设备端调用有
__CUDA_ARCH__ >= 900保护 - CUTLASS 开了
CUTLASS_ENABLE_GDC_FOR_SM90/SM100 - 启动属性只在计算能力 ≥ 9.0 时加
- 有全局关闭开关
- 自定义 PyTorch 扩展在
at::cuda::getCurrentCUDAStream()上启动 - 用了 launch completion 事件或
LaunchCompletion端口的地方,没有拿它来保证数据 - 用 Inductor 的
triton.enable_pdl时,PyTorch 版本包含 #199445、#199812 的修复
验证
- 机器码里有
ACQBULK(等待)和PREEXIT(放行) - “晚写入”正确性测试通过,包括 A → B → C(B 不读 A)的情况
- 抓图检查过边的类型,知道链条在哪里断开
- CUDA Graph 下开关 PDL 的端到端对比,覆盖小、中、大并发
- 前后相邻的是不是其他库的 kernel?是的话,确认双方都遵守”先等待再读”
14. 常见问题
Q:启动属性加在哪个 kernel 上?
加在后一个 kernel 上。它的意思是”允许我和前面那个 kernel 重叠”。
Q:前一个 kernel 放行之后写的数据,后一个 kernel 等待之后能读到吗?
能。等待会等前一个 kernel 完全结束、所有写入都可见。放行的位置只影响性能。
Q:不调用放行可以吗?
可以,结果完全正确,只是等于在每个 block 退出时才放行,重叠的空间小了。DeepGEMM 就是这样做的。B300 实测,不放行也能省下约 0.4 μs 的启动空档(4.2 节)。
Q:每个 kernel 都要支持 PDL 吗?
不用,但链条越连续越好。两个 PDL kernel 中间夹一个普通 kernel,这一段的重叠就没了。反过来,只要一个 kernel 用 PDL 启动,它就必须等待。
Q:放行要每个线程都调用吗?
不用。一个 block 里只要有一个线程调用就算这个 block 放行了(B300 实测,4.2 节),但所有 block 都要放行。
Q:前一个 kernel 是闭源库里的,改不了代码、也不会调用放行,还能重叠吗?
能,有两条路。第一,不放行本来就等于”退出时放行”,至少能藏起启动空档。第二,如果你手工建 CUDA Graph,可以用 LaunchCompletion 端口 + Programmatic 类型的边:前一个 kernel 的所有 block 一开始执行,后一个 kernel 就能启动,而且等待仍然有效(4.7 节)。但后一个 kernel 必须自己等待,也要注意它会提前占用 SM 资源。
Q:PDL 能跨 stream 用吗?
能,用 cudaLaunchAttributeProgrammaticEvent。但在 B300 上,直接在 stream 上用时我没有测到任何重叠,抓进 CUDA Graph 之后才有(4.6 节)。注意不要和 cudaLaunchAttributeLaunchCompletionEvent 搞混,后者对等待不可见。
Q:PDL 和多 stream 并行有什么区别?
多 stream 是让两个没有依赖的 kernel 同时跑。PDL 是让同一个 stream 上有依赖的相邻 kernel 把不依赖数据的部分提前。
Q:老 GPU 上开着有坏处吗?
功能上没有,属性会被静默忽略(本地已验证)。但 CUDA Graph 会多记一条依赖边,每次回放多花约 1 μs(vLLM #65059)。所以最好按架构判断后再加属性。
Q:为什么有些代码注释说”等待在放行时就返回”?
这是一个常见的误解,和官方文档、PTX 规范都不符。见 2.5 节。
Q:PDL 能让 attention 在 Q、K、V 的部分 head 算完时就开始吗?
不能。PDL 的等待是整个 grid 级别的,要等前一个 kernel 的所有 block 都结束。这正是 megakernel 工作批评它”粒度太粗”的原因,NVIDIA 的 Rubin 架构也在往 tile 级触发的方向改进(见 11.3 节)。
参考资料
官方文档
- CUDA Programming Guide,PDL 章节:https://docs.nvidia.com/cuda/cuda-programming-guide/04-special-topics/programmatic-dependent-launch.html
- CUDA Programming Guide,启动配置:https://docs.nvidia.com/cuda/cuda-programming-guide/03-advanced/advanced-host-programming.html
- CUDA Graphs(边数据):https://docs.nvidia.com/cuda/cuda-programming-guide/04-special-topics/cuda-graphs.html
- PTX ISA,
griddepcontrol:https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-griddepcontrol - CUDA Runtime API 类型(启动属性):https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__TYPES.html
- cuBLAS 补丁说明:https://docs.nvidia.com/cuda/cublas-patch-release-notes/index.html
- Triton
gdc_wait:https://triton-lang.org/main/python-api/generated/triton.language.extra.cuda.gdc_wait.html - 实测环境 NGC PyTorch 容器:https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch(
26.10-py3)
CUTLASS 官方范例
- PDL 文档:https://github.com/NVIDIA/cutlass/blob/main/media/docs/cpp/dependent_kernel_launch.md
include/cutlass/arch/grid_dependency_control.hinclude/cutlass/gemm/kernel/sm90_gemm_tma_warpspecialized_cooperative.hpp、sm100_gemm_tma_warpspecialized.hpp- example 63(权重预取):https://github.com/NVIDIA/cutlass/tree/main/examples/63_hopper_gemm_with_weight_prefetch
- example 93(低延迟 GQA):
examples/93_blackwell_low_latency_gqa/ - CuTe DSL 教程:https://github.com/NVIDIA/cutlass/blob/main/examples/python/CuTeDSL/dsl_tutorials/programmatic_dependent_launch.py
- CuTe DSL 事件教程:https://github.com/NVIDIA/cutlass/blob/main/examples/python/CuTeDSL/dsl_tutorials/launch_completion_and_programmatic_events.py
NVIDIA blog
- Llama 4 Maverick:https://developer.nvidia.com/blog/blackwell-breaks-the-1000-tps-user-barrier-with-metas-llama-4-maverick/
- Blackwell 上的 MoE 推理:https://developer.nvidia.com/blog/delivering-massive-performance-leaps-for-mixture-of-experts-inference-on-nvidia-blackwell/
- Rubin 架构:https://developer.nvidia.com/blog/inside-nvidia-rubin-gpu-architecture-powering-the-era-of-agentic-ai/
- TRT-LLM tech blog 1(DeepSeek-R1 低延迟):https://github.com/NVIDIA/TensorRT-LLM/blob/main/docs/source/blogs/tech_blog/blog01_Pushing_Latency_Boundaries_Optimizing_DeepSeek-R1_Performance_on_NVIDIA_B200_GPUs.md
框架源码
- TensorRT-LLM:
cpp/tensorrt_llm/common/envUtils.h(launchWithPdlWhenEnabled)、envUtils.cpp(getEnvEnablePDL) - FlashInfer:
flashinfer/utils.py(device_support_pdl)、include/flashinfer/norm.cuh、tests/test_helpers/pdl.py(main) - SGLang:
python/sglang/kernels/jit/include/sgl_kernel/utils.cuh(LaunchKernel::enable_pdl)、python/sglang/srt/environ.py - PyTorch:
torch/_inductor/config.py(TORCHINDUCTOR_ENABLE_PDL)、torch/_inductor/codegen/triton.py;issue #199166,修复 #199445、#199812 - Triton:#11905、#11906;
python/triton/language/extra/cuda/gdc.py - llama.cpp:
ggml/src/ggml-cuda/common.cuh - CCCL:https://github.com/NVIDIA/cccl(
_CCCL_PDL_GRID_DEPENDENCY_SYNC、CCCL_DISABLE_PDL) - XLA:
xla/debug_options_flags.cc(xla_gpu_enable_pdl) - DeepGEMM:https://github.com/deepseek-ai/DeepGEMM;DeepEP:https://github.com/deepseek-ai/DeepEP;FlashMLA:https://github.com/deepseek-ai/FlashMLA
- TileLang:
tilelang/cuda/language/pdl.py - HIPIFY:https://github.com/ROCm/HIPIFY
替代方案与论文
- Hazy Research,No Bubbles:https://hazyresearch.stanford.edu/blog/2025-05-27-no-bubbles
- Mirage Persistent Kernel:https://arxiv.org/abs/2512.22219
- Stream-K:https://arxiv.org/abs/2301.03598