CUDA 流异步重叠:H2D、计算、D2H 三条流水线的时间线设计
更新时间:2026-09-29。前面 CUDA stream 异步 一篇讲了 stream 的基本概念:默认流串行、
cudaMemcpyAsync要配 pinned 内存、多流能把拷贝藏进计算。这一篇往里再走一层——不谈「是什么」,专谈「怎么设计」:三条流怎么分工、event 依赖图怎么画、双缓冲的节拍怎么对齐、两块拷贝引擎的卡上怎么把入方向和出方向也叠起来。它和 GPU 存储层次与带宽 是一对:那篇告诉你 PCIe 和 HBM 各有多快,这篇告诉你怎么让这两条总线同时处于忙的状态。
本文要回答的问题
- 三流重叠的时间线到底长什么样?填充、稳态、排空三段各占总耗时多少?
- 为什么需要 event?不用 event 的三流代码错在哪,加了
cudaStreamWaitEvent之后依赖图变成什么样? - pinned 内存在驱动层面改变了什么?同一块缓冲区 pageable 和 page-locked 走的路径差在哪?
- 有 2 个拷贝引擎的卡上,H2D 和 D2H 方向能不能也重叠?批次大小怎么选?
- 理论加速比怎么估,又怎么确认优化在真实硬件上确实发生了?
一、先画时间线:三流重叠的三段结构
做 CUDA 流异步重叠,第一件事不是写代码,而是把硬件时间线画出来。GPU 上有三类物理上独立的执行单元:入方向拷贝引擎(H2D DMA)、SM 计算阵列、出方向拷贝引擎(D2H DMA)。它们各自有自己的队列,谁先谁后完全由软件排队方式决定。把数据切成 4 批,每批 H2D 8 ms、计算 24 ms、D2H 8 ms,三条流各管一段:
这张图要读出三层信息。第一是填充段:前 8 ms 只有 H2D 引擎在干活,SM 和 D2H 都在等——这段开销无法消除,只能摊薄。第二是稳态段:从第 8 ms 起,SM 以 24 ms 为节拍连续计算,H2D 引擎在 32 ms 内就把 4 批全部送完然后彻底休息,D2H 引擎则在每个计算周期里插空工作 8 ms、闲 16 ms。第三是排空段:最后一批计算完还要 8 ms 把结果搬回来。总耗时 = 8 + 24×4 + 8 = 112 ms,而串行执行是 40×4 = 160 ms。
注意一个反直觉的点:稳态期的系统吞吐只由最慢的那一段决定。这里计算 24 ms 是瓶颈,H2D 和 D2H 加起来 16 ms,完全藏得住。如果换成预处理型负载——H2D 20 ms、计算 8 ms——瓶颈就翻到拷贝引擎上,这时候再怎么加流也没用,要改的是数据布局或压缩传输量。所以时间线设计的第一原则:先量出三段各自耗时,确认「计算段 ≥ 两个拷贝段」,重叠才有意义;否则优化方向不在流上。
二、没有 event 的三流代码是错的
看过时间线,很多人会写出这样的代码:
for (int b = 0; b < NB; ++b) {
cudaMemcpyAsync(d_in[b], h_in[b], sz, cudaMemcpyHostToDevice, h2dStream);
kernel<<<grid, block, 0, computeStream>>>(d_in[b], d_out[b]); // 危险!
cudaMemcpyAsync(h_out[b], d_out[b], sz, cudaMemcpyDeviceToHost, d2hStream);
}这段代码编译能过、跑起来结果还经常是对的——但它有真 bug。三条流之间默认没有任何顺序保证:computeStream 里的 kernel 并不等 h2dStream 里的拷贝完成,GPU 完全可能在数据还没搬完时就启动 kernel。之所以「经常是对的」,是因为拷贝通常比 CPU 循环入队快,竞态大概率不显现;换一台更慢的机器、换一批更大的数据、或者系统总线被别的进程占住,错误就会以「偶发结果错误」的形式出现——最难查的那一类 bug。
正确做法是用 event 把跨流的先后关系显式缝出来。event 是插进流里的时间点标记,cudaStreamWaitEvent 则往另一条流里排一个「等到该事件触发再继续」的节点:
cudaEvent_t h2dDone[NB], computeDone[NB];
for (int b = 0; b < NB; ++b) {
cudaEventCreate(&h2dDone[b]);
cudaEventCreate(&computeDone[b]);
}
for (int b = 0; b < NB; ++b) {
cudaMemcpyAsync(d_in[b], h_in[b], sz, cudaMemcpyHostToDevice, h2dStream);
cudaEventRecord(h2dDone[b], h2dStream); // H2D 完成时触发
cudaStreamWaitEvent(computeStream, h2dDone[b], 0); // 计算流在此等数据就绪
kernel<<<grid, block, 0, computeStream>>>(d_in[b], d_out[b]);
cudaEventRecord(computeDone[b], computeStream); // 计算完成时触发
cudaStreamWaitEvent(d2hStream, computeDone[b], 0); // D2H 流在此等结果就绪
cudaMemcpyAsync(h_out[b], d_out[b], sz, cudaMemcpyDeviceToHost, d2hStream);
}把这段代码的依赖关系画成图,它比时间线更能说明 event 的作用:
虚线就是 event 缝出来的跨流边。每条流内部仍然严格 FIFO,但流与流之间只在标了虚线的位置对齐——其余部分自由并发。这正是三流方案和「单流顺序排所有操作」的本质区别:单流是一条直线,三流加 event 是一张有向无环图,GPU 可以在图的宽度方向并行推进。
工程上几个细节值得记住。event 数量按批次建,每批两个(H2D 完成、计算完成),程序退出前 cudaEventDestroy 回收。纯同步用途的 event 用 cudaEventCreateWithFlags(&e, cudaEventDisableTiming) 创建,告诉驱动不需要走时间戳硬件路径,开销更低。还有一条硬规则:cudaStreamWaitEvent 只是往流里排队一个等待,它本身不阻塞 CPU——CPU 调用完立刻返回,可以继续排后面的操作。想阻塞 CPU 等某个事件,用的是另一个接口 cudaEventSynchronize,别搞混。
三、pinned 内存:异步 DMA 的物理前提
三流代码写对了,还有一道关:所有 cudaMemcpyAsync 涉及的主机缓冲区必须是锁页内存(pinned memory),否则重叠是假重叠。这不是性能建议,是机制问题。两条路径的差别:
上半是 pageable 内存的旅程:操作系统随时可能把 malloc 出来的页换到磁盘或挪到别的物理地址,而 DMA 引擎一旦启动就认死一个物理地址、中途无法改。驱动只能先在内部一块锁页暂存区做一次 CPU 参与的拷贝,再从暂存区发起 DMA。更要命的是,因为驱动无法保证这次代搬何时结束,对 cudaMemcpyAsync 它常常在入队前直接做一次隐式同步——你写的异步调用,实际行为和 cudaMemcpy 一样阻塞,还多付了一次 memcpy。放到三流场景里就是:H2D 流的每次入队都把 CPU 卡住进而在时间上把三条流的启动错开甚至串行化,时间线退回第二节那种「经常是对的但其实没重叠」的状态。
下半是 cudaMallocHost 分配的锁页内存:物理页常驻、地址固定,DMA 引擎拿到地址就能全速读写,调用真正入队即返回。这是 CUDA 流异步重叠能成立的物理前提,没有替代品。
代价要心里有数:锁页内存不可换出,钉得太多会挤压系统其余部分的可用内存;分配和释放也比 malloc 慢一个数量级以上。所以实践模式固定为——程序启动时按批次一次性申请好 pinned 缓冲池,运行期反复复用,退出时统一 cudaFreeHost,绝不在热路径上分配。每批需要两块独立缓冲(输入、输出),批次数 N 就是 2N 块;想再省可以复用,但复用就要引入额外的 event 等待来保证「上一批的 D2H 读完了才能填下一批数据」,换来的内存节省通常不值这份复杂度。
四、双拷贝引擎与双缓冲:把重叠做到头
cudaDeviceProp 里的 asyncEngineCount 告诉你卡上有几个拷贝引擎。消费级卡通常是 1,此时 H2D 和 D2H 共用一台 DMA,两个方向的传输互相串行——第一节的时间线在 D2H 行要修正为「D2H 必须等同一时刻没有 H2D 在进行」。数据中心卡(A100、H100 一档)一般是 2,入方向出方向各一台,可以一边搬进一边搬出。1 引擎和 2 引擎的卡上,同一份三流代码的稳态时间线不同:
| 维度 | 1 个拷贝引擎(消费卡常见) | 2 个拷贝引擎(数据中心卡) |
|---|---|---|
| H2D 与 D2H 能否同时进行 | 不能,共用一台 DMA 互斥 | 能,方向各一台 |
| 拷贝段可藏上限 | H2D+D2H 之和 ≤ 计算段 | 各自 ≤ 计算段即可 |
| 适合藏掉的拷贝占比 | 较小,两段要排队 | 大一倍,双向各自排 |
| 批次大小下限 | 受双向争用影响,宜更大 | 可以更小、批次更多 |
| 代码是否要改 | 不用改,重叠度自动受限 | 不用改,硬件自动并行 |
好消息是代码一份通用,硬件决定实际重叠度;坏消息是你必须知道自己跑在哪种卡上,否则加速比预估会偏乐观。查询就一行:cudaDeviceGetAttribute(&n, cudaDevAttrAsyncEngineCount, dev)。
另一个把重叠做到头的手段是双缓冲(double buffering):不为每批准备独立缓冲,而是准备两套,第 N 批用 A 套、第 N+1 批用 B 套、第 N+2 批又回到 A 套。它的用武之地是数据量超大、显存放不下全部批次的场景——比如逐块处理一个比显存大十倍的矩阵。双缓冲的稳态节拍:
关键在「H2D→A(覆盖第 1 批)」这一格:往 A 缓冲写第 3 批数据之前,必须保证第 1 批的 D2H 已经从 A 读完了。这个跨周期依赖又是 event 的活——每套缓冲配一个「D2H 完成」事件,下一轮 H2D 入队前先 cudaStreamWaitEvent 等它。双缓冲把显存占用从「全部批次」压到「两套缓冲」,代价是依赖图多了一圈回边,节拍一旦错一拍就是数据踩踏。所以它的出场顺序在独立缓冲之后:先用多批次独立缓冲把流水线调通,确认显存真的装不下了,再上双缓冲。
批次大小怎么定?两个下界一个上界。下界一:单批传输时间要远大于拷贝的固定启动开销(每次 DMA 约几微秒),否则带宽跑不起来,一般单批至少几百 KB 到几 MB。下界二:批次总数要足够多,让填充和排空占比可忽略——经验上 N ≥ 8 之后边际收益就很小了。上界:单批显存占用 × 批次数不能超过显存预算,且单批 kernel 的 grid 要足够大让 SM 吃饱。实际做法是从「总数据量 / 8 批」起步,用 Nsight Systems 看时间线,往两头各试一档,选拷贝块和计算块咬合最紧的那档。
五、三个最常见的翻车现场
把三流重叠从样例搬进真实项目,最容易栽的是下面三处,按出现频率排序。
翻车一:缓冲复用没有等。 为了省显存,第 N+2 批复用第 N 批的设备缓冲,却忘了在 H2D 入队前等第 N 批的 kernel 读完这块缓冲。症状是结果偶发错误、和小数据量时完全正常。修法就是第四节说的回边 event:每块复用缓冲配一个「上一位使用者已读完」事件,写入方先 cudaStreamWaitEvent 再拷贝。
翻车二:默认流搅局。 代码里三流都建好了,但某处漏传流参数——比如一个忘记加第四个参数的 <<<>>> 启动,或一次 cudaMemset 没写流——这个操作就落进了默认流。若编译时没开 --default-stream per-thread,默认流会和设备上所有流做隐式双向同步,整条流水线在它前后被拦腰截断。排查方法:全项目搜一遍所有 CUDA 调用,确认每个都显式带流;或者干脆编译时加上 per-thread 选项,让默认流退化成普通流。
翻车三:event 等出了死循环般的全串行。 和第 N 批相关的等待写错了对象——比如 cudaStreamWaitEvent(h2dStream, computeDone[b]) 把等待放进了 H2D 流自己,于是第 N+1 批的拷贝必须等第 N 批全部算完,流水线退化成单流串行。症状是程序结果完全正确但 profiler 里三条行首尾相接、毫无重叠。这类 bug 不伤正确性只伤性能,不看时间线根本发现不了,这正是下一节强调实测的原因。
六、估算加速比,再用 profiler 证真
理论加速比一笔账就能算清。设每批 H2D、计算、D2H 耗时为 h、c、d,共 N 批。串行总耗时 N(h+c+d);三流重叠后,若 c 是瓶颈,总耗时约 h + N·c + d。加速比:
$$S = \frac{N(h+c+d)}{h + Nc + d} \xrightarrow{N\to\infty} \frac{h+c+d}{c} = 1 + \frac{h+d}{c}$$
结论就一条:稳态加速比 = 1 + 可藏拷贝时间 / 计算时间。h+d 占 c 的 20%,天花板就是 1.2 倍;拷贝和计算一样长,才够到 2 倍。这个公式同时告诉你什么时候别做这项优化——c 远大于 h+d 时(kernel 一次算几百毫秒、拷贝几毫秒),折腾多流纯属给自己加 bug 面。
估完之后必须实测证真,因为纸面模型漏掉了一堆真实世界的摩擦:1 引擎卡上 H2D/D2H 互斥、kernel 占满 SM 时跨流 kernel 无法并发、驱动隐式同步、批次太小带宽跑不满。标准验证流程:
- 开 Nsight Systems(
nsys profile ./app),看 GPU 时间线视图; - 确认 Memcpy(H2D)行、Compute 行、Memcpy(D2H)行在时间轴上真的重叠,而不是首尾相接;
- 若没重叠,按嫌疑顺序排查:主机缓冲是不是 pinned → 是不是误用了默认流(老版默认流会和所有流隐式同步,
--default-stream per-thread或全用显式流)→ event 等待是不是放错了流 → 拷贝引擎数是不是只有 1; - 用
cudaEventElapsedTime在关键 kernel 前后打点,确认单批耗时没有因为并发争抢而变长太多——重叠换来吞吐,单批延迟略升是正常的,但单批变慢超过拷贝段的量级就说明资源争抢过烈,该减流或调批次。
还有一个容易漏的检查点:CPU 侧。三流流水线假定 CPU 能源源不断地准备数据和入队,如果 CPU 准备一批数据就要 30 ms,那整条流水线的瓶颈根本不在 GPU。Nsight 里看 CPU 线程行,如果入队间隔比 GPU 节拍长,先优化主机侧的数据准备——比如把预处理挪到另一个 CPU 线程,和 GPU 流水线并行。
这一篇在知识体系里的位置
本篇是 GPU 数据移动专题的「工程设计」篇。概念层的前置是 CUDA stream 异步(stream、pinned、event 是什么);带宽数字的背景在 GPU 存储层次与带宽;不想手写这套流水线时的替代路线是 CUDA 统一内存,用页迁移换编程简单性。往底层走,SM 为什么能和拷贝引擎真正并行、warp 调度如何决定 kernel 并发驻留,见 GPU 架构深入:SIMT、warp 调度;往应用走,训练框架的 prefetch、推理服务的连续 batching,都是本篇这张三流时间线的工业化封装。
总结
CUDA 流异步重叠的本质是把 H2D、kernel、D2H 拆到三条流上,让三台独立的硬件单元并行干活:先用 event 和 cudaStreamWaitEvent 把跨流数据依赖缝成有向无环图(缺了它三流代码有真 bug),再用 cudaMallocHost 的锁页内存保证异步 DMA 不退化成同步,批次按「计算段 ≥ 两拷贝段」设计,双拷贝引擎的卡上连进出方向也能叠起来——稳态加速比上限是 1 + (h+d)/c,最后用 Nsight Systems 的时间线证真实重叠,而不是凭代码结构自我感觉良好。