🏠 总目录📚 本教程 GPU 是什么 ← →

AI基础设施 · 02

一个 warp、一个 SM 和一张 GPU,究竟是什么包含关系?

SM 是包含运算与局部存储的组织层;warp 是线程执行组织。先分清包含、共享和执行,再解释分支与访存。

读完能判断:沿包含与共享关系读 GPU,区分线程组织、存储层级和执行顺序。

📑 本页目录(点开跳转)

02 · GPU 到底是什么

⏱ 26 分钟 | ⭐ 不需要写 CUDA,但要知道它长什么样


🎯 一句话

GPU 擅长让大量数据一起做相似的运算;它不保证把任何程序都加速。

假设程序要给 100 个数分别做同样的处理,例如给一批特征逐个加 1。只要每个输出只依赖自己的输入,就可以把 100 份工作分开。神经网络中也有大量可成批安排的乘加。

接着第 1 章的算力与带宽问题,本章只抓三件事:谁在算、数据放哪、为什么有时算不快。 先用这 100 个数区分响应和吞吐,再跟着它们走到一个 warp。


🆚 一、CPU vs GPU

CPU 怎么推进任务?把程序视为一串机器指令:按指令位置取指、译码,读取操作数,执行计算/访存/分支,再更新寄存器等程序状态和后续指令位置。复杂依赖和控制流会限制并行度,这正是下面对照的背景。

深入:用一个分支看执行顺序(可跳过)

这里从已经能够执行的机器指令开始。高级语言需经编译或由解释器等运行时推进,CPU 不直接理解源代码中的业务任务。

  1. 取指与译码:指令指针标记要执行的位置,取来的指令被解释为运算、访存或转移等操作;指令和数据也可能命中缓存。
  2. 读操作数并执行:教学设定寄存器里已有 2 与 3,加法得到 5;随后比较 5 是否大于 4。比较依赖加法的结果,不能凭更多算术单元消除这项依赖。
  3. 更新状态与控制流:此例条件为真,后续沿指定分支继续;否则沿另一条路径。结果可更新寄存器或由存储指令交给存储层次,不能把执行完成等同于文件已经持久化。

抽象步骤不是逐拍时间表:许多高性能 CPU 会流水重叠多条指令、预测分支并乱序执行就绪操作,再按架构规则提交结果。不能说每条指令固定一拍或硬件只能完全串行。本例只解释控制依赖,与下图的 GPU 吞吐取舍衔接。

自测:加法尚未产生结果时,后面的比较能直接使用 5 吗?不能;这是数据依赖。此例不涉及程序装载、OS 调度或中断/异常处理,也不是处理器实测。

依据:Intel 优化手册 Vol.2 §3.1(取指、乱序执行与顺序提交)。具体流水线宽度和行为以处理器型号为准。

CPUGPU核核核核缓存与控制逻辑复杂的分支预测 · 乱序执行偏重单线程响应偏重大量并行运算
看两边面积的侧重点:CPU 强调单线程响应,GPU 给并行运算更多资源。这是设计取舍示意,不是面积或核数的实测比例;GPU 也有缓存和调度逻辑。
比较什么 CPU 的侧重点 GPU 的侧重点
设计目标 尽快完成一条复杂任务 提高大量任务的总吞吐
常见优势 分支复杂、依赖强、任务较小 规模较大的并行运算
“核心”口径 能独立处理复杂指令流的 CPU 核 CUDA Core 等算术单元,不能与 CPU 核一对一比较
等待数据时 缓存、乱序执行等机制减少等待 缓存、数据复用与调度其他就绪 warp 配合

不要用“博士生和小学生”理解两者。 它们是不同的硬件组织方式,不是智能程度不同。CPU 也能并行,GPU 也能处理分支。

深度学习中的矩阵运算适合 GPU 的并行组织,专用矩阵单元和软件库也很重要。实际程序中,CPU 往往负责准备任务、调用运行时并提交工作,GPU 执行提交的内核(kernel),也就是在线程上运行的一段函数。例如,同一个加 1 内核可以让每个线程处理一个不同的数。

只处理一个数,和一批处理 100 个数

先看延迟(latency)。 从开始到拿到一个结果,等了多久?假设 CPU 逐个处理,每个用 5 μs。GPU 路径固定花 20 μs 在提交与等待等开销上,只处理一个数时,内核另用 2 μs。CPU 是 5 μs,GPU 路径是 20 + 2 = 22 μs。

