AI Infra

CUDA 编程初探:从线程与内存模型,到第一个实用 Kernel

2026-09-29 #cuda 编程

cuda

写一个 CPU 版本的向量加法,只需要一个循环:逐个取出两个数组里的元素,相加,再写回结果。如果数组里有上千万个元素,而且每次加法互不依赖,能不能让大量线程一起做这件事?

CUDA 提供了这样的编程方式。不过,把循环搬到 GPU 上,还需要回答几个问题:每个线程负责哪个元素?输入数据存在哪里?CPU 什么时候能读取结果?GPU 计算很快,为什么整个程序却不一定更快?

这篇文章基于 AIInfraGuide 的四篇入门教程整理:开发环境搭建、编程模型、内存模型、第一个实用 Kernel。正文用 vector_add.cu 串起完整流程,最后结合四份练习代码继续理解规约、SAXPY、Grid-stride Loop 和异步传输。

代码文件 在本文中的用途 主要知识点
vector_add.cu 正文案例 线程索引、显存管理、结果校验与计时
dot_product.cu 练习一 共享内存、块内同步、树形规约
saxpy.cu 练习二 原地更新、独立输入副本、浮点误差
grid_stride_loop.cu 练习三 一个线程处理多个元素
async_overlap.cu 练习四 锁页内存、Stream、异步与重叠的区别

本文面向具备基本 C/C++ 数组、指针和循环知识的读者。文中的代码分析来自上述五份源码;没有附带 GPU 实测记录,因此不把教程中的参考耗时写成本人的实验结果。

1. 四篇教程可以串成怎样一条学习路线?

这四篇教程依次回答了四个问题:

教程 核心问题 在本文中的落点
开发环境搭建 怎么编译、运行 GPU 程序? 区分驱动、Toolkit、主机编译器
编程模型 怎样把工作分给大量线程? Grid、Block、Thread、Warp 与索引
内存模型 数据放在哪里,线程怎样协作? 全局内存、共享内存、寄存器与访存模式
第一个实用 Kernel 怎样完成一次可靠的 GPU 计算? 向量加法、错误检查、验证与性能分析

学习时可以先把向量加法跑通,再带着代码回看线程和内存模型。例如,blockIdx.x 不再只是一个需要背下来的变量,而是定位当前线程任务的工具;cudaMemcpy 也不只是固定模板,而是 CPU 与 GPU 之间的数据流动。

教程中的部分说法需要结合条件理解:32 的倍数是常见的 Block 大小选择建议;使用 cudaMemcpyAsync 并不自动产生传输与计算重叠;不同架构的内存容量、延迟和事务粒度也不能套用同一张固定数字表。后文会在对应位置说明这些边界。

2. CUDA 程序由 CPU 和 GPU 一起完成

CUDA 是 NVIDIA 提供的并行计算平台和编程模型。本文使用 CUDA C++:在 C++ 的基础上,通过函数修饰符、启动语法和运行时 API 描述 GPU 上的工作。

在一个典型程序中:

  • Host(主机) 通常指 CPU 一侧,负责准备输入、分配内存、提交任务和处理结果。
  • Device(设备) 通常指 GPU 一侧,负责执行大量并行线程。
  • Kernel(核函数) 是在 GPU 上执行的函数。同一次启动中,许多线程执行这份函数代码,并通过自己的线程编号处理不同数据。

对于本文使用的独立 GPU 和显式内存拷贝方式,完整流程如下:

mermaid

GPU 适合执行大量结构相似、能够并行的工作。CPU 仍然承担控制逻辑,任务提交和数据传输也有成本。判断 GPU 是否值得使用,需要把这些环节一起考虑。

3. 先把开发环境的几层关系分清楚

3.1 驱动、Toolkit 和主机编译器

组件 作用 常用检查方式
NVIDIA 驱动 让操作系统和 CUDA 程序访问 GPU nvidia-smi
CUDA Toolkit 提供 nvcc、头文件、CUDA Runtime、开发库等 nvcc --version
主机 C++ 编译器 编译 .cu 文件中的 CPU 代码 Linux 常用 GCC;Windows 常用 MSVC

nvidia-smi 中的 CUDA Version 表示驱动支持的 CUDA 版本信息,不能用来判断本机装了哪个 Toolkit。即使没有安装 nvcc,驱动也可能正常显示这个字段。

nvcc --version 才用于查看当前命令路径对应的 CUDA 编译工具版本。安装多个 Toolkit 时,还需要检查当前命中的路径。

新版驱动支持旧版 CUDA 应用通常称为向后兼容。实际选择版本时应查看 NVIDIA 的兼容性文档和该 Toolkit 的发布说明;小版本兼容及特定前向兼容机制各有条件,不能只凭两个版本号是否完全相同作判断。

3.2 Windows 与 Linux 上怎样准备

Windows 上可以按以下顺序准备:

  1. 安装支持目标 GPU 的 NVIDIA 驱动。
  2. 安装所选 Toolkit 支持的 Visual Studio / Build Tools,并包含 C++ 桌面开发组件和 Windows SDK。
  3. 安装 CUDA Toolkit,确认其 bin 目录可被命令行找到。
  4. 在配置好 MSVC 环境的 x64 开发者终端中运行 nvidia-smi、nvcc --version 和编译命令。

PowerShell 中可用 Get-Command nvcc 查看命中的编译器路径。如果 nvcc 提示找不到 cl.exe,需要先检查 MSVC 组件和开发者终端环境。

Linux 上同样需要驱动、Toolkit 和受支持的主机编译器。优先按发行版及 NVIDIA 官方安装指南配置软件源和软件包,确认 nvcc 所在目录进入 PATH;动态库路径按实际安装方式配置。教程里的具体版本号和安装命令是示例,使用时要与自己的系统对应。

3.3 编译一份 .cu 文件

