
写一个 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 和显式内存拷贝方式,完整流程如下:

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 上可以按以下顺序准备:
- 安装支持目标 GPU 的 NVIDIA 驱动。
- 安装所选 Toolkit 支持的 Visual Studio / Build Tools,并包含 C++ 桌面开发组件和 Windows SDK。
- 安装 CUDA Toolkit,确认其
bin目录可被命令行找到。 - 在配置好 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 | nvcc -O3 -std=c++17 -lineinfo vector_add.cu -o vector_add |
Windows 开发者终端:
1 | nvcc -O3 -std=c++17 -lineinfo -Xcompiler /O2 vector_add.cu -o 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 | 一次 Kernel 启动对应一个 Grid |

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 | int blockSize = 256; |
实际启动 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 | int col = blockIdx.x * blockDim.x + threadIdx.x; |
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 | 线程编号: 0 1 2 3 ... 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 | // 假设 tile 的容量与当前 Block 配置匹配 |
这样尾块也有明确定义。后面的点积练习正好展示了这个模式。
6. 第一个实用 Kernel:向量加法
目标是计算:
CPU 的写法是一个循环:
1 | void vectorAddCPU(const float* A, const float* B, float* C, int N) { |
vector_add.cu 中的 GPU Kernel 则让每个线程负责一个元素:
1 | __global__ void vectorAdd(const float* A, const float* B, float* C, int N) { |
这里每个输出位置只有一个线程写入,线程间没有数据依赖,因此无需共享内存、原子操作或块内同步。
6.1 主机端需要做什么?
五份代码都采用 h_ 和 d_ 前缀区分主机和设备指针。前缀只是命名约定,真正决定内存位置的是分配方式。
核心步骤可以写成:
1 | // 片段:假设输入已初始化,CUDA_CHECK 已定义 |
在这个同一默认 Stream 中的执行序列里,回传结果的阻塞式 D2H 拷贝完成后,CPU 才读取 h_C。如果之后使用多个 Stream,则需要重新明确各项操作之间的依赖。
6.2 一份便于独立理解的完整版本
下面是根据 vector_add.cu 整理的精简教学版本,保留分配、传输、启动、错误检查与校验,计时在下一节单独讨论。它不是原文件的逐字复制。
1 |
|
这里的 1e-5 是针对当前有界输入的示例容差,不是所有浮点运算的统一标准。std::isfinite 让校验同时拒绝 NaN 和无穷大;单独比较 fabs(diff) > tolerance 可能漏掉 NaN。
6.3 为什么错误检查需要区分两个阶段?
cudaGetLastError() 常用于检查启动配置等错误,但它不会等待 Kernel 完成。越界等执行期间的问题,可能在后续同步操作或其他 CUDA API 调用中才被报告。
开发时可以在启动后添加:
1 | CUDA_CHECK(cudaGetLastError()); |
这样便于定位问题。进入异步流水线优化后,应在必要位置同步,并保留错误检查,避免每次启动都做全设备同步而破坏并发。
原始 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 | // 片段:假设设备输入、输出和启动配置已准备好 |
这个结果是该批次的平均时间,短 Kernel 的提交间隙等因素也可能影响测量。重复运行还可能改变缓存状态,因此应记录预热方法、重复次数和数据规模。需要更细的分析时,可用 Nsight Compute 查看单个 Kernel,用 Nsight Systems 查看拷贝、计算和主机提交的时间线。
测量完整流程时,更适合用主机端 std::chrono::steady_clock:在开始前排除先前未完成的工作,记录起点,提交传输和计算,等待结果完成,完成必要的 CPU 后处理,再记录终点。这样能明确覆盖 CPU 与 GPU 的混合工作。
7.3 向量加法为什么容易受带宽限制?
每处理一个 float 元素,需要读取 A[i]、读取 B[i]、写入 C[i],按算法计算共访问 12 字节,只做一次浮点加法。因此算术强度为:
对于足够大的数组,这通常意味着内存带宽比浮点运算能力更值得关注;对于很小的数组,启动开销也可能占主导。
原代码采用 N = 1 << 24 = 16,777,216。一个 float 数组占 67,108,864 字节,也就是 64 MiB,三个数组的算法访存量为 192 MiB,约 201.33 MB。源码以 1024 × 1024 为除数却打印 MB,严格说应标成 MiB。
有效带宽的计算方式是:
当 kernel_ms 的单位为毫秒时:
1 | double bandwidthGBs = (3.0 * N * sizeof(float)) |
纯作公式示例:假设 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 |
|
8. 练习一:向量点积与共享内存规约
对应文件:dot_product.cu。
向量点积计算:
与向量加法相比,乘法部分仍然相互独立,但最终需要把所有乘积合成一个数。把许多值按照某种运算合成较少的值,称为规约(Reduction)。
8.1 当前实现采用 GPU 块内规约,再由 CPU 汇总
代码先让每个 Block 输出一个部分和:
1 | __global__ void vectorDotReduction(const float* A, const float* B, |
以 256 个线程为例,第一次把后 128 个值加到前 128 个值上,之后依次得到 64、32、16、8、4、2、1 个部分和,共 8 轮。每一轮的同步保证下一轮读到的是上一轮已经完成的结果。
这里有三个关键条件:
- 当前代码固定使用一维的 256 线程 Block,与
s_sum[256]对应。 - 这种直接折半的写法要求 Block 线程数为 2 的幂;随意改成 192 等大小会遗漏部分值,改大到超过 256 还会越界。
- 无有效输入的线程写入 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 的结果可能有差异?
浮点加法不满足严格的结合律:
在有限精度下,CPU 的顺序累加和 GPU 的树形累加具有不同的舍入过程。当前输入使用正弦、余弦,还可能发生正负项相消。CPU 的单精度结果也不能直接当作精确答案。
原代码使用 fabs(cpu_result - gpu_result) < 1e-4。这个固定绝对阈值不适用于任意输入规模,检查失败也不能立即归因于 Kernel 的逻辑错误。
更有解释力的方法,是先用较高精度构造参考结果:
1 | double reference = 0.0; |
再根据精度目标同时考虑绝对误差和相对误差:
atol、rtol 应根据数据规模、累加精度和应用需求选择;如果参考结果接近 0,还要特别关注相消误差和绝对误差。也可以记录 sum(abs(A[i] * B[i])),帮助判断问题的数值条件。更高精度的参考计算减少了比较基准的误差,但它本身仍是有限精度计算。
8.3 点积的计时与带宽口径
当前代码的 kernel_ms 只测 GPU 块内规约,未包含最终 CPU 汇总。因此用它和完整 CPU 点积计算加速比时,应明确两边完成的工作范围并不完全相同。
原代码在 CPU 汇总之后才记录结束 Event,两个事件之间可能包含主机工作造成的设备空闲间隔。若要可靠描述完整点积流程,建议用主机时钟包住 H2D、Kernel、部分和回传以及 CPU 最终求和。
第一阶段 Kernel 的逻辑全局访存量近似为:
原文件使用 8N 估算带宽,忽略了部分和写出。这里这个额外量较小,但严格记录时可以计入;共享内存访问则应与全局访存分开分析。
9. 练习二:SAXPY 与原地更新
对应文件:saxpy.cu。
SAXPY 是单精度 BLAS 基础操作,形式为:
在当前代码中,A 对应 X,B 对应 Y,标量 a = 10.0f:
1 | __global__ void saxpy(const float* A, float* B, const float a, int N) { |
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:
它比向量加法多一次乘法,但对于大数组通常仍然需要重点关注访存效率。
10. 练习三:Grid-stride Loop,让线程重复领取任务
对应文件:grid_stride_loop.cu。
前面的版本让每个线程最多处理一个元素,所以启动的线程数需要覆盖整个数组。Grid-stride Loop 则让每个线程沿着固定步长处理多个元素:
1 | __global__ void vectorAddStride(const float* A, const float* B, |
当前代码使用 <<<128, 256>>>,总线程数为:
于是每个线程负责的位置为:
1 | 线程 0:0,32768,65536,…… |
对 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 | float* h_A; |
分配与释放应成对使用:cudaMallocHost 对应 cudaFreeHost,cudaMalloc 对应 cudaFree。传输尚未完成时,CPU 不能改写仍在发送的输入,也不能读取尚未回传完成的输出。
原文件把 h_C_cpu 也分配成了锁页内存,但它只用于 CPU 基线,通常可以使用普通主机内存。锁页内存应优先用于确实参与异步传输的缓冲区。
11.3 怎样进一步实现重叠?
对于这个没有元素间依赖的任务,可以把数组分成独立数据块,再交给多个 Stream。每一块仍然保持“输入拷贝 → 计算 → 输出回传”的顺序,而不同块之间有机会并行:
1 | 时间向右;仅示意可能的重叠,不代表实测时间比例 |
能否实际重叠,还取决于设备的复制引擎能力、依赖关系、资源使用、块大小和提交时机。asyncEngineCount 等设备属性可用于了解能力,最终应通过 Nsight Systems 的时间线确认。
下面是可替换原程序单 Stream 提交部分的扩展示例片段,不是原文件已经具备的实现。它沿用完整设备数组,让各块使用互不重叠的地址区间;主机输入输出已使用锁页内存分配,并需包含 <algorithm> 和 <chrono>:
1 | constexpr int streamCount = 2; |
尾块使用 count 而非整个 N,并同步调整拷贝字节数与 Kernel 参数,可以防止最后一块越界。同一个 Stream 被多次复用时,其内部顺序仍然有效;当前片段使用的是完整数组中的独立区间。如果进一步改成反复复用的小缓冲区,还需要管理缓冲区的完成事件与复用时机。
多个 Stream 的耗时不能通过把各自的时间简单相加来表示,因为它们可能重叠。这里用主机时钟包住全部提交与等待,测量整个分块流程;单独分析 Kernel 时,可以在对应 Stream 中记录事件。
比较单 Stream 与多 Stream 时,应统一锁页内存策略、预热和计时边界。即使多 Stream 能重叠,也可能因为任务过小、传输粒度或资源竞争而没有加速,不能仅凭 API 名字下结论。
12. 完成这些练习后,接下来关注什么?
向量加法给出了从输入到结果的基本流程。点积增加了线程协作和归约顺序,SAXPY 引出了输入状态和数值误差,Grid-stride Loop 解除了数据规模与线程总数的绑定,Stream 则让问题扩展到数据搬运与计算的调度。
下一步可以沿着两条线继续学习:一条是从点积出发,学习 Warp Shuffle、多阶段规约和 CUB;另一条是从共享内存出发,学习矩阵乘法的 Tiling、数据复用和算子融合。每增加一种优化,都需要重新确认结果正确、计时范围一致,并用测量说明它改善了哪个环节。
参考资料
本文以以下四篇 AIInfraGuide 教程为学习主线,结合五份配套源码重新组织讲解,并补充了同步、计时和异步重叠的适用条件:
- AIInfraGuide:1.1 CUDA 开发环境搭建
- AIInfraGuide:1.2 CUDA 编程模型
- AIInfraGuide:1.3 CUDA 内存模型
- AIInfraGuide:1.4 第一个实用 Kernel——向量加法
进一步查阅 API 语义、设备限制与版本差异,可参考 NVIDIA 官方资料: