一、什么是 CUDA?
CUDA(Compute Unified Device Architecture)是 NVIDIA 推出的 GPU 通用计算平台和编程模型。
在 CUDA 出现之前,GPU 主要用于图形渲染,开发者通常通过图形 API 使用 GPU。
CUDA 将 GPU 的计算能力开放给通用程序,使开发者能够使用 C、C++ 等语言编写 GPU 并行程序。
CUDA 不仅是一种编程语言,也不是单独的一个库,而是一套完整的 GPU 计算生态。
主要包括:
- CUDA 编程模型:定义如何组织 GPU 线程和计算任务。
- CUDA C/C++:用于编写 GPU Kernel。
- CUDA Runtime:提供设备管理、内存分配和 Kernel 启动等接口。
- CUDA Driver API:提供更底层的 GPU 控制能力。
- CUDA Toolkit:包含编译器、开发工具和相关库。
- CUDA Libraries:提供矩阵计算、深度学习等高性能计算能力。
1. 为什么需要 CUDA?
CPU 和 GPU 的设计目标不同。
CPU 更注重单线程性能、复杂控制逻辑和低延迟任务。
GPU 更注重吞吐量,通过大量计算单元同时执行相似的计算任务。
例如,需要对一个包含一百万个元素的数组执行相同的平方运算:
CPU 可以使用多个核心并行处理,但核心数量相对有限。
GPU 则可以启动大量线程,让不同线程处理不同元素。
flowchart TD
A["输入一百万个数据"] --> B{"选择计算设备"}
B -->|"CPU"| C["少量高性能核心"]
B -->|"GPU"| D["大量并行计算线程"]
C --> E["分批处理数据"]
D --> F["多个线程同时处理不同元素"]
E --> G["合并计算结果"]
F --> G
G --> H["得到输出数组"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
2. CUDA 的核心价值
CUDA 主要解决三个问题:
第一,让 GPU 可以执行通用计算。
开发者不再局限于图形渲染,而是可以在 GPU 上执行矩阵乘法、图像处理、科学计算和神经网络计算。
第二,提供统一的并行编程模型。
开发者可以将任务拆分成大量线程,由 GPU 自动调度执行。
第三,提供成熟的高性能计算生态。
CUDA 提供 cuBLAS、cuDNN、NCCL 等库,减少开发者重复实现底层计算的工作。
二、GPU 的硬件执行架构
理解 CUDA,首先要理解 GPU 如何组织计算资源。
GPU 并不是一个拥有大量独立 CPU 核心的处理器,而是由多个流式多处理器(Streaming Multiprocessor,SM)组成。
每个 SM 包含多个计算单元、寄存器、共享内存和调度资源。
1. GPU 的主要组成
一个典型的 NVIDIA GPU 包含:
| 组件 | 作用 |
|---|---|
| SM | GPU 的主要计算与调度单元 |
| CUDA Core | 执行整数和浮点等通用计算 |
| Tensor Core | 加速矩阵乘法等张量运算 |
| Warp Scheduler | 调度 Warp 执行 |
| Register File | 保存线程私有寄存器 |
| Shared Memory | 提供 SM 内线程共享的高速存储 |
| L1 Cache | 缓存局部访问数据 |
| L2 Cache | GPU 多个 SM 共享的缓存 |
| Global Memory | GPU 显存中的全局数据存储 |
具体硬件数量和组织方式会因 GPU 架构及型号不同而变化。
2. 什么是 SM?
SM 是 CUDA 并行执行的核心硬件单元。
GPU 通常包含多个 SM,每个 SM 可以同时驻留多个线程块,并根据资源情况调度不同 Warp。
一个线程块在执行过程中由某个 SM 负责,不会被拆分到多个 SM 上同时执行。
一个 SM 可以同时管理多个线程块,但能够同时驻留多少个线程块,取决于:
- SM 可用寄存器数量。
- 共享内存容量。
- 每个线程块的线程数量。
- GPU 架构的线程和线程块上限。
例如,假设某 GPU 拥有 80 个 SM,程序启动了 1000 个线程块。
GPU 不会一次性将全部线程块同时放入硬件执行,而是根据 SM 的资源情况分批调度。
flowchart TD
A["GPU"] --> B["SM 0"]
A --> C["SM 1"]
A --> D["SM 2"]
A --> E["SM ..."]
B --> F["Warp Scheduler"]
C --> G["Warp Scheduler"]
D --> H["Warp Scheduler"]
F --> I["CUDA Core / Tensor Core"]
G --> J["CUDA Core / Tensor Core"]
H --> K["CUDA Core / Tensor Core"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
3. CUDA Core 与 Tensor Core
CUDA Core 是 GPU 中执行通用计算的基本计算单元。
Tensor Core 则专门针对矩阵乘法和矩阵乘加等运算进行优化。
在深度学习中,常见的计算形式是:
或者矩阵乘加:
Tensor Core 能够以更高的吞吐量执行支持的数据类型和矩阵形状对应的运算。
常见支持精度包括:
- FP16
- BF16
- TF32
- FP8
- INT8
- 更低位宽的部分整数格式
具体支持范围取决于 GPU 架构。
需要注意,Tensor Core 并不是 CUDA Core 的简单替代品。普通算子、控制逻辑和其他计算仍然可能由 CUDA Core 等执行单元处理。
三、CUDA 编程模型:Thread、Block 与 Grid
CUDA 最重要的概念是线程组织模型。
开发者编写一个 GPU Kernel,定义每个线程负责什么工作,然后通过 Grid 和 Block 组织大量线程。
CUDA 使用三个核心概念:
- Thread:线程。
- Block:线程块。
- Grid:线程块集合。
1. Thread:线程
Thread 是 CUDA 编程模型中最基本的执行单位。
每个线程拥有自己的:
- Thread ID。
- 寄存器。
- 局部变量。
- 执行状态。
例如,执行数组平方计算时,可以让每个线程处理一个数组元素。
__global__ void square(float* input, float* output, int n) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < n) {
output[idx] = input[idx] * input[idx];
}
}
其中:
threadIdx.x:线程在当前 Block 中的索引。blockIdx.x:Block 在 Grid 中的索引。blockDim.x:每个 Block 在 x 维度上的线程数量。
线程通过全局索引 idx 确定自己处理的数据位置。
2. Block:线程块
Block 是一组可以协作执行的线程。
同一个 Block 内的线程可以:
- 通过 Shared Memory 共享数据。
- 使用同步原语进行协调。
- 通过 Warp 级指令进行协作计算。
例如,一个 Block 包含 256 个线程:
dim3 block(256);
这表示一个一维线程块包含 256 个线程。
Block 是 GPU 调度的基本组织单位。
一个 Block 会被分配到一个 SM 上执行,Block 内的线程不会被拆分到多个 SM。
3. Grid:网格
Grid 是一次 Kernel 启动所包含的全部 Block。
假设需要处理 10000 个元素,每个 Block 使用 256 个线程:
因此,需要启动 40 个 Block。
最后一个 Block 中可能有部分线程没有对应的数据,需要通过边界判断避免越界访问。
4. 三层组织关系
flowchart TD
A["Grid"] --> B["Block 0"]
A --> C["Block 1"]
A --> D["Block 2"]
A --> E["Block ..."]
B --> F["Thread 0"]
B --> G["Thread 1"]
B --> H["Thread ..."]
C --> I["Thread 0"]
C --> J["Thread 1"]
C --> K["Thread ..."]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
可以将它们理解为:
| 层级 | 含义 | 主要作用 |
|---|---|---|
| Grid | 全部线程块 | 描述完整计算任务 |
| Block | 一组线程 | 组织协作和共享数据 |
| Thread | 单个线程 | 执行具体计算 |
四、Warp:GPU 真正的执行调度单位
理解 Thread、Block 和 Grid 之后,还需要理解 Warp。
Warp 是 GPU 硬件调度线程的重要单位。
在 NVIDIA CUDA GPU 中,一个 Warp 通常包含 32 个线程。
同一个 Warp 中的线程采用 SIMT(Single Instruction, Multiple Threads)执行模型。
这意味着一个 Warp 中的线程通常执行相同的指令,但可以操作不同的数据。
1. 什么是 SIMT?
SIMT 是 CUDA GPU 的核心执行模型之一。
假设一个 Warp 有 32 个线程,每个线程负责数组中的一个元素。
所有线程执行相同的平方运算指令,但访问不同的数据位置。
Thread 0 -> input[0] -> output[0]
Thread 1 -> input[1] -> output[1]
Thread 2 -> input[2] -> output[2]
...
Thread 31 -> input[31] -> output[31]
这种方式使 GPU 能够高效处理大量相同类型的计算。
2. Warp 与 Block 的关系
假设一个 Block 包含 256 个线程:
这个 Block 可以划分为 8 个 Warp。
如果一个 Block 有 128 个线程,则包含 4 个 Warp。
如果线程数量不能被 32 整除,最后一个 Warp 中可能有部分线程处于非活动状态。
3. Warp Divergence:分支发散
Warp Divergence 是 CUDA 性能优化中非常重要的概念。
假设一个 Warp 中的 32 个线程执行条件判断:
if (threadIdx.x % 2 == 0) {
result = a + b;
} else {
result = a * b;
}
其中一半线程执行加法,另一半执行乘法。
由于这些线程属于同一个 Warp,硬件可能需要分别执行不同分支,并通过线程掩码控制哪些线程处于活动状态。
这会降低执行效率。
需要注意,现代 GPU 对分支执行有更复杂的优化机制,实际影响取决于架构、分支条件和代码结构。
常见容易引起性能问题的情况:
- 同一个 Warp 内不同线程频繁执行不同分支。
- 分支内部包含复杂计算。
- 线程执行路径差异明显。
优化方向:
- 尽量让同一 Warp 中的线程执行相似路径。
- 减少不必要的条件分支。
- 将不同计算路径的数据适当分组。
4. Warp Shuffle
Warp Shuffle 是 Warp 内线程交换寄存器数据的机制。
例如,一个线程可以读取同一 Warp 中另一个线程的寄存器值。
常见用途:
- Warp 内归约。
- 前缀和计算。
- 数据重排。
- Warp 内协作计算。
与使用 Shared Memory 相比,Warp Shuffle 在适用场景下可以减少内存访问和同步开销。
五、CUDA 内存体系
GPU 并不是只有显存一种存储空间。
CUDA 提供多层内存体系,不同内存的访问速度、容量、作用范围和生命周期都不同。
理解内存体系,是编写高性能 CUDA 程序的关键。
1. 内存层级
| 内存类型 | 位置 | 访问范围 | 特点 |
|---|---|---|---|
| Register | SM 内 | 单个线程 | 速度快、容量有限 |
| Local Memory | GPU 显存体系 | 单个线程 | 线程私有,通常位于显存 |
| Shared Memory | SM 内 | 同一个 Block | 线程共享,速度快 |
| L1 Cache | SM 内 | SM 内线程访问 | 缓存局部数据 |
| L2 Cache | GPU 级 | 多个 SM 共享 | 缓存全局数据 |
| Global Memory | 显存 | GPU 所有线程 | 容量大、延迟相对高 |
| Constant Memory | GPU 内存体系 | 所有线程只读 | 适合广播访问 |
| Texture Memory | GPU 缓存体系 | GPU 线程 | 具有特定缓存访问机制 |
2. Register:寄存器
寄存器是线程私有的高速存储空间。
每个线程可以使用寄存器保存:
- 中间计算结果。
- 局部变量。
- 索引。
- 临时数值。
寄存器访问速度非常快,但每个 SM 的寄存器总量有限。
如果一个 Kernel 每个线程使用大量寄存器,就可能减少一个 SM 同时驻留的 Warp 数量。
这会影响 GPU 的 Occupancy。
3. Shared Memory:共享内存
Shared Memory 是同一个 Block 内线程可以共同访问的高速存储空间。
它位于 SM 内,适合保存需要被多个线程重复访问的数据。
例如矩阵乘法中,可以将矩阵的一部分数据加载到 Shared Memory,再由多个线程重复使用。
这样能够减少对 Global Memory 的重复访问。
示例:
__shared__ float tile[16][16];
这表示在一个 Block 内声明一个共享的二维数组。
需要注意:
- Shared Memory 的作用范围是 Block。
- 不同 Block 之间不能直接共享同一块 Shared Memory。
- 使用前需要关注线程同步。
- Shared Memory 容量有限。
4. Global Memory:全局内存
Global Memory 通常就是 GPU 显存。
它容量较大,所有 GPU 线程都可以通过指针访问。
例如:
__global__ void add(float* a, float* b, float* c, int n) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < n) {
c[idx] = a[idx] + b[idx];
}
}
这里的 a、b 和 c 通常指向 Global Memory 中的数据。
Global Memory 的访问延迟比寄存器和 Shared Memory 高,因此需要尽量提高访问效率。
5. 内存访问性能
可以从访问延迟、容量和共享范围三个方面理解 CUDA 内存体系。
flowchart TD
A["CUDA 内存体系"] --> B["线程私有存储"]
A --> C["Block 共享存储"]
A --> D["GPU 全局存储"]
B --> E["Register"]
B --> F["Local Memory"]
C --> G["Shared Memory"]
C --> H["L1 Cache"]
D --> I["L2 Cache"]
D --> J["Global Memory"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
需要注意,Local Memory 虽然名称中包含 Local,但它并不是 SM 内的高速片上存储。它通常位于设备内存体系中,可能经过缓存,访问成本往往明显高于寄存器。
当寄存器压力过大,编译器可能将部分变量放入 Local Memory,这种情况称为 Register Spilling。
六、CUDA Kernel 的执行机制
Kernel 是 CUDA 中运行在 GPU 上的函数。
开发者使用 __global__ 声明一个 Kernel,并通过特殊的启动语法调用它。
1. Kernel 函数
一个简单的向量加法:
__global__ void vector_add(
float* a,
float* b,
float* c,
int n
) {
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < n) {
c[idx] = a[idx] + b[idx];
}
}
这里:
__global__:表示这是一个 GPU Kernel。a、b:输入数组。c:输出数组。idx:当前线程负责的数据索引。if (idx < n):防止线程访问数组边界之外的位置。
2. Kernel 启动
CUDA 使用以下语法启动 Kernel:
vector_add<<<gridSize, blockSize>>>(a, b, c, n);
其中:
gridSize:Grid 中 Block 的数量。blockSize:每个 Block 的线程数量。
例如:
int n = 10000;
int blockSize = 256;
int gridSize = (n + blockSize - 1) / blockSize;
vector_add<<<gridSize, blockSize>>>(a, b, c, n);
计算得到:
GPU 会按照 Grid 和 Block 的组织方式调度线程执行 Kernel。
3. Kernel 执行过程
flowchart TD
A["CPU 准备输入数据"] --> B["分配 GPU 显存"]
B --> C["复制输入数据到 GPU"]
C --> D["配置 Grid 和 Block"]
D --> E["启动 CUDA Kernel"]
E --> F["GPU 调度线程块到 SM"]
F --> G["Warp 调度线程执行指令"]
G --> H["读写 GPU 内存并完成计算"]
H --> I["检查执行结果"]
I --> J["复制结果回 CPU"]
J --> K["释放 GPU 资源"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style K fill:#DCEFE5,stroke:#4F8B70,color:#24563F
这里有一个重要概念:Kernel 启动通常是异步的。
CPU 提交 Kernel 启动请求后,不一定等待 GPU 完成计算就会继续执行后面的代码。
如果需要确保计算完成,可以使用同步操作。
例如:
cudaDeviceSynchronize();
实际开发中还需要检查 Kernel 启动错误和异步执行错误。
七、CUDA 的线程同步机制
GPU 中大量线程可能同时访问共享数据。
如果多个线程之间存在数据依赖,就需要同步机制保证执行顺序和数据正确性。
1. __syncthreads()
__syncthreads() 是 Block 级同步原语。
它会让同一个 Block 中参与执行的线程在指定位置等待,直到 Block 内线程都到达同步点。
例如:
__global__ void shared_example(float* input, float* output) {
__shared__ float cache[256];
int tid = threadIdx.x;
int idx = blockIdx.x * blockDim.x + tid;
cache[tid] = input[idx];
__syncthreads();
output[idx] = cache[tid] * 2.0f;
}
这里先将数据写入 Shared Memory,再通过同步确保数据已经准备好,最后执行计算。
需要注意:
- 只能同步同一个 Block 内的线程。
- 不同 Block 之间不能直接依靠
__syncthreads()同步。 - 同一个 Block 中的线程必须以正确的控制流到达同步点。
- 如果部分线程跳过同步点,可能导致程序行为错误或死锁。
2. 原子操作(Atomic Operations)
当多个线程同时修改同一个变量时,可能出现数据竞争。
例如:
counter += 1;
如果多个线程同时执行这段操作,可能发生更新丢失。
CUDA 提供原子操作:
atomicAdd(&counter, 1);
它能够保证指定内存位置上的加法操作具有原子性。
常见原子操作:
atomicAddatomicSubatomicExchatomicMinatomicMaxatomicCAS
原子操作能够保证正确性,但大量线程竞争同一个地址时,也可能成为性能瓶颈。
3. Stream:CUDA 流
CUDA Stream 是一条有序的 GPU 操作队列。
同一个 Stream 中的操作按照提交顺序执行。
不同 Stream 之间的操作,在满足依赖和硬件条件时可以并发执行。
常见用途:
- 数据传输与计算重叠。
- 并行执行多个独立 Kernel。
- 多请求任务调度。
- 提高 GPU 利用率。
例如:
cudaStream_t stream1;
cudaStream_t stream2;
cudaStreamCreate(&stream1);
cudaStreamCreate(&stream2);
kernel_a<<<grid, block, 0, stream1>>>();
kernel_b<<<grid, block, 0, stream2>>>();
这两个 Kernel 分别提交到不同 Stream,但是否真正并发执行,还取决于 GPU 资源、Kernel 特征和依赖关系。
八、CUDA 并行计算的关键优化技术
编写 CUDA 程序,不只是把任务拆成大量线程,还需要让线程、内存和计算资源高效协同。
1. Coalesced Memory Access:合并内存访问
GPU 内存系统会尽可能将多个线程的内存访问合并成较少的内存事务。
假设一个 Warp 包含 32 个线程,每个线程读取连续的 4 Byte 数据:
Thread 0 -> data[0]
Thread 1 -> data[1]
Thread 2 -> data[2]
...
Thread 31 -> data[31]
这种连续访问通常有利于内存事务合并。
如果线程访问的地址非常分散,就可能需要更多内存事务,降低带宽利用率。
因此,连续访问和合理的数据布局非常重要。
2. Shared Memory Tiling
矩阵乘法需要反复读取矩阵中的数据。
如果每个线程都直接从 Global Memory 读取数据,可能产生大量重复访问。
Tiling 技术将矩阵拆分成小块,先加载到 Shared Memory,再由 Block 内多个线程重复使用。
例如:
可以将矩阵拆成多个子矩阵:
这种方式能够提高数据复用率,减少 Global Memory 访问。
3. Occupancy:占用率
Occupancy 表示一个 SM 上实际驻留的 Warp 数量与硬件允许的最大驻留 Warp 数量之间的比例。
公式:
影响 Occupancy 的因素包括:
- 每个线程使用的寄存器数量。
- 每个 Block 使用的 Shared Memory。
- 每个 Block 的线程数量。
- SM 硬件资源限制。
提高 Occupancy 有助于隐藏内存访问延迟,但并不意味着 Occupancy 越高性能就一定越好。
如果为了提高 Occupancy 而减少数据复用,或者导致更多重复计算,最终性能反而可能下降。
4. Kernel Fusion:算子融合
假设一个计算任务由三个操作组成:
如果分别执行乘法和加法,可能需要启动多个 Kernel,并多次读写中间结果。
Kernel Fusion 将多个操作合并到一个 Kernel 中执行。
flowchart TD
A["输入数据 x"] --> B["独立执行乘法 Kernel"]
B --> C["写入中间结果"]
C --> D["启动加法 Kernel"]
D --> E["写入最终结果"]
A --> F["融合 Kernel"]
F --> G["一次执行乘法和加法"]
G --> H["写入最终结果"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F