nvcc 会协调主机代码与设备代码的编译,最终得到可执行程序。下面的命令应在五份源码所在目录执行。

Linux:

1
2
nvcc -O3 -std=c++17 -lineinfo vector_add.cu -o vector_add
./vector_add

Windows 开发者终端:

1
2
nvcc -O3 -std=c++17 -lineinfo -Xcompiler /O2 vector_add.cu -o vector_add.exe
.\vector_add.exe

这里 -O3 请求优化,-std=c++17 指定语言标准,-lineinfo 保留用于性能分析的设备代码行号;Windows 示例显式向 MSVC 传递 /O2。比较 CPU 与 GPU 时,也应确认主机代码使用了合理的优化选项。

正式测量前,应按 GPU 的计算能力指定目标架构。例如 RTX 4090 对应 -arch=sm_89,但这个参数不能照搬到所有显卡,Toolkit 也必须支持所选架构。-G 用于设备代码调试,会影响优化,不适合用于性能对比。

4. 编程模型:把数组下标分配给线程

4.1 Grid、Block 和 Thread

CUDA 将一次 Kernel 启动中的线程组织成层次结构:

1
2
3
4
5
6
7
8
9
一次 Kernel 启动对应一个 Grid
├── Block 0
│ ├── Thread 0
│ ├── Thread 1
│ └── ...
├── Block 1
│ ├── Thread 0
│ └── ...
└── ...

kernel_grid_block_thread

Thread 是处理数据的执行实例,Block 是线程协作的基本单位,Grid 是这次启动中所有 Block 的集合。

同一个 Block 中的线程可以通过共享内存交换数据,并使用 __syncthreads() 做块内同步。普通 Kernel 中,不同 Block 的执行顺序没有保证,也不能用 __syncthreads() 实现整个 Grid 的同步。

GPU 上的 SM(Streaming Multiprocessor,流式多处理器)承载这些工作。一个普通 Block 的线程在同一个 SM 上执行,一个 SM 可以同时驻留多个 Block,具体数量受线程数、寄存器和共享内存等资源限制。启动的所有 Block 不需要同时驻留。

4.2 四个内置变量与一个索引公式

对一维数组,最常见的变量是:

变量 含义
threadIdx.x 当前线程在 Block 内的编号
blockIdx.x 当前 Block 在 Grid 内的编号
blockDim.x 每个 Block 的线程数
gridDim.x Grid 中的 Block 数

全局索引为:

1
int idx = blockIdx.x * blockDim.x + threadIdx.x;

例如,每个 Block 有 256 个线程,blockIdx.x = 3、threadIdx.x = 5,则 idx = 3 × 256 + 5 = 773,这个线程可以处理数组的第 773 号元素。这里编号从 0 开始。

若数组长度 N = 1000:

1
2
int blockSize = 256;
int gridSize = (N + blockSize - 1) / blockSize; // 向上取整,得到 4

实际启动 1024 个线程,编号 1000~1023 的线程没有有效任务。因此需要 if (idx < N),防止它们访问数组外的地址。

4.3 Kernel 的修饰符与启动语法

修饰符 执行位置 常见用途
__global__ GPU 从主机启动的 Kernel 入口,返回类型为 void
__device__ GPU 供设备代码调用的辅助函数
__host__ CPU 主机函数;普通 C++ 函数默认如此

函数也可以同时使用 __host__ __device__,分别生成供 CPU 和 GPU 调用的版本。这里先讨论从 CPU 启动 Kernel 的常用方式。

1
kernel<<<grid, block, sharedMemBytes, stream>>>(args...);

前两个参数决定 Block 数和每个 Block 的线程布局;第三个参数指定每个 Block 的动态共享内存字节数;第四个参数指定执行流。后两个参数可以省略,默认分别为 0 和默认 Stream。

Kernel 启动通常对主机是异步的:CPU 提交任务后可以继续执行。提交完成不代表 GPU 已经算完,读取结果前需要通过合适的拷贝、事件或同步操作建立完成关系。

4.4 Warp 与 Block 大小

当前 NVIDIA CUDA GPU 的一个 Warp 包含 32 个线程,是硬件组织和调度线程指令的重要单位。256 个线程的 Block 对应 8 个 Warp。

把 Block 大小设成 32 的倍数通常更容易充分利用 Warp,但这是性能建议。合法的 100 线程 Block 也可以运行,它会占用 4 个 Warp,最后一个 Warp 只有 4 个有效线程。

同一个 Warp 中的线程如果走向不同分支,执行效率可能下降;不同 Warp 走不同分支不会产生同一种 Warp 内分歧。现代架构支持独立线程调度,涉及线程间通信时仍应使用正确的同步原语,不能假定线程会按源码逐行自动同步。

入门时可以从 256 个线程开始。之后再根据实际 GPU 和 Kernel 尝试 128、256、512 等配置。最大 Block 线程数应通过设备属性查询,常见设备的上限为 1024,还要满足各维度及 Kernel 资源约束。

Occupancy(占用率)描述 SM 上活跃 Warp 数相对硬件上限的比例。它能帮助理解延迟隐藏能力,但更高的 Occupancy 不必然带来更低的耗时,相关 API 也不能直接给出所有 Kernel 的最快配置。

4.5 从一维数组扩展到矩阵

对于按行存储的二维矩阵,可以这样计算位置:

1
2
3
4
5
6
int col = blockIdx.x * blockDim.x + threadIdx.x;
int row = blockIdx.y * blockDim.y + threadIdx.y;
if (row < height && col < width) {
int idx = row * width + col;
// 处理 idx 对应的矩阵元素
}

dim3 block(16, 16) 表示每个 Block 有 16 × 16 = 256 个线程。二维组织便于表达问题,但最终访问的数组仍然是按某种布局线性存储的。

5. 内存模型:数据放在哪里,怎样访问更合适?

5.1 先掌握几类常用存储

