CUDA流与计算传输重叠
CPU与GPU的交互机制
前文介绍了核函数在GPU内部的执行流程,但忽略了CPU与GPU之间的交互过程。本节对该过程进行补充。
两个引擎
CPU与GPU之间交互时涉及两个引擎:
| 引擎 | 职责 | 类比 |
|---|---|---|
| 内存复制引擎 | CPU与GPU之间的数据传输 | 物流队列 |
| 核函数执行引擎 | CPU向GPU部署核函数任务 | 生产队列 |
┌─────────┐ ┌─────────────────────────┐
│ CPU │ ──────→ │ 内存复制引擎(H2D/D2H) │ ──→ GPU显存
│ │ └─────────────────────────┘
│ │ ┌─────────────────────────┐
│ │ ──────→ │ 核函数执行引擎 │ ──→ GPU SM
└─────────┘ └─────────────────────────┘两个引擎可以理解为任务队列,CPU将任务添加到不同的队列中,GPU驱动程序负责执行队列中的任务。这两个队列是相互独立的,可以并发运行——即GPU在执行核函数时,可以同时进行CPU与GPU之间的数据传输。这就是所谓的计算与传输重叠(Overlap)。
通过 cudaGetDeviceProperties() 函数查看GPU的 deviceOverlap 属性可以判断该GPU是否支持计算与传输重叠功能。
CUDA流(Stream)
基本概念
流可以理解为一系列异步的GPU操作,这些操作按照主机代码确定的顺序在GPU上执行。
Stream 0: [H2D传输] → [kernel执行] → [D2H传输]
按顺序执行,前一个完成后才执行下一个
Stream 1: [H2D传输] → [kernel执行] → [D2H传输]
独立于Stream 0,可以同时执行利用流实现计算与传输重叠
以3个CUDA流为例,基本思路为:
cpp code block
// 1. 创建3个流
cudaStream_t streams[3];
for (int i = 0; i < 3; i++) {
cudaStreamCreate(&streams[i]);
}
// 2. 在3个流上异步传输数据(H2D)
for (int i = 0; i < 3; i++) {
cudaMemcpyAsync(d_input[i], h_input[i], size,
cudaMemcpyHostToDevice, streams[i]);
}
// 3. 在3个流上执行核函数
for (int i = 0; i < 3; i++) {
my_kernel<<<grid, block, 0, streams[i]>>>(d_input[i], d_output[i]);
}
// 4. 在3个流上异步传回数据(D2H)
for (int i = 0; i < 3; i++) {
cudaMemcpyAsync(h_output[i], d_output[i], size,
cudaMemcpyDeviceToHost, streams[i]);
}
// 5. 同步所有流
for (int i = 0; i < 3; i++) {
cudaStreamSynchronize(streams[i]);
}
// 或者:cudaDeviceSynchronize();
// 6. 销毁流
for (int i = 0; i < 3; i++) {
cudaStreamDestroy(streams[i]);
}重叠的时间线
时间 →
Stream 0: │ H2D │ kernel │ D2H │
Stream 1: │ │ H2D │ kernel │ D2H │
Stream 2: │ │ │ H2D │ kernel │ D2H │
↑ ↑
kernel和H2D重叠 kernel和H2D/D2H重叠
内存复制的执行时间被尽可能地隐藏到核函数的计算时间之中注意事项
① 主机内存必须是固定内存
cpp code block
// ❌ 普通内存,不能用于异步传输
float* h_data = (float*)malloc(size);
// ✅ 固定内存,可以用于异步传输
float* h_data;
cudaMallocHost(&h_data, size); // 或 cudaHostAlloc② 同一个stream内不能实现计算与传输重叠
原因:同一个流中计算需要的数据依赖于传输的数据
如果传输没有完成就开始计算,数据就是错误的
Stream 0: [H2D] → [kernel] → [D2H]
↑ ↑
└────────┘
kernel必须等H2D完成,不能重叠
只能重叠不同流中的传输与计算③ 传输与计算会争抢显存带宽
Stream 1: │ kernel │
Stream 2: │ H2D │
↑ 两者同时进行时争抢显存带宽
效率比单独运行时低,但显存带宽利用率最大
降低比率与各自的显存带宽占用率有关Hyper-Q技术
背景:虚假依赖问题
在没有Hyper-Q技术之前,CPU和GPU之间只有1个工作队列(包含1个内存复制引擎和1个核函数执行引擎),所有流共用这个工作队列。
此时如果采用深度优先的方式组织流操作,会产生虚假依赖:
深度优先(无Hyper-Q时有问题):
Stream 0: [H2D] [kernel] [D2H]
Stream 1: [H2D] [kernel] [D2H]
Stream 2: [H2D] [kernel] [D2H]
实际执行(单一队列):
│ S0:H2D │ S0:kernel │ S0:D2H │ S1:H2D │ S1:kernel │ ...
↑
Stream 1必须等Stream 0全部完成才能开始
→ 没有重叠,性能差虚假依赖是指在单一工作队列上,后面的流会等待前面的流完成,重叠只能发生在流的边缘。
解决方案:宽度优先
无Hyper-Q时,必须采用宽度优先的方式组织流操作:
cpp code block
// 宽度优先:相同操作在不同流上相邻执行
for (int i = 0; i < streamNum; i++) {
cudaMemcpyAsync(..., streams[i]); // 所有流的H2D
}
for (int i = 0; i < streamNum; i++) {
kernel<<<..., streams[i]>>>(); // 所有流的kernel
}
for (int i = 0; i < streamNum; i++) {
cudaMemcpyAsync(..., streams[i]); // 所有流的D2H
}宽度优先(无Hyper-Q时正确):
执行顺序:S0:H2D, S1:H2D, S2:H2D, S0:kernel, S1:kernel, S2:kernel, ...
时间线:
│ S0:H2D │ S1:H2D │ S2:H2D │ S0:kernel │ S1:kernel │ S2:kernel │
↑ ↑
H2D之间可以重叠 kernel之间可以重叠Hyper-Q的改进
从Kepler架构开始,引入了Hyper-Q技术:
无Hyper-Q:
CPU ←→ GPU之间只有1个工作队列
所有流共用 → 虚假依赖
有Hyper-Q(Kepler及以后):
CPU ←→ GPU之间最多32个工作队列
每个流分配一个工作队列 → 无虚假依赖
(超过32个流时,多个流共用一个队列)Hyper-Q带来的改变:可以采用深度优先
cpp code block
// 深度优先(有Hyper-Q时可以)
for (int i = 0; i < streamNum; i++) {
cudaMemcpyAsync(..., streams[i]);
kernel<<<..., streams[i]>>>();
cudaMemcpyAsync(..., streams[i]);
}深度优先(有Hyper-Q时):
每个流有独立的工作队列,无虚假依赖
Stream 0: [H2D] [kernel] [D2H]
Stream 1: [H2D] [kernel] [D2H]
Stream 2: [H2D] [kernel] [D2H]
时间线:
│ S0:H2D │ S0:kernel │ S0:D2H │
│ S1:H2D │ S1:kernel │ S1:D2H │
│ S2:H2D │ S2:kernel │ S2:D2H │
↑
不同流的kernel可以真正并行执行Hyper-Q的另一功能:计算与计算重叠
Hyper-Q不仅让传输与计算重叠,还让不同stream中的计算也能重叠:
Stream 1的kernel:占用30%核心 + 50%带宽
Stream 2的kernel:占用80%核心 + 60%带宽
单独运行:各自用各自的资源
同时运行:争用GPU资源,按比例分配
核心思想:当一个stream没有占满GPU资源时
再运行另一个stream的任务
最大化GPU资源利用率阻塞流与非阻塞流
默认流(空流)
默认流 = 空流 = 隐式流
特点:
· 不需要创建,自动存在
· 使用 kernel<<<blocks, threads>>>() 启动的kernel在默认流上
· 与所有阻塞流同步阻塞流
cudaStreamCreate() 创建的流是阻塞流
阻塞流会被默认流阻塞:
kernel1<<<1, 1, 0, stream1>>>(); // 阻塞流
kernel2<<<1, 1>>>(); // 默认流
kernel3<<<1, 1, 0, stream2>>>(); // 阻塞流
执行顺序:
kernel1 → kernel2 → kernel3(串行!)
原因:默认流会等待所有阻塞流完成
阻塞流也会等待默认流完成
→ 形成隐式同步非阻塞流
cpp code block
// 创建非阻塞流
cudaStream_t stream;
cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking);非阻塞流不受默认流阻塞:
kernel1<<<1, 1, 0, stream1>>>(); // 非阻塞流
kernel2<<<1, 1>>>(); // 默认流
kernel3<<<1, 1, 0, stream2>>>(); // 非阻塞流
执行顺序:
· 有Hyper-Q:kernel1和kernel3可以并发执行
· 无Hyper-Q:kernel1和kernel3仍然串行(单一队列)对比总结
| 流类型 | 创建方式 | 被默认流阻塞 | 其他流阻塞 |
|---|---|---|---|
| 默认流 | 隐式存在 | - | 阻塞所有阻塞流 |
| 阻塞流 | cudaStreamCreate() | ✅ 是 | 串行(单队列)或并行(Hyper-Q) |
| 非阻塞流 | cudaStreamCreateWithFlags(..., cudaStreamNonBlocking) | ❌ 否 | 并行(有Hyper-Q) |