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)