存储类型 作用范围与位置 适合存放什么 需要注意什么
寄存器 线程私有,位于 SM 上 索引、临时变量、局部累加器 分配由编译器决定;用量影响驻留线程数
Local Memory 线程私有的地址空间,通常由设备内存承载 溢出的寄存器值、部分局部数组等 名称中的 Local 不代表片上高速存储
Shared Memory 通常由同一个 Block 的线程共享,位于 SM 上 块内交换的数据、复用的分块数据 需要正确同步;用量影响可驻留 Block 数
Global Memory GPU 可访问的全局地址空间,通常由显存承载 输入输出数组、中间结果 关注访问模式、带宽和访问量
Constant Memory 设备代码只读,带专用缓存 Warp 内线程经常读取的相同常量 同一次读取中的不同地址会拆分处理

L1、L2 是硬件管理的缓存。全局内存背后的显存可能是 GDDR,也可能是 HBM,不能把 Global Memory 与 HBM 直接画等号。具体容量、延迟和缓存组织随架构变化。

此外,还有三个容易混淆的概念:

  • Pinned Memory(锁页内存):位于 CPU 一侧,使用 cudaMallocHost 等方式分配,适合显式主机与设备异步传输;它本身不是显存。
  • Unified Memory(统一内存):例如通过 cudaMallocManaged 分配,由运行时和系统管理 CPU/GPU 访问及必要的数据迁移;它不是另一层固定速度的物理存储,也不意味着没有传输成本。
  • 纹理访问:通过纹理对象等机制访问数据,可提供采样、寻址和插值功能,适合某些图像处理任务;本文的向量计算暂时不需要它。

统一内存的实际访问与迁移行为依赖平台和设备能力。它能简化编程,但是否更快仍需结合访问方式判断。

5.2 合并访问:看同一时刻相邻线程访问哪里

向量加法中,相邻线程访问相邻元素:

1
2
3
线程编号:  0       1       2       3      ...     31
读取 A: A[0] A[1] A[2] A[3] ... A[31]
写入 C: C[0] C[1] C[2] C[3] ... C[31]

一个 Warp 的 32 个线程读取 32 个连续 float,总计 128 字节。在地址对齐合适时,GPU 可以通过较少的内存事务完成访问。

在现代 GPU 上,分析全局内存访问时经常以 32 字节扇区为单位:这 128 字节可以覆盖 4 个扇区。具体事务和缓存行为取决于架构及指令,因此不宜把“连续访问”一概说成“永远只发出一次 128 字节事务”。

如果改成 A[idx * 32],同一个 Warp 访问的地址变得分散,读取的数据中可能只有少部分真正被使用,通常会降低访存效率。

5.3 共享内存需要有明确用途

向量加法的每个输入元素只用一次,也不需要把值传给其他线程。先搬到共享内存再相加,通常只会增加额外操作。

共享内存更适合两类任务:一是多个线程需要交换数据,例如点积中的块内求和;二是同一批数据会被反复使用,例如矩阵乘法中的分块计算(Tiling)。

使用共享内存时还要关注 Bank Conflict。在常见的 32 位访问模式下,不同线程访问同一 Bank 中的不同地址可能引起冲突,而读取同一地址可以广播。矩阵转置中常见的 tile[32][33],就是通过额外的一列改变列访问的 Bank 映射。

5.4 同步不能被边界条件随意跳过

线程写入共享内存后,如果其他线程接下来要读取这些值,就需要适当的同步。

初学时应避免把 __syncthreads() 放入一个只有部分线程会进入的 if (idx < N) 分支。原内存教程中的静态共享内存示例存在这种边界风险;尾块中还可能读取未初始化的共享内存元素。

对于求和规约,更稳妥的模式是让无有效输入的线程写入加法的单位元 0,再让整个 Block 一起到达屏障:

1
2
3
// 假设 tile 的容量与当前 Block 配置匹配
tile[threadIdx.x] = (idx < N) ? input[idx] : 0.0f;
__syncthreads();

这样尾块也有明确定义。后面的点积练习正好展示了这个模式。

6. 第一个实用 Kernel:向量加法

目标是计算:

C[i]=A[i]+B[i],0≤i<N.

CPU 的写法是一个循环:

1
2
3
4
5
void vectorAddCPU(const float* A, const float* B, float* C, int N) {
for (int i = 0; i < N; ++i) {
C[i] = A[i] + B[i];
}
}

vector_add.cu 中的 GPU Kernel 则让每个线程负责一个元素:

1
2
3
4
5
6
__global__ void vectorAdd(const float* A, const float* B, float* C, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < N) {
C[idx] = A[idx] + B[idx];
}
}

这里每个输出位置只有一个线程写入,线程间没有数据依赖,因此无需共享内存、原子操作或块内同步。

6.1 主机端需要做什么?

五份代码都采用 h_ 和 d_ 前缀区分主机和设备指针。前缀只是命名约定,真正决定内存位置的是分配方式。

核心步骤可以写成:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 片段:假设输入已初始化,CUDA_CHECK 已定义
size_t bytes = static_cast<size_t>(N) * sizeof(float);
float *d_A, *d_B, *d_C;
CUDA_CHECK(cudaMalloc(&d_A, bytes));
CUDA_CHECK(cudaMalloc(&d_B, bytes));
CUDA_CHECK(cudaMalloc(&d_C, bytes));

CUDA_CHECK(cudaMemcpy(d_A, h_A, bytes, cudaMemcpyHostToDevice));
CUDA_CHECK(cudaMemcpy(d_B, h_B, bytes, cudaMemcpyHostToDevice));

int blockSize = 256;
int gridSize = (N + blockSize - 1) / blockSize;
vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
CUDA_CHECK(cudaGetLastError());

CUDA_CHECK(cudaMemcpy(h_C, d_C, bytes, cudaMemcpyDeviceToHost));

