【CUDA编程】GPU通用计算:CPU与GPU的设计差异、线程网格与Warp执行、内存层次与合并访问、架构演进与工具链优化

前言
我们了解完多线程,把 CPU 上那几个核都用上之后,数据量再往上加,单靠多开几个线程就顶不住了。这一篇换个方向,看看 GPU 上的并行计算,也就是英伟达做了很多年的 CUDA。
刚学完多线程面对 GPU 可能会有这些疑问:同样是把任务拆开算,为什么 GPU 能比 CPU 快几十倍?成千上万个线程写在代码里,到底怎么组织才不乱?
| 现象 | 你可能以为的原因 | 真正发生的事情 |
|---|---|---|
| GPU 算得快 | 主频比 CPU 高 | 核心数量多,靠吞吐量把同一份计算摊到大量数据上 |
| 一个循环能跑进显卡 | 编译器自动把循环改成并行 | 程序员自己把任务拆成网格、线程块和线程,再写成内核 |
| 线程之间能配合 | 所有线程共用一块内存 | 只有同一个线程块能靠共享内存协作、用同步栅栏对齐 |
| 线程加得越多越快 | 并行度上去了速度跟着涨 | 全局内存带宽和访存方式先撞到瓶颈,线程再多也吃不满 |
问题来了: Grid、Block、Thread 这三层各管什么?Warp 为什么固定 32 个线程?共享内存比全局内存快在哪?所谓的合并访问又在合并什么?
答案就是——分层 + 批量!CUDA 把一份大任务先切成网格,再切成线程块,最后落到每个线程处理一小份数据;硬件把这些线程按 32 个一组编成 Warp,用同一条指令驱动一批数据,这就是 SIMT。而真正卡住速度的,往往不是线程数,是数据能不能按连续地址从全局内存搬进来。
通过本文,你将掌握:
| 技能 | 应用场景 |
|---|---|
| CPU 与 GPU 的设计差异 | 判断手上的任务值不值得搬到 GPU 上跑 |
| Grid / Block / Thread | 把一份数据拆成成千上万个并行任务,算清每个线程的下标 |
| Warp 与 SIMT 执行模型 | 看懂分支分歧为什么会拖慢内核 |
| 五级内存层次 | 按作用域和速度选内存,别把所有数据都塞进全局内存 |
| 合并访问与 bank 冲突 | 写出能吃满带宽的访存代码 |
| NVCC 与 Nsight 工具链 | 编译 .cu、调内核、定位性能瓶颈 |
| CUDA-X 加速库 | 常见运算直接调 cuDNN / cuBLAS,不用自己写内核 |
前置知识: C / C++ 基础、线程与并发的直观认识、内存层次和缓存的概念。
文章目录
正文:
一、CUDA 是什么
从显卡到通用计算
GPU 最早只负责画像素,图形流水线是固定的,想让它算点别的东西,得把数据伪装成纹理、把计算伪装成渲染。2006 年英伟达推出 CUDA(Compute Unified Device Architecture,统一计算设备架构),第一次让程序员直接用 C 语言写跑在 GPU 上的代码,不用再绕图形接口,GPU 通用计算(GPGPU)这才真正落地。
CUDA 不是一块芯片,也不是一个函数库,它是英伟达给出的并行计算平台和编程模型:一边规定了硬件怎么组织大量核心和内存,一边规定了软件怎么把任务拆成线程、怎么写内核函数、怎么在主机和设备之间搬数据。
放到实际工程里,它解决的三件事很直白:
- 提速:适合并行的那部分计算,相对 CPU 能拿到几十倍甚至上百倍。
- 写得动:C、C++、Python、Fortran 都能用,不用去碰汇编或者图形 API。
- 用得广:科学计算、深度学习、图像和金融里的数值模拟都吃这一套。
CPU 和 GPU 的设计差别
两者的差别不在谁更先进,在设计目标就不一样。CPU 追求把一个任务尽快做完,GPU 追求同一时间把一大批任务一起做完。
| 特性 | CPU(中央处理器) | GPU(图形处理器) |
|---|---|---|
| 核心数量 | 少量强大核心,通常 2~64 个 | 大量简单核心,成百上千个 |
| 设计目标 | 低延迟,快速完成单个任务 | 高吞吐量,同时处理大量任务 |
| 缓存策略 | 多级复杂缓存 L1 / L2 / L3 | 简单缓存,加上大量高速共享内存 |
| 适合任务 | 串行任务、复杂控制逻辑 | 并行任务、大规模数据处理 |
所以分任务的时候可以按这个来:串行步骤多、分支复杂、控制逻辑绕的那部分留给 CPU;数据量大、每个元素做同样运算的那部分交给 GPU。CPU 负责调度和准备数据,GPU 负责批量算,这就是 CUDA 程序里主机(Host)和设备(Device)的分工。
这里要分清: CPU 上的并行是几个核分时复用,GPU 上的并行是几千个线程真的同时在跑,线程的数量级不是一回事。
二、编程模型:线程怎么组织
Grid、Block 与 Thread
CUDA 把一次内核启动要跑的所有线程分三层,从上到下是网格、线程块、线程。
| 层次 | 组成 | 能共享什么 | 怎么同步 |
|---|---|---|---|
| Grid(网格) | 若干个 Block | 全局内存,所有线程都能访问 | 内核之间靠流或事件,块之间不同步 |
| Block(线程块) | 若干个 Thread | 共享内存,块内线程可见 | __syncthreads() |
| Thread(线程) | 最小执行单元 | 寄存器,线程私有 | 无 |
- 线程:每个线程跑同一份内核代码,靠自己的索引取不同的数据,算不同的那一小块。
- 线程块:一组线程,能一起把数据搬进共享内存,也能用同步栅栏对齐进度。
- 网格:所有线程块合起来就是这次内核的完整任务。
写内核的时候,blockIdx、threadIdx、blockDim 这几个内置变量就是用来算全局下标的,常见写法是 int i = blockIdx.x * blockDim.x + threadIdx.x;。程序员写的时候有可能出现这个问题:下标算漏了 blockDim,结果好几个线程去写同一个位置。
Warp 与 SIMT
线程块往下还会被硬件再切一刀。Warp(线程束)是 GPU 执行的基本单位,一组 32 个线程,Warp 里的线程同一时刻执行同一条指令,但各自操作不同的数据,这叫 SIMT(单指令多线程)。
它和 SIMD 不一样的地方在调度:每个线程有自己独立的程序计数器和寄存器状态,可以走自己的分支。代价是分支分歧——同一个 Warp 里一部分线程走 if、另一部分走 else,硬件只能把两条路径串行各执行一遍,各自屏蔽掉不相关的线程,这一段的吞吐就掉下来了。所以内核里尽量让同一个 Warp 的线程走同一条路。
Warp Scheduler 负责把线程块拆成 Warp 再喂给执行单元。现代架构(Ampere、Hopper)又加了异步执行和线程块级别的并行,配合 CUDA 流可以让数据传输和计算重叠起来,不让显卡空等内存。
内存层次
CUDA 给了好几级内存,作用域和速度都不一样,选错一级性能就差一大截。
| 内存类型 | 作用域 | 速度 | 容量 | 典型用途 |
|---|---|---|---|---|
| 寄存器 | 线程私有 | 最快 | 极小 | 临时变量、频繁访问的数据 |
| 共享内存 | 线程块内共享 | 快 | 适中 | 线程协作、数据复用 |
| 全局内存 | 所有线程 | 慢 | 大 | 输入输出数据 |
| 常量内存 | 所有线程 | 快(有缓存) | 小 | 只读常量数据 |
| 纹理内存 | 所有线程 | 快(有缓存) | 大 | 特定访问模式优化 |
主机内存和显存是分开的,数据要先 cudaMemcpy 到设备上,算完再拷回来。这两次拷贝本身很贵,程序写的时候要尽量减少次数,能留在设备上复用的就别来回搬。
内存优化:合并访问与 bank 冲突
性能调优的大头在访存,常用的几件事:
① 合并访问:让相邻线程访问相邻的全局内存地址,一次事务就能把一整段取回来,带宽才吃得满。
② 减少 bank 冲突:共享内存分成多个 bank,多个线程同时打同一个 bank 就得排队,写下标的时候要错开。
③ 按访问模式选内存:只读常量放 __constant__,块内复用放 __shared__,别一股脑全用全局内存。
④ 异步传输:用流把数据拷贝和内核执行排到不同队列,让两者重叠。
⑤ 复用数据:能搬进共享内存算多次的,就别反复读全局内存。
矩阵乘法是这套思路最典型的例子:把 A、B 各切一块进共享内存,块内线程一起加载、同步、算完再换下一块。
// 用共享内存分块做矩阵乘法
__global__ void matrixMulShared(float *A, float *B, float *C, int width) {
__shared__ float As[TILE_WIDTH][TILE_WIDTH];
__shared__ float Bs[TILE_WIDTH][TILE_WIDTH];
int bx = blockIdx.x; int by = blockIdx.y;
int tx = threadIdx.x; int ty = threadIdx.y;
int row = by * TILE_WIDTH + ty;
int col = bx * TILE_WIDTH + tx;
float sum = 0.0;
for (int m = 0; m < width / TILE_WIDTH; ++m) {
// 块内协作把子矩阵加载进共享内存
As[ty][tx] = A[row * width + (m * TILE_WIDTH + tx)];
Bs[ty][tx] = B[(m * TILE_WIDTH + ty) * width + col];
__syncthreads(); // 等所有线程加载完
for (int k = 0; k < TILE_WIDTH; ++k) {
sum += As[ty][k] * Bs[k][tx];
}
__syncthreads(); // 等所有人算完,再覆盖下一块
}
C[row * width + col] = sum;
}
两个 __syncthreads() 都不能省:第一个保证读到的子矩阵是完整的,第二个保证没人还在用旧数据的时候就被下一次加载覆盖了。
三、架构演进:从 G80 到 Hopper
CUDA 从 2006 年发布到现在,硬件换了好几代,编程模型跟着一起长。
| 时间 | 架构 / 版本 | 关键变化 |
|---|---|---|
| 2006 | G80 / CUDA 1.0 | 首次开放 C 语言写 GPU,GPGPU 起步 |
| 2007 | CUDA SDK 1.0 | 支持 Windows 与 Linux |
| 2008 | CUDA 2.0 | 加入双精度支持 |
| 2010 | Fermi | ECC 内存、可配置 L1 与统一 L2、并发内核 |
| 2012 | Kepler | 动态并行 |
| 2014 | Maxwell | 能效优化 |
| 2016 | Pascal | NVLink 互连 |
| 2017 | Volta | 引入 Tensor Core |
| 2020 | Ampere | 稀疏化加速 |
| 2022 | Hopper | Transformer 引擎 |
| 2025 | CUDA 13.1 | Tile 编程模型 |
三个值得单拎出来的节点
Fermi(2010):第一次支持 ECC 内存,计算结果更可靠;L1 缓存可配置,L2 统一;支持多个内核并发执行,GPU 不再一次只干一件事。
Volta(2017):加了专门给深度学习做矩阵运算的 Tensor Core;INT32 和 FP32 执行管线分开;内存子系统带宽也提上去了。
Hopper(2022):Transformer 引擎针对大模型负载优化;第二代 MIG 多实例 GPU;线程块簇级别的分布式共享内存(DSMEM)和异步执行增强。
这几代看下来有一条线很清楚:核心数在涨,但每一代真正花力气的都是「怎么让数据更快喂到核心上」,所以内存和调度一直比算力更值得关注。
四、用在哪:应用场景与 CUDA-X
主要场景
| 应用领域 | 典型案例 | 性能提升 |
|---|---|---|
| 深度学习 | 神经网络训练、推理 | 数十至数百倍 |
| 科学计算 | 分子动力学、流体力学 | 10~100 倍 |
| 金融分析 | 蒙特卡洛模拟、风险评估 | 20~50 倍 |
| 图像处理 | 实时渲染、医学成像 | 5~20 倍 |
| 加密货币 | 挖矿运算 | 视算法而定 |
这些数字只能当参考,实际能拿到多少,取决于算法能不能拆开、访存是不是连续、数据搬运占多大比例。2012 年 AlexNet 在 ImageNet 上用 GPU 训练跑出突破,就是深度学习和 CUDA 互相推着走的一个节点:模型需要大量矩阵运算,GPU 正好擅长这个。
CUDA-X 加速库
自己从零写内核不是常态,英伟达在 CUDA 之上铺了一层现成的库,合起来叫 CUDA-X:
- cuDNN:深度神经网络的原语,卷积、池化这类操作直接用。
- cuBLAS:线性代数运算。
- cuFFT:快速傅里叶变换。
- cuSPARSE:稀疏矩阵运算。
- Thrust:C++ 并行算法库,写法接近 STL。
这些库针对各代架构调过,多数情况下比自己手写的第一版内核更快,也少踩访存的坑。
五、工具链与性能调优
从 .cu 到可执行
.cu 文件由 NVCC 编译,先产出 PTX 中间代码,再由驱动编译成具体 GPU 的机器码。围绕这条链路,配套的工具是:
- CUDA Runtime:运行时接口,管内存分配、内核启动、流和事件。
- 驱动程序:和硬件通信的那一层。
- cuda-gdb:内核级调试器。
- Nsight Compute:看单个内核的指令、访存和占用率。
- Nsight Systems:看整个程序的时间线,找出主机和设备哪里在互相等。
调优的一般顺序是先用 Nsight Systems 看全局,确认瓶颈落在哪个内核,再用 Nsight Compute 抠这个内核的细节。
性能优化几件事
① 并行度给够:线程数要够多,才能用计算把内存延迟藏起来。
② 访存先改:合并访问、避开 bank 冲突、能用共享内存复用就复用。
③ 指令上省一点:用 __expf(x) 这类快速数学函数,少写分支分歧,必要时循环展开。
④ 异步执行:用流让计算与传输并行,用事件保证该等的顺序。
⑤ 算法挑对:选本身能并行化的算法,分治比串行递推更适合 GPU。
异步这套写法用的是 cudaMemcpyAsync 加带流参数的内核启动:
cudaStream_t stream;
cudaStreamCreate(&stream);
// 主机到设备,异步
cudaMemcpyAsync(d_A, h_A, size, cudaMemcpyHostToDevice, stream);
// 内核排进同一个流
myKernel<<<blocks, threads, 0, stream>>>(d_A, d_B, d_C);
// 结果拷回主机,同样异步
cudaMemcpyAsync(h_C, d_C, size, cudaMemcpyDeviceToHost, stream);
// 等这个流上的活干完
cudaStreamSynchronize(stream);
cudaStreamDestroy(stream);
同一个流里的操作按入队顺序执行,不同流之间才能真的重叠。程序员写的时候有可能出现这个问题:把有依赖的两步放进不同流,又没加事件同步,读到的还是没算完的数据。
六、后面的方向
CUDA 还在往几个方向走:
- Tile 编程模型:CUDA 13.1 引入基于 Tile 的写法,把大规模并行的拆分交给更高层的抽象。
- 工具链用 AI 辅助:代码生成和性能调优开始借机器学习。
- 多 GPU 协同:编程模型和卡间通信效率继续加强。
- 能效:性能要涨,功耗要压。
| 挑战 | 对应的机会 |
|---|---|
| 编程复杂 | 更高层的抽象,比如 Tile |
| 内存墙 | HBM3e 这类新型内存 |
| 功耗限制 | 面向能效的架构设计 |
| 生态竞争 | 统一计算平台继续往外扩 |
整体方向是从通用计算往生成式 AI 负载倾斜,但底下那套线程层次、内存层次和访存规则没变,还是写内核时绕不开的东西。
七、小结
把这篇收一下:
① CUDA 是英伟达给的并行计算平台和编程模型,不是某个库,也不是一句编译选项。
② 核心思路是把大任务拆成 Grid / Block / Thread,硬件按 Warp 用 SIMT 批量执行同一条指令。
③ 性能瓶颈大多在内存,合并访问、共享内存复用和异步传输比堆线程数管用。
④ 真要干活,先看看 CUDA-X 里有没有现成的库,再用 Nsight 定位瓶颈,不要一上来就手写内核。
搞清楚这几点,再去看别人的 CUDA 代码,<<<>>> 里那两个数字为什么这么填、共享内存为什么开这么大,就能自己说出理由了。
- 本节完…
📝 作者:say-fall | 编辑:say-fall | 🌟 原创不易,如果对你有帮助,记得 👍 点赞 + ⭐ 收藏 哦!
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/say_fall/article/details/170779250