再看吞吐(throughput)。 一段时间共交付多少结果?现在 100 个输入已准备好。假设 CPU 仍逐个处理,完成一批需 100 × 5 = 500 μs。GPU 一次提交整批,假设内核用 30 μs,合计 20 + 30 = 50 μs。各用 100 除以完成整批的时间,分别得 0.2 和 2 个结果/μs。

1 μs 是百万分之一秒。以上时间都是为解释口径而设的数字。这个例子中,单件延迟更长的路径反而能交付更高的批量吞吐。若 CPU 也采用向量化或多核,或者 GPU 路径需等凑批、来回搬数据,时间就要重新算。


🏗️ 二、GPU 的层次结构

先看包含关系:运算单元与局部存储在 SM 内;再看共享关系:多个 SM 连接 L2,继续访问显存。图示是逻辑层次,不是芯片物理布局。GPU:执行单元在 SM 内,L2 由 SM 共享GPU 内部一个 SM 内CUDA Core / Tensor Core寄存器 / Shared Memory / L1其他 SM并行执行L2 Cache:多个 SM 共享显存:HBM 或 GDDR,容量较大
先看包含关系:运算单元与局部存储在 SM 内;再看共享关系:多个 SM 连接 L2,继续访问显存。图示是逻辑层次,不是芯片物理布局。

看图时,先找谁能执行指令,再看它从哪里取数据:

为什么这里提 FlashAttention? 它会分块复用片上存储,减少中间结果往返显存;并不是整张注意力矩阵都能装进 Shared Memory。见第 8 章。

架构与示例数字依据:NVIDIA GPU 性能背景指南。

⭐ Tensor Core:为什么它改变了一切

Tensor Core 把一组矩阵乘加交给专用硬件,合适的运算可以有更高吞吐。

普通算术路径能分别做乘法和加法。矩阵乘加把许多这样的步骤写成 D = A×B + C。A、B 是相乘的两个输入矩阵,C 是要加上的已有结果,D 是新结果。A 的列数要等于 B 的行数,C 的形状要和乘积相同。

只手算一个输出位置:A 取一行 [2, 3],B 取一列 [4, 5],C 在该位置是 1。对应相乘再相加,得 2 × 4 + 3 × 5 + 1 = 8 + 15 + 1 = 24。真实矩阵乘加会批量计算许多这样的输出位置。常见教学图里的 4×4 来自早期硬件示例,实际指令的矩阵块大小依代际和指令而定。

以 A100 为例,以下是非稀疏理论峰值,不是一段训练程序的实测速度:

运算路径 峰值 怎么读
FP32 普通算术 19.5 TFLOPS 本表比较基准
TF32 Tensor Core 156 TFLOPS 峰值是上行的 8 倍,输入计算精度不同
BF16 / FP16 Tensor Core 312 TFLOPS 峰值是基准的 16 倍,不代表训练快 16 倍
INT8 Tensor Core 624 TOPS 整数运算,用 TOPS;不与浮点精度混为一谈

数字来源:NVIDIA A100 规格。带“稀疏”标记的峰值另有使用条件,本表没有使用它们。

混合精度为什么可能更快? 一方面,较小的数据类型减少显存占用与搬运;另一方面,合适的矩阵运算能使用高吞吐路径。它不是无条件的“免费午餐”,仍要检查数值稳定性与实际耗时,见第 6 章。

不是只有半精度才能用 Tensor Core。 TF32 也是例子;Ada 架构的 Tensor Core 还支持 FP8,但硬件支持不等于当前框架和算子已启用。

维度对齐是效率建议,不是统一的准入门槛。 NVIDIA 文档说明:cuBLAS 11.0、cuDNN 7.6.3 起,Tensor Core 不再要求所有相关维度必须对齐才能使用。对齐仍可能更高效,具体要求取决于数据类型、硬件和库版本;不能仅凭 4095 而不是 4096 就断定“退回 CUDA Core”。矩阵乘性能指南、Ada 调优指南。


🧵 三、执行模型:warp 和它的两个坑

从外框向内读组织层级;线程格仅列出首尾示例,不是说一个 warp 只有三个线程。这张图不表示执行先后。Grid 包含 block,block 包含 warpGrid一个 block在同一个 SM 上执行一个 warp:32 个线程线程 0线程 1线程 31…其他 block
从外框向内读组织层级;线程格仅列出首尾示例,不是说一个 warp 只有三个线程。这张图不表示执行先后。

回到 100 个数。CUDA 让程序先决定一次内核启动要开多少个线程块(block),以及每块有多少线程(thread)。线程可以执行同一段内核代码,每个线程用自己的编号找输入。一次启动的全部块叫网格(grid)。图里画的是一维布局的包含关系,块和线程都从 0 编号。

执行时,GPU 把一个块的线程安排到同一个 SM。SM 再把块内连续编号的线程按 32 个分成一组,称为线程束(warp)。块里的最后一组可以不满 32。一个 SM 能同时容纳多少块,要看寄存器、共享内存等资源。块编号也不规定它在哪个 SM 上或什么时候执行。CUDA 编程模型

怎么让 100 个数各有一个线程负责? 在这一维例子里,n 表示元素数,B 表示每块线程数。每个线程最多负责一个元素,所需块数是 n ÷ B 后向上取整。取 n = 100、B = 64,100 ÷ 64 = 1.5625,所以开 2 块。每块 64 ÷ 32 = 2 个 warp。

两块共 128 个线程,覆盖 100 个输入
块warp 0warp 1
块 0编号 0–31
处理 32 个
编号 32–63
处理 32 个
块 1编号 64–95
处理 32 个
编号 96–127
处理 4 个

设 b 是块编号,t 是块内线程编号。前面 b 块共有 b × B 个线程,再加块内偏移 t,就得到输入编号 i = b × B + t。块 1 的线程 35 得到 i = 1 × 64 + 35 = 99,正好处理最后一个数。下一线程得到 100,必须先检查 i < n,条件不满足就不能读写数组。

因此最后一个 warp 的 96–99 号线程参与加法,100–127 号线程不访问数据。两块一共启动 2 × 64 = 128 个线程,100 个有元素可做,另有 28 个没有。本例的派工覆盖比例为 100 ÷ 128 = 78.125%。它只统计本次谁拿到了输入,不能从中推出 GPU 有多忙或内核跑了多久。

下面用 Python 3 复算表格。外层枚举块,内层枚举块内 warp。start 是这一组的第一个全局编号,stop 是它后面第一个编号。用 min(stop, n) 截住有效范围,再用 max(0, ...) 处理整组没有输入的情况。这里的循环只列派工结果,不模拟 GPU 的执行顺序。

n = 100
block_size = 64
warp_size = 32
blocks = (n + block_size - 1) // block_size