CUDA_CHECK(cudaFree(d_A));
CUDA_CHECK(cudaFree(d_B));
CUDA_CHECK(cudaFree(d_C));

在这个同一默认 Stream 中的执行序列里,回传结果的阻塞式 D2H 拷贝完成后,CPU 才读取 h_C。如果之后使用多个 Stream,则需要重新明确各项操作之间的依赖。

6.2 一份便于独立理解的完整版本

下面是根据 vector_add.cu 整理的精简教学版本,保留分配、传输、启动、错误检查与校验,计时在下一节单独讨论。它不是原文件的逐字复制。

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#include <cuda_runtime.h>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>

#define CUDA_CHECK(call) \
do { \
cudaError_t err = (call); \
if (err != cudaSuccess) { \
std::fprintf(stderr, "CUDA error at %s:%d: %s\n", \
__FILE__, __LINE__, cudaGetErrorString(err)); \
std::exit(EXIT_FAILURE); \
} \
} while (0)

__global__ void vectorAdd(const float* A, const float* B, float* C, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < N) {
C[idx] = A[idx] + B[idx];
}
}

int main() {
const int N = 1 << 24;
const size_t bytes = static_cast<size_t>(N) * sizeof(float);
std::vector<float> h_A(N), h_B(N), h_C(N);

for (int i = 0; i < N; ++i) {
h_A[i] = std::sin(i * 0.001f);
h_B[i] = std::cos(i * 0.001f);
}

float *d_A, *d_B, *d_C;
CUDA_CHECK(cudaMalloc(&d_A, bytes));
CUDA_CHECK(cudaMalloc(&d_B, bytes));
CUDA_CHECK(cudaMalloc(&d_C, bytes));
CUDA_CHECK(cudaMemcpy(d_A, h_A.data(), bytes, cudaMemcpyHostToDevice));
CUDA_CHECK(cudaMemcpy(d_B, h_B.data(), bytes, cudaMemcpyHostToDevice));

const int blockSize = 256;
const int gridSize = (N + blockSize - 1) / blockSize;
vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
CUDA_CHECK(cudaGetLastError());
CUDA_CHECK(cudaMemcpy(h_C.data(), d_C, bytes, cudaMemcpyDeviceToHost));

int errors = 0;
double maxError = 0.0;
for (int i = 0; i < N; ++i) {
double ref = static_cast<double>(h_A[i]) + h_B[i];
double diff = std::fabs(static_cast<double>(h_C[i]) - ref);
bool finite = std::isfinite(h_C[i]);
if (!finite || diff > 1e-5) {
++errors;
}
if (finite && diff > maxError) {
maxError = diff;
}
}
std::printf("%s: mismatches=%d, max finite error=%g\n",
errors == 0 ? "PASS" : "FAIL", errors, maxError);

CUDA_CHECK(cudaFree(d_A));
CUDA_CHECK(cudaFree(d_B));
CUDA_CHECK(cudaFree(d_C));
return errors == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}

这里的 1e-5 是针对当前有界输入的示例容差,不是所有浮点运算的统一标准。std::isfinite 让校验同时拒绝 NaN 和无穷大;单独比较 fabs(diff) > tolerance 可能漏掉 NaN。

6.3 为什么错误检查需要区分两个阶段?

cudaGetLastError() 常用于检查启动配置等错误,但它不会等待 Kernel 完成。越界等执行期间的问题,可能在后续同步操作或其他 CUDA API 调用中才被报告。

开发时可以在启动后添加:

1
2
CUDA_CHECK(cudaGetLastError());
CUDA_CHECK(cudaDeviceSynchronize());

这样便于定位问题。进入异步流水线优化后,应在必要位置同步,并保留错误检查,避免每次启动都做全设备同步而破坏并发。

原始 vector_add.cu 已经包装了内存相关 API,但部分 Event 调用没有使用 CUDA_CHECK。进一步整理时,可以统一检查 Event 的创建、记录、同步和销毁返回值;使用 malloc 的版本也应检查主机内存分配结果。

7. 性能测量:Kernel 快,程序就一定快吗?

7.1 分开看计算时间与完整流程时间

原始向量加法代码同时输出 CPU 耗时、GPU Kernel 耗时、包含拷贝的 GPU 流程耗时,以及两种加速比。这种区分很有必要。

计时口径 回答的问题
CPU 循环时间 当前 CPU 实现完成计算需要多久?
GPU Kernel 时间 数据已在 GPU 上时,当前 Kernel 需要多久?
传输与计算流程时间 从主机输入到主机结果可用需要多久?
整个程序时间 包含初始化、分配和清理后,应用总共需要多久?

原代码中标注为 GPU total 的区间从数据拷贝前开始,没有覆盖全部内存分配、数据初始化与清理。因此更准确的描述是“包含传输的计算流程耗时”,不应理解为整个进程的运行时间。

7.2 用 CUDA Event 测 Kernel

仅在 CPU 上记录 Kernel 启动前后的时间,通常测到的主要是任务提交开销。CUDA Event 可以在 GPU 执行流中标记时间点。

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
// 片段:假设设备输入、输出和启动配置已准备好
cudaEvent_t start, stop;
CUDA_CHECK(cudaEventCreate(&start));
CUDA_CHECK(cudaEventCreate(&stop));

// 先预热;向量加法会覆盖输出,重复执行不改变输入
vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
CUDA_CHECK(cudaGetLastError());
CUDA_CHECK(cudaDeviceSynchronize());

const int repeat = 100;
CUDA_CHECK(cudaEventRecord(start));
for (int r = 0; r < repeat; ++r) {
vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
CUDA_CHECK(cudaGetLastError());
}
CUDA_CHECK(cudaEventRecord(stop));
CUDA_CHECK(cudaEventSynchronize(stop));

float totalMs = 0.0f;
CUDA_CHECK(cudaEventElapsedTime(&totalMs, start, stop));
float averageMs = totalMs / repeat;
std::printf("Average kernel interval: %.4f ms\n", averageMs);

