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

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

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

在这里插入图片描述

🌈 say-fall:个人主页
🚀 专栏:《手把手教你学会C++》 | 《系统深入Linux操作系统》 | 《数据结构与算法》 | 《小游戏与项目》
💪 格言:做好你自己,才能吸引更多人,与他们共赢,这才是最好的成长方式。

前言

我们了解完多线程,把 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 年发布到现在,硬件换了好几代,编程模型跟着一起长。

时间架构 / 版本关键变化
2006G80 / CUDA 1.0首次开放 C 语言写 GPU,GPGPU 起步
2007CUDA SDK 1.0支持 Windows 与 Linux
2008CUDA 2.0加入双精度支持
2010FermiECC 内存、可配置 L1 与统一 L2、并发内核
2012Kepler动态并行
2014Maxwell能效优化
2016PascalNVLink 互连
2017Volta引入 Tensor Core
2020Ampere稀疏化加速
2022HopperTransformer 引擎
2025CUDA 13.1Tile 编程模型

三个值得单拎出来的节点

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

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--