for block in range(blocks):
    for warp in range(block_size // warp_size):
        start = block * block_size + warp * warp_size
        stop = start + warp_size
        useful = max(0, min(stop, n) - start)
        print(f"块 {block}, warp {warp}: {start}–{stop - 1}, {useful} 个")

launched = blocks * block_size
print(f"派工: {n}/{launched} = {n / launched:.3%}")

// 对非负整数做整除,先加每块线程数减 1 就能把有余数的商进一。100 个输入时,代码依次输出表中的 32、32、32、4,最后输出 派工: 100/128 = 78.125%。把 n 改为 96,最后一个 warp 就没有可处理的元素。这段演示假定输入非空、块大小是 32 的整数倍,无需 GPU 或第三方包。

同一个 warp 中,多个活跃线程可以接到相同指令,各自用不同的数据执行。这种组织叫单指令多线程(Single Instruction, Multiple Threads,SIMT)。当各线程需要走不同路径时,只有属于当前路径的线程参与那部分工作。较新架构支持独立线程调度,程序需要同步时仍要显式表达,不能假定同组线程始终齐步。CUDA SIMT 与独立线程调度

坑 ① warp divergence(分支发散)

同一个 warp 走不同分支,可能让部分执行通道暂时闲着。慢多少要看分支里的工作。

继续看前面的 warp 0。现在让偶数编号线程执行路径 A,奇数编号线程执行路径 B。两边各有 16 个线程。下表只数路径各自参与的线程,不表示哪条路径先运行。

当前执行的分支 哪些线程参与 另一些线程
A 偶数编号线程 不执行 A 的结果写入
B 奇数编号线程 不执行 B 的结果写入

假设 A 只有 1 条指令、B 有 3 条,教学模型把两条路径分别发给本组。按每条指令的 32 个可参与位置计,4 条指令一共有 32 × (1 + 3) = 128 个位置,实际参与的是 16 × 1 + 16 × 3 = 64 个。这次分支段的参与比例为 64 ÷ 128 = 50%。前面的 78.125% 数的是整个网格谁分到了输入,两处的分母不同。

如果 A、B 工作量相近,分别执行两条路径通常比所有线程一起做其中一条费更多发指令工作。实际耗时还受路径长度、编译器的谓词化(用条件标记哪些线程生效)以及访存等待影响,50% 不等于耗时必定翻倍。

下一步不是删掉所有 if,而是用性能分析工具确认分支分歧是否真是瓶颈。

坑 ② 非合并访存(uncoalesced access)

同一组线程要的数据越分散,可能需要搬入越多用不上的数据。

继续看一个满员 warp。假设每个线程各读一个不同且对齐的 4 字节数,设备按 32 字节扇区处理这次访存,共有 32 × 4 = 128 个有效字节。从 32 字节对齐的起点算,若地址偏移依次为 0、4、…、124,每个扇区放 32 ÷ 4 = 8 个数,所以覆盖 32 ÷ 8 = 4 个扇区。若偏移变成 0、32、…、992,每个线程都在不同扇区,一共覆盖 32 个。

地址分布 覆盖的 32 字节扇区 请求覆盖的数据量
连续,起点按 32 字节对齐 4 个 128 字节
每个线程落到不同扇区 最多 32 个 最多 1024 字节

把覆盖的扇区数乘以 32 字节,连续方案是 4 × 32 = 128 字节,分散方案是 32 × 32 = 1,024 字节。后者本次只需要 128 字节,因此覆盖数据中的有效字节比例为 128 ÷ 1,024 = 1/8。这里统计的是这次请求的扇区覆盖,显存实际流量还要考虑缓存。

这也不是程序必然慢 8 倍:缓存命中、相邻 warp 的复用、对齐与其他瓶颈都会影响时间。NVIDIA 全局内存访问说明。

它和 PyTorch 的关系:先区分“布局”与“访问方式”。 转置通常只改变 stride(相邻元素的地址步长),不搬数据;contiguous() 可以复制成连续布局。但访问能否合并,还取决于算子怎样把数据分配给线程。

下面只观察布局与形状,不测 GPU 性能。安装 PyTorch 后可在 CPU 运行;有 CUDA 时使用 GPU。矩阵缩小是为了方便观察,原理不依赖 4096 这一大小。

import torch

device = 'cuda' if torch.cuda.is_available() else 'cpu'
x = torch.arange(16, dtype=torch.float32, device=device).reshape(4, 4)
w = torch.ones(4, 2, device=device)
y = x.t()                      # 转置视图:没有重排底层数据
y_contiguous = y.contiguous()  # 复制为连续布局

z = y @ w                      # 矩阵乘可以接受这个非连续输入
z_contiguous = y_contiguous @ w

print("device:", device)
print("stride:", y.stride(), y_contiguous.stride())
print("contiguous:", y.is_contiguous(), y_contiguous.is_contiguous())
print("shape:", tuple(z.shape))
print("same result:", torch.equal(z, z_contiguous))

你应看到什么? stride 分别为 (1, 4)、(4, 1),连续性分别为 False、True;两个输出形状均为 (4, 2),本例的整数值可精确表示,结果相同。

不要因此到处补 contiguous()。 矩阵乘库可能直接支持转置布局;一次额外复制反而会增加时间。性能比较要包含复制成本,并按第 4 章的方法测量。

为什么调度其他 warp 能掩盖延迟? 当一个 warp 等数据时,SM 可以执行另一个已经就绪的 warp。但驻留数量多(occupancy 高)不等于就绪任务足够,也不保证更快。

小 batch 有时不能提供足够并行工作;有时瓶颈却是访存、启动开销或形状。不要仅凭 batch 小就确定原因。


📊 四、几张主流卡的关键数字

这里保留 A100、H100、RTX 4090 三个代际示例,用于学习读规格,不是当前购买推荐。

比较项 A100 80GB SXM H100 SXM RTX 4090
BF16 Tensor Core,FP32 累加 312 TFLOPS 约 989 TFLOPS 约 165 TFLOPS
FP8 Tensor Core 不支持 约 1979 TFLOPS 支持;须区分累加精度与软件支持
显存 80 GB HBM2e 80 GB HBM3 24 GB GDDR6X
显存带宽 约 2.04 TB/s 3.35 TB/s 约 1.01 TB/s
NVLink 标称双向汇总带宽 600 GB/s 900 GB/s 无 NVLink

表内算力均按非稀疏峰值理解。RTX 4090 的约 165 是 FP32 累加口径;不能拿其他累加精度或稀疏峰值混比。来源:A100、H100、RTX 4090、Ada 架构规格附录。

卡间通信要另算。 RTX 4090 走 PCIe 4.0;x16 链路理论上约 31.5 GB/s 单向、63 GB/s 双向合计,不能把“双向约 64”当成单向 GPU 间有效速度。实际还受主板拓扑、通道宽度、驱动及点对点传输支持影响。

这不等于多卡训练“基本不可用”。 数据并行与张量并行的通信需求不同;24 GB 容量可能先成为限制,也可能是频繁通信限制扩展。应实测目标任务,再看第 12 章如何分析通信。

FP8 也不是切个开关就稳。 它对表示范围和精度的取舍更激进,需要合适的缩放与数值验证;缩放粒度依实现而定,不只一种 per-tensor 方案。


🧰 五、你实际会碰到的抽象层

先写框架运算,再定位具体实现;不要把所有库当成每次都会依次经过的步骤。

先使用现有实现。确认瓶颈在某个算子后,再考虑 CUDA 或 Triton;Triton 使用 Python 风格接口,但仍需要理解并行与访存,见第 7 章。

下面的命令用于已安装 NVIDIA 驱动的环境;部分监控功能受操作系统和设备支持限制。

# 三个你一定会用到的命令
nvidia-smi                    # 看显存占用、利用率、温度、功耗
nvidia-smi topo -m            # ⭐ 看卡间互联拓扑(NVLink 还是 PCIe)
nvidia-smi dmon -s pucm       # 持续监控

GPU-Util 100% 不等于算力用满。 它描述采样期间 GPU 执行 kernel 的时间占比,一个受访存限制的 kernel 持续运行,也能让该值很高。

下一步结合任务吞吐、延迟、显存带宽与算子分析;训练时还可参考 MFU。MFU 不是所有任务唯一正确的指标,见第 4 章。


🔗 和站内其他章的关系

相关的地方 这里的位置
ML 基础第 15 章 .to('cuda') 把张量与运算放到 GPU
第 1 章 算力与带宽 判断是否被数据搬运限制
第 3 章 显存 / L2 / Shared Memory 的层次
第 6 章 数据大小、数值稳定性与运算路径
第 8 章 分块复用片上存储,减少显存往返

✅ 检查点

  1. CPU 和 GPU 的设计目标有什么侧重?为什么不能直接比“核心数”?
  2. GPU 靠什么掩盖内存延迟?小 batch 一定是 warp 不够吗?
  3. Tensor Core 做什么?A100 上的“16 倍”是什么口径?
  4. 混合精度为什么可能快?矩阵维度不对齐就一定不能用 Tensor Core 吗?
  5. 如果改为处理 97 个数,每块仍开 64 个线程,需要几个块?最后一个 warp 有几个线程可以读写数据?
  6. 什么是 warp?例子中的 50% 参与比例,为什么不能说成 GPU-Util 50%?
  7. 本章连续与分散访存各覆盖多少个扇区?contiguous 能保证算子访问合并吗?
  8. 比较 RTX 4090 与数据中心卡,除算力还要看什么?
  9. 为什么 GPU-Util 100% 不能证明没有优化空间?
👀 答案
  1. CPU 偏重复杂任务的响应,GPU 偏重大量运算的吞吐。CPU 核与 CUDA Core 的功能口径不同,不能一对一比较。
  2. 缓存、数据复用及调度就绪 warp 配合。小 batch 可能并行度不足,也可能受访存、形状或启动开销限制,需要测量。
  3. Tensor Core 处理特定矩阵乘加。312 / 19.5 = 16 比的是 A100 的 BF16 Tensor Core 与 FP32 普通算术理论峰值,精度不同,不是训练加速承诺。
  4. 数据更小可减少搬运,合适的矩阵运算也可走高吞吐路径。TF32 同样能用 Tensor Core;现代库中对齐常是效率因素,不是统一的硬性门槛。
  5. 97 ÷ 64 向上取整为 2 块。最后一个 warp 的编号是 96–127,只有编号 96 小于 97,所以只有一个线程可以读写。
  6. CUDA warp 是 32 个执行位置组成的一组,末组可以不满。本例的 50% 是分支指令中实际参与的位置占比,GPU-Util 则按采样窗口内内核活跃时间计算。分歧的耗时还要结合实现和访存判断。
  7. 在本章对齐、每线程读 4 字节的例子中,连续覆盖 4 个扇区,完全分散可覆盖 32 个;后者有效字节比例是 1/8。张量连续性和线程访问方式是两件事,不能仅看 contiguous 判断速度。
  8. 显存容量、显存带宽、互联与软件支持。PCIe 的单双向口径要分清;多卡效率取决于并行方案和通信量,不是“没有 NVLink 就不能训练”。
  9. GPU-Util 主要描述 kernel 活跃时间;仍可能受访存或低效算子限制。应结合吞吐、延迟和性能分析,训练时再看 MFU 等指标。

本节回顾

⚡ 走神救援

先记住这几件事

下一节 👉 03-显存与带宽墙.md ⭐

打卡记录保存在你的浏览器里,首页能看到总进度