CUDA_CHECK(cudaEventDestroy(start));
CUDA_CHECK(cudaEventDestroy(stop));

这个结果是该批次的平均时间,短 Kernel 的提交间隙等因素也可能影响测量。重复运行还可能改变缓存状态,因此应记录预热方法、重复次数和数据规模。需要更细的分析时,可用 Nsight Compute 查看单个 Kernel,用 Nsight Systems 查看拷贝、计算和主机提交的时间线。

测量完整流程时,更适合用主机端 std::chrono::steady_clock:在开始前排除先前未完成的工作,记录起点,提交传输和计算,等待结果完成,完成必要的 CPU 后处理,再记录终点。这样能明确覆盖 CPU 与 GPU 的混合工作。

7.3 向量加法为什么容易受带宽限制?

每处理一个 float 元素,需要读取 A[i]、读取 B[i]、写入 C[i],按算法计算共访问 12 字节,只做一次浮点加法。因此算术强度为:

Arithmetic Intensity=1 FLOP12 Bytes≈0.083 FLOP/Byte.

对于足够大的数组,这通常意味着内存带宽比浮点运算能力更值得关注;对于很小的数组,启动开销也可能占主导。

原代码采用 N = 1 << 24 = 16,777,216。一个 float 数组占 67,108,864 字节,也就是 64 MiB,三个数组的算法访存量为 192 MiB,约 201.33 MB。源码以 1024 × 1024 为除数却打印 MB,严格说应标成 MiB。

有效带宽的计算方式是:

BWeffective=3Nsizeof(float)tkernel.

当 kernel_ms 的单位为毫秒时:

1
2
double bandwidthGBs = (3.0 * N * sizeof(float))
/ (kernel_ms * 1e-3) / 1e9;

纯作公式示例:假设 Kernel 用时 0.3 ms,则有效带宽约为 671 GB/s。这不是本文的实测结果。原 Kernel 教程的参考表和后文计算使用的带宽数字不完全一致,整理实验结果时应从同一数据规模和实际耗时重新计算。

有效带宽按算法需要的数据量统计。缓存命中、实际内存事务和其他因素都会影响硬件流量,因此它也不等于直接测得的 DRAM 带宽。

7.4 对性能对比应保留哪些信息?

CPU time / kernel time 比较的是两个计算阶段;CPU time / workflow time 则更接近“输入在 CPU 上时,把这次工作交给 GPU 是否划算”。二者都可以报告,但要写清楚含义。

本文的 CPU 基线是单线程循环,编译器可能对其做自动向量化;它不代表经过多线程或专用库优化的 CPU 上限。GPU 端的优势也取决于数组大小、显存和主机互连带宽,以及数据是否已经在设备上。

可按下表记录自己的实验,本文不预填耗时:

项目 应记录的信息
硬件与软件 CPU、GPU、驱动、Toolkit、编译选项
输入与配置 N、数据类型、Grid、Block
正确性 参考计算方式、最大误差、容差与异常值检查
测量方法 计时边界、预热次数、重复次数、缓存及输入重置方式
结果 CPU 耗时、Kernel 耗时、流程耗时、有效带宽

当一个任务要连续执行多个 GPU 算子时,尽量让中间结果留在显存中,通常比每个算子前后都做一次 CPU/GPU 往返更有意义。这也是从简单向量加法走向 AI 算子优化时,需要持续关注的数据流问题。

7.5 完整代码 vectorAdd.cu

vectorAdd.cu 代码
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <chrono>
#include <cuda_runtime.h>

// 错误检查宏
#define CUDA_CHECK(call) \
do { \
cudaError_t err = call; \
if (err != cudaSuccess) { \
fprintf(stderr, "CUDA error at %s:%d - %s\n", \
__FILE__, __LINE__, cudaGetErrorString(err)); \
exit(EXIT_FAILURE); \
} \
} while (0)

// GPU Kernel
__global__ void vectorAdd(const float* A, const float* B, float* C, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < N) {
C[idx] = A[idx] + B[idx];
}
}

// CPU 基线
void vectorAddCPU(const float* A, const float* B, float* C, int N) {
for (int i = 0; i < N; i++) {
C[i] = A[i] + B[i];
}
}

int main() {
const int N = 1 << 24; // 约 1600 万元素
const size_t size = N * sizeof(float);
printf("Vector size: %d elements (%.1f MB)\n", N, size / (1024.0 * 1024.0));

// ========== 分配主机内存 ==========
float* h_A = (float*)malloc(size);
float* h_B = (float*)malloc(size);
float* h_C_cpu = (float*)malloc(size);
float* h_C_gpu = (float*)malloc(size);

// 初始化数据
for (int i = 0; i < N; i++) {
h_A[i] = sinf(i * 0.001f);
h_B[i] = cosf(i * 0.001f);
}

// ========== CPU 计算 ==========
auto cpu_start = std::chrono::high_resolution_clock::now();
vectorAddCPU(h_A, h_B, h_C_cpu, N);
auto cpu_end = std::chrono::high_resolution_clock::now();
float cpu_ms = std::chrono::duration<float, std::milli>(cpu_end - cpu_start).count();
printf("CPU time: %.4f ms\n", cpu_ms);

// ========== GPU 计算 ==========
float *d_A, *d_B, *d_C;
CUDA_CHECK(cudaMalloc(&d_A, size));
CUDA_CHECK(cudaMalloc(&d_B, size));
CUDA_CHECK(cudaMalloc(&d_C, size));

// 创建 CUDA Event 计时器
cudaEvent_t start, stop, kernel_start, kernel_stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventCreate(&kernel_start);
cudaEventCreate(&kernel_stop);

// 端到端计时(含传输)
cudaEventRecord(start);

CUDA_CHECK(cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice));
CUDA_CHECK(cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice));

int blockSize = 256;
int gridSize = (N + blockSize - 1) / blockSize;

// 仅 Kernel 计时
cudaEventRecord(kernel_start);
vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
cudaEventRecord(kernel_stop);

CUDA_CHECK(cudaGetLastError());
CUDA_CHECK(cudaMemcpy(h_C_gpu, d_C, size, cudaMemcpyDeviceToHost));

cudaEventRecord(stop);
cudaEventSynchronize(stop);

float gpu_total_ms = 0, kernel_ms = 0;
cudaEventElapsedTime(&gpu_total_ms, start, stop);
cudaEventElapsedTime(&kernel_ms, kernel_start, kernel_stop);

printf("GPU kernel time: %.4f ms\n", kernel_ms);
printf("GPU total time (with memcpy): %.4f ms\n", gpu_total_ms);
printf("Speedup (kernel only): %.1fx\n", cpu_ms / kernel_ms);
printf("Speedup (end-to-end): %.1fx\n", cpu_ms / gpu_total_ms);

// ========== 结果验证 ==========
int errors = 0;
for (int i = 0; i < N; i++) {
if (fabsf(h_C_gpu[i] - h_C_cpu[i]) > 1e-5f) {
if (errors < 5) {
printf("Mismatch at %d: CPU=%.6f, GPU=%.6f\n",
i, h_C_cpu[i], h_C_gpu[i]);
}
errors++;
}
}
if (errors == 0) {
printf("Verification PASSED!\n");
} else {
printf("Verification FAILED: %d mismatches\n", errors);
}

// ========== 计算有效带宽 ==========
// 向量加法读 2 个 float、写 1 个 float = 12 bytes/element
float bandwidth_gb = (3.0f * size) / (kernel_ms * 1e-3f) / 1e9f;
printf("Effective bandwidth: %.1f GB/s\n", bandwidth_gb);

// ========== 清理 ==========
cudaEventDestroy(start);
cudaEventDestroy(stop);
cudaEventDestroy(kernel_start);
cudaEventDestroy(kernel_stop);
CUDA_CHECK(cudaFree(d_A));
CUDA_CHECK(cudaFree(d_B));
CUDA_CHECK(cudaFree(d_C));
free(h_A);
free(h_B);
free(h_C_cpu);
free(h_C_gpu);

return 0;
}


8. 练习一:向量点积与共享内存规约

对应文件:dot_product.cu。

向量点积计算:

dot(A,B)=∑i=0N−1A[i]B[i].

与向量加法相比,乘法部分仍然相互独立,但最终需要把所有乘积合成一个数。把许多值按照某种运算合成较少的值,称为规约(Reduction)。

8.1 当前实现采用 GPU 块内规约,再由 CPU 汇总

代码先让每个 Block 输出一个部分和:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
__global__ void vectorDotReduction(const float* A, const float* B,
float* out, int N) {
__shared__ float s_sum[256];
int tid = threadIdx.x;
int idx = blockIdx.x * blockDim.x + threadIdx.x;

s_sum[tid] = (idx < N) ? A[idx] * B[idx] : 0.0f;
__syncthreads();

for (int s = blockDim.x / 2; s > 0; s >>= 1) {
if (tid < s) {
s_sum[tid] += s_sum[tid + s];
}
__syncthreads();
}

if (tid == 0) {
out[blockIdx.x] = s_sum[0];
}
}

以 256 个线程为例,第一次把后 128 个值加到前 128 个值上,之后依次得到 64、32、16、8、4、2、1 个部分和,共 8 轮。每一轮的同步保证下一轮读到的是上一轮已经完成的结果。

这里有三个关键条件:

  1. 当前代码固定使用一维的 256 线程 Block,与 s_sum[256] 对应。
  2. 这种直接折半的写法要求 Block 线程数为 2 的幂;随意改成 192 等大小会遗漏部分值,改大到超过 256 还会越界。
  3. 无有效输入的线程写入 0,并继续参加同步,不能把整段同步逻辑放到 if (idx < N) 里面。

对于 N = 2^24、blockSize = 256,会产生 65,536 个 Block 部分和,占 256 KiB。程序把它们拷回主机后,用 CPU 循环完成最终相加。

因此当前实现是一次 GPU 与 CPU 协作完成的点积。如果希望最终结果直接留在 GPU,可继续用一个或多个 Kernel 规约这些部分和,或者进一步学习 CUB、cuBLAS 等库提供的实现。

8.2 为什么 CPU 与 GPU 的结果可能有差异?

浮点加法不满足严格的结合律:

(a+b)+c≠a+(b+c)

在有限精度下,CPU 的顺序累加和 GPU 的树形累加具有不同的舍入过程。当前输入使用正弦、余弦,还可能发生正负项相消。CPU 的单精度结果也不能直接当作精确答案。

原代码使用 fabs(cpu_result - gpu_result) < 1e-4。这个固定绝对阈值不适用于任意输入规模,检查失败也不能立即归因于 Kernel 的逻辑错误。

更有解释力的方法,是先用较高精度构造参考结果:

1
2
3
4
5
double reference = 0.0;
for (int i = 0; i < N; ++i) {
reference += static_cast<double>(h_A[i])
* static_cast<double>(h_B[i]);
}

再根据精度目标同时考虑绝对误差和相对误差:

|rGPU−rref|≤atol+rtol|rref|.

atol、rtol 应根据数据规模、累加精度和应用需求选择;如果参考结果接近 0,还要特别关注相消误差和绝对误差。也可以记录 sum(abs(A[i] * B[i])),帮助判断问题的数值条件。更高精度的参考计算减少了比较基准的误差,但它本身仍是有限精度计算。

8.3 点积的计时与带宽口径

当前代码的 kernel_ms 只测 GPU 块内规约,未包含最终 CPU 汇总。因此用它和完整 CPU 点积计算加速比时,应明确两边完成的工作范围并不完全相同。

原代码在 CPU 汇总之后才记录结束 Event,两个事件之间可能包含主机工作造成的设备空闲间隔。若要可靠描述完整点积流程,建议用主机时钟包住 H2D、Kernel、部分和回传以及 CPU 最终求和。

第一阶段 Kernel 的逻辑全局访存量近似为:

8N+4×gridSizeBytes.

原文件使用 8N 估算带宽,忽略了部分和写出。这里这个额外量较小,但严格记录时可以计入;共享内存访问则应与全局访存分开分析。

9. 练习二:SAXPY 与原地更新

对应文件:saxpy.cu。

SAXPY 是单精度 BLAS 基础操作,形式为:

Y[i]=αX[i]+Y[i].

在当前代码中,A 对应 X,B 对应 Y,标量 a = 10.0f:

1
2
3
4
5
6
__global__ void saxpy(const float* A, float* B, const float a, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < N) {
B[idx] = a * A[idx] + B[idx];
}
}

SAXPY 仍然是逐元素计算,所以索引和启动配置沿用向量加法即可。变化在于 B 同时是输入与输出:Kernel 读取旧值,再写回新值。

9.1 CPU 与 GPU 必须从同一份初始状态出发

这份代码分别创建了 h_B_cpu 和 h_B_gpu,并把二者初始化为相同内容。CPU 修改前者,GPU 从后者获取输入,比较时才有意义。

如果先让 CPU 更新 B,再把更新后的 B 送给 GPU,那么 GPU 做的是第二次 SAXPY,自然不能和 CPU 第一次的结果直接比较。

同理,重复调用 Kernel 会累计更新 B。如果要预热后测量“同一输入上的一次 SAXPY”,应使用专用预热缓冲区,或者在测量前恢复初始输入;如果测连续更新,则参考结果也要匹配调用次数,并说明重置或拷贝是否计入时间。

9.2 FMA 与误差检查

GPU 编译器可能把 a * A[idx] + B[idx] 合并成 FMA(融合乘加),只进行一次舍入;CPU 是否采用相同方式取决于指令集和编译选项。两边的结果可能出现小幅差异,因此应采用合适的容差,并检查 NaN、Inf 等异常值。

SAXPY 每个元素读取两个 float、写回一个 float,逻辑访存量仍是 12 字节,按常规计数完成 2 FLOPs:

Arithmetic Intensity=212≈0.167 FLOP/Byte.

它比向量加法多一次乘法,但对于大数组通常仍然需要重点关注访存效率。

10. 练习三:Grid-stride Loop,让线程重复领取任务

对应文件:grid_stride_loop.cu。

前面的版本让每个线程最多处理一个元素,所以启动的线程数需要覆盖整个数组。Grid-stride Loop 则让每个线程沿着固定步长处理多个元素:

1
2
3
4
5
6
7
8
__global__ void vectorAddStride(const float* A, const float* B,
float* C, int N) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
int stride = blockDim.x * gridDim.x;
for (int i = idx; i < N; i += stride) {
C[i] = A[i] + B[i];
}
}

当前代码使用 <<<128, 256>>>,总线程数为:

stride=128×256=32768.

于是每个线程负责的位置为:

1
2
3
线程 0:0,32768,65536,……
线程 1:1,32769,65537,……
线程 2:2,32770,65538,……

对 N = 2^24,每个线程恰好处理 512 个元素。不同线程从不同的起点出发,以总线程数为步长前进,所有合法下标都能被覆盖一次。

10.1 为什么这种“大步长”仍然可以合并访问?

单个线程的两次访问确实相隔较远,但同一轮迭代中,相邻线程仍然访问相邻位置。合并访问关注的是一个 Warp 中线程在同一次访存指令里访问哪些地址,而不是某个线程先后访问的元素是否相邻。

10.2 固定 Grid 的价值与限制

这种写法把“数据规模”和“启动线程数”分开,便于按 SM 数量、资源使用和测量结果选择 Grid。它也支持用 <<<1, 1>>> 让一个线程遍历全数组,帮助理解索引覆盖过程。

但固定 gridSize = 128 只是练习参数,在不同 GPU 上不保证最优。线程块太少可能无法提供足够的并行工作,太多也不必然更快。

当前 int 索引足以覆盖练习规模。若扩展到很大的数组,需要检查下标、总线程数和循环增量的溢出风险,可以使用足够宽的无符号类型,并在乘法之前完成类型转换。

11. 练习四:异步传输与计算重叠

对应文件:async_overlap.cu。

这份代码在向量加法基础上做了三项改动:使用 cudaMallocHost 分配锁页内存,创建一个显式 Stream,并使用 cudaMemcpyAsync 提交拷贝。

11.1 单个 Stream 的语义是什么?

Stream 可以理解为有顺序约束的任务队列。同一 Stream 内,操作按照顺序满足执行依赖。当前文件把两次输入拷贝、Kernel 和结果回传都放在同一个 Stream 中:

1
同一个 Stream:H2D(A) → H2D(B) → vectorAdd → D2H(C)

因此,这份实现展示了异步提交,但没有实现这几步之间的传输与计算重叠。Kernel 需要等待前面的输入就绪,结果回传也需要等待 Kernel 完成。原教程练习中的单 Stream 示例同样需要补充这一条件。

两个概念应分清:

  • 异步:主机调用返回时,GPU 工作可能还没有完成,CPU 有机会继续做其他事。
  • 重叠:两项工作在时间线上有一部分同时进行,例如第 0 块数据正在计算,第 1 块数据正在传输。

当前代码提交后立即调用 cudaStreamSynchronize 等待,也没有安排额外的 CPU 工作来利用这段时间。

11.2 锁页内存解决了什么?

普通 malloc 分配的是可分页主机内存。对于显式主机与独立 GPU 间的拷贝,要可靠利用异步传输和重叠,通常需要锁页内存,避免临时中转及相关同步影响。

1
2
3
4
float* h_A;
CUDA_CHECK(cudaMallocHost(&h_A, bytes));
// 使用 h_A,并等待相关异步操作完成
CUDA_CHECK(cudaFreeHost(h_A));

分配与释放应成对使用:cudaMallocHost 对应 cudaFreeHost,cudaMalloc 对应 cudaFree。传输尚未完成时,CPU 不能改写仍在发送的输入,也不能读取尚未回传完成的输出。

原文件把 h_C_cpu 也分配成了锁页内存,但它只用于 CPU 基线,通常可以使用普通主机内存。锁页内存应优先用于确实参与异步传输的缓冲区。

11.3 怎样进一步实现重叠?

对于这个没有元素间依赖的任务,可以把数组分成独立数据块,再交给多个 Stream。每一块仍然保持“输入拷贝 → 计算 → 输出回传”的顺序,而不同块之间有机会并行:

1
2
3
4
时间向右;仅示意可能的重叠,不代表实测时间比例

Stream 0,块 0: [H2D] [Kernel] [D2H]
Stream 1,块 1: [H2D] [Kernel] [D2H]

能否实际重叠,还取决于设备的复制引擎能力、依赖关系、资源使用、块大小和提交时机。asyncEngineCount 等设备属性可用于了解能力,最终应通过 Nsight Systems 的时间线确认。

下面是可替换原程序单 Stream 提交部分的扩展示例片段,不是原文件已经具备的实现。它沿用完整设备数组,让各块使用互不重叠的地址区间;主机输入输出已使用锁页内存分配,并需包含 <algorithm> 和 <chrono>:

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
constexpr int streamCount = 2;
constexpr int chunkElements = 1 << 20;
cudaStream_t streams[streamCount];
for (int s = 0; s < streamCount; ++s) {
CUDA_CHECK(cudaStreamCreateWithFlags(&streams[s], cudaStreamNonBlocking));
}

// 设备数组 d_A/d_B/d_C 均已按完整 N 分配;输入 h_A/h_B 已初始化
CUDA_CHECK(cudaDeviceSynchronize());
auto begin = std::chrono::steady_clock::now();

int chunkId = 0;
for (int offset = 0; offset < N; offset += chunkElements, ++chunkId) {
cudaStream_t stream = streams[chunkId % streamCount];
int count = std::min(chunkElements, N - offset);
size_t chunkBytes = static_cast<size_t>(count) * sizeof(float);

CUDA_CHECK(cudaMemcpyAsync(d_A + offset, h_A + offset, chunkBytes,
cudaMemcpyHostToDevice, stream));
CUDA_CHECK(cudaMemcpyAsync(d_B + offset, h_B + offset, chunkBytes,
cudaMemcpyHostToDevice, stream));

int blocks = (count + 255) / 256;
vectorAdd<<<blocks, 256, 0, stream>>>(d_A + offset, d_B + offset,
d_C + offset, count);
CUDA_CHECK(cudaGetLastError());

CUDA_CHECK(cudaMemcpyAsync(h_C_gpu + offset, d_C + offset, chunkBytes,
cudaMemcpyDeviceToHost, stream));
}

// 全部提交之后再等待,避免每提交一块就阻塞主机
for (int s = 0; s < streamCount; ++s) {
CUDA_CHECK(cudaStreamSynchronize(streams[s]));
}
auto end = std::chrono::steady_clock::now();
double workflowMs = std::chrono::duration<double, std::milli>(end - begin).count();
std::printf("Chunked workflow: %.4f ms\n", workflowMs);

for (int s = 0; s < streamCount; ++s) {
CUDA_CHECK(cudaStreamDestroy(streams[s]));
}
// 此后才能校验 h_C_gpu,或释放相关内存

尾块使用 count 而非整个 N,并同步调整拷贝字节数与 Kernel 参数,可以防止最后一块越界。同一个 Stream 被多次复用时,其内部顺序仍然有效;当前片段使用的是完整数组中的独立区间。如果进一步改成反复复用的小缓冲区,还需要管理缓冲区的完成事件与复用时机。

多个 Stream 的耗时不能通过把各自的时间简单相加来表示,因为它们可能重叠。这里用主机时钟包住全部提交与等待,测量整个分块流程;单独分析 Kernel 时,可以在对应 Stream 中记录事件。

比较单 Stream 与多 Stream 时,应统一锁页内存策略、预热和计时边界。即使多 Stream 能重叠,也可能因为任务过小、传输粒度或资源竞争而没有加速,不能仅凭 API 名字下结论。

12. 完成这些练习后,接下来关注什么?

向量加法给出了从输入到结果的基本流程。点积增加了线程协作和归约顺序,SAXPY 引出了输入状态和数值误差,Grid-stride Loop 解除了数据规模与线程总数的绑定,Stream 则让问题扩展到数据搬运与计算的调度。

下一步可以沿着两条线继续学习:一条是从点积出发,学习 Warp Shuffle、多阶段规约和 CUB;另一条是从共享内存出发,学习矩阵乘法的 Tiling、数据复用和算子融合。每增加一种优化,都需要重新确认结果正确、计时范围一致,并用测量说明它改善了哪个环节。

参考资料

本文以以下四篇 AIInfraGuide 教程为学习主线,结合五份配套源码重新组织讲解,并补充了同步、计时和异步重叠的适用条件:

  1. AIInfraGuide:1.1 CUDA 开发环境搭建
  2. AIInfraGuide:1.2 CUDA 编程模型
  3. AIInfraGuide:1.3 CUDA 内存模型
  4. AIInfraGuide:1.4 第一个实用 Kernel——向量加法

进一步查阅 API 语义、设备限制与版本差异,可参考 NVIDIA 官方资料:

Comments
赞赏
Share
← 返回