同一个 1024 阶矩阵乘法,交给 CPU 单线程跑,常见的结果是零点几秒到几秒;交给一块像样的 GPU,常见结果是几十毫秒。两个数字差两个数量级,很多人第一次看到会以为 GPU 的主频高得离谱,实际上 GPU 的核心频率往往比 CPU 还低。
但同一个 GPU,让它处理一百个小任务,每个任务只算几微秒,总时间反而比 CPU 逐个做还长。这不是 GPU 突然变笨了,是它的优势有前提:任务要足够多、足够整齐,而且数据已经在显存里。
本机没有可用的 GPU 计算环境,下面的架构原理和量级来自公开资料,具体跑分、显存带宽和 kernel 时间均未在本机实测。唯一真跑的是 Python 写的软件模拟,用来演示分支发散怎么吃掉吞吐,它模拟的是规则,不是 GPU 硬件。
GPU 里到底有什么
把 GPU 拆开看,主体是大量的流处理器。每个流处理器不算聪明,能做的运算有限,但它数量多,而且共享取指和调度。GPU 里还有寄存器堆、片上共享内存、一级缓存、显存控制器和调度器,负责把成千上万个线程轮流送进执行单元。
CPU 的核像几个熟练工,每个人能独立处理复杂的活;GPU 像一条很长的流水线,每个工位只会几个简单动作,但同时有几千件产品在走。熟练工遇到不确定的活能自己判断,流水线遇到规格不一致的产品就得停下来调整。
GPU 的调度器还有一个重要任务:隐藏延迟。显存访问要等几百个周期,GPU 不等,直接切换到另一个准备好的线程组。只要线程足够多,执行单元就一直有活干。这也是为什么 GPU 需要大量线程,线程少了就掩盖不住延迟。
除了计算单元,GPU 里还有纹理单元、光栅化单元和显示输出接口,它们原本是给图形管线用的。通用计算兴起以后,纹理缓存也被拿来加速只读数据访问,图形和计算共用同一套硬件,只是走不同的路径。所以一块显卡既能玩游戏,也能跑训练,底层不是两套芯片。
SIMT:一条指令,多个线程
SIMT 是 Single Instruction Multiple Threads,单指令多线程。GPU 把线程按固定大小分组,NVIDIA 叫 warp,通常是 32 个线程;AMD 叫 wavefront,常见 64 个。一组线程共享同一个程序计数器,同一拍执行同一条指令,只是各自的数据不同。
这和 CPU 的 SIMD 有点像,但不一样。SIMD 是一条指令处理一个向量寄存器里的多个数据,程序员要显式打包;SIMT 是每个线程有自己的寄存器和状态,硬件把它们锁步执行。写代码时看起来像普通的多线程,硬件却按组调度。
一个 warp 里的线程各自有寄存器,但共享程序计数器和取指单元。这样取一条指令就能喂给三十多个线程,前端开销被摊薄。代价是线程之间必须步调一致,谁也不能单独跑到别的地方,遇到分支只能整组一起选路。
锁步执行带来一个硬约束:一组线程如果走到不同的分支,硬件不能同时执行两条路,只能先执行一条,把走另一条路的线程遮住,再执行另一条。这个现象叫分支发散。发散不改变结果,但会拉长执行时间。
分支发散:一个 if 能让吞吐减半
假设一个 warp 有 32 个线程,代码里有一个 if/else,两边各做一次运算。如果 32 个线程全走同一边,硬件执行一遍就完事;如果有一部分走 if、一部分走 else,硬件要把两遍都执行,每遍只让对应的线程有效。最坏情况下,工作量翻倍,有效吞吐减半。
更麻烦的是概率。只要有一个线程和其他线程不同,整个 warp 就发散。32 个线程、每个线程有百分之一的概率走另一条路,看起来很小,但「至少有一个不同」的概率是 1 减去 0.99 的 32 次方,大约是 27.6%。也就是说,百分之一的分支概率,能让超过四分之一的 warp 发散。
下面这段 Python 用随机数模拟这个规则。它不是 GPU 实测,只是按「同组必须走同一条路」的规则算有效吞吐:
import random
LANES = 32
def simulate(p_taken, trials=200000, seed=7):
rng = random.Random(seed)
useful = 0
cycles = 0
divergent = 0
for _ in range(trials):
taken = sum(1 for _ in range(LANES) if rng.random() < p_taken)
useful += LANES
if taken == 0 or taken == LANES:
cycles += 1
else:
cycles += 2
divergent += 1
return useful / (cycles * LANES), divergent / trials
print("p(taken) divergent-warps effective-throughput")
for p in [0.0, 0.01, 0.05, 0.1, 0.25, 0.5, 0.9]:
eff, div = simulate(p)
print(f"{p:8.2f} {div:14.3f} {eff:19.3f}")
本机 Python 3.15 实际输出:
p(taken) divergent-warps effective-throughput
0.00 0.000 1.000
0.01 0.276 0.784
0.05 0.806 0.554
0.10 0.966 0.509
0.25 1.000 0.500
0.50 1.000 0.500
0.90 0.966 0.509
分支概率到 5% 时,八成以上的 warp 都发散,有效吞吐掉到 0.554;到 25% 时几乎全部发散,吞吐稳定在 0.5。注意 0.9 那行又回到 0.509,因为「大部分线程走 if」和「大部分走 else」在发散上是对称的,只要不是全体一致,代价一样。
减少发散的办法不是把所有 if 都删掉,而是让同一组线程尽量走同一条路。把分支条件按线程编号分组,让相邻线程处理相似的数据;把短的 if/else 改写成条件赋值或查表;把不同分支的任务拆成不同的 kernel。这些做法都能把「一组里有人走另一条路」的概率降下来。
线程层次:线程、warp、块、网格
GPU 的线程不是散着跑的,它们有明确的层级。最底层是线程,几个线程组成一个 warp 或 wavefront,若干 warp 组成一个线程块,block,所有块组成一个网格,grid。块内可以用共享内存和同步,块之间默认不能直接通信。
这个层次决定了怎么写代码。需要线程间交换数据时,先放进共享内存,再同步;不需要交换时,就让每个线程独立算,减少同步。块的大小要配合硬件,太小浪费调度槽位,太大则占用率受限。
占用率,occupancy,指的是实际活跃的 warp 数占硬件上限的比例。占用率太低,延迟藏不住;但占用率也不是越高越好,寄存器用得多、共享内存占得满,都会限制能同时驻留的块数。优化时要在寄存器和并行度之间找平衡。
共享内存是块内线程交换数据的地方,容量只有几十 KB,但延迟比显存低得多。用它做矩阵分块,可以先把一块数据搬进来,多个线程反复读,减少对显存的访问。用完要同步,同步点太多会抵消收益,所以块的大小和分工要一起设计。
显存带宽:算得再快也要喂得饱
GPU 的计算单元很宽,但数据要从显存搬过来。显存带宽是每秒能搬多少字节,常见单位是 GB/s。矩阵乘法这类任务,每做一次乘加要读两个数、写一个结果,如果每次都直接读显存,带宽很快就不够用。
解决办法是分块复用。把矩阵切成小块,装进共享内存,块内反复使用,减少对显存的访问。这样算术强度上去了:每搬一字节能做好几次乘加。算术强度是计算量与字节数的比值,它决定了任务到底是算力受限还是带宽受限。
可以用一个粗略的屋顶线来记:芯片有一条算力上限和一条带宽上限,任务落在哪条线下面,就受哪个限制。大矩阵乘法可以做到算力受限,逐元素操作、激活函数、小 batch 推理往往先撞带宽墙。买 GPU 只看 TFLOPS 不看带宽,容易踩坑。
访存还有一个「合并访问」的讲究。一个 warp 的 32 个线程如果访问连续地址,硬件可以把它们合成一两次大事务;如果每个线程跳到很远的地方,就变成 32 次独立事务,带宽利用率暴跌。所以数组布局要尽量让相邻线程读相邻元素,结构体数组和数组结构体的选择也受这条影响。
启动开销和数据搬运:小任务为什么不划算
GPU 的 kernel 不是免费的。每次启动要经过驱动、命令队列和硬件调度,常见开销是几微秒到几十微秒。数据还要从主机内存拷到显存,算完再拷回来,走 PCIe 总线,带宽比显存低一个量级。任务本身如果只有几微秒,这些固定开销就占了大头。
按一组假设参数算:一百个小任务,CPU 每个 30 微秒,总共 3 毫秒;GPU 每个任务要 10 微秒启动、25 微秒传输、8 微秒计算,总共 4.3 毫秒,反而慢 1.4 倍。这是按参数算的模型,不是本机实测,但它解释了为什么小批量推理常常留在 CPU 上。
所以 GPU 适合的是「一次搬进来,算很久」的任务。批量图像处理、矩阵乘法、训练时的反向传播,都是把数据准备好以后反复算。反过来,每隔几毫秒就要和 CPU 同步一次的任务,GPU 的固定开销会反复出现,收益很难做正。
真实系统里,拷贝和计算可以重叠。用两个流,一边把下一批数据拷进显存,一边算当前批,能把传输时间藏起来一部分。前提是任务能拆成相互独立的批次,并且显存够放两份数据。这个技巧能明显改善小批量场景,但藏不住单次启动的固定延迟。
精度和结果:GPU 算出来的数不一定和 CPU 一样
GPU 为了吞吐,常用较低的精度和不同的运算顺序。矩阵乘法在 GPU 上可能按分块顺序累加,和 CPU 的串行累加顺序不同,浮点数的舍入误差也就不一样。多数情况下差在末几位,但对数值敏感的任务,比如长时间积分、某些优化算法,结果可能明显分叉。
很多 GPU 还支持 FMA,融合乘加,把乘法和加法合成一条指令,中间结果不单独舍入。它更快也更准,但和分开算的结果仍有差别。做跨平台对比时,要固定精度模式、运算顺序和归约方式,否则比的是实现差异,不是硬件快慢。
这不是 GPU 的缺陷,是并行计算的固有代价。只要结果落在可接受的误差范围,就没问题;如果任务要求逐位一致,就要专门设计归约顺序,或者退回串行实现。验证的办法是先在小规模数据上对比 CPU 和 GPU 的结果,逐层看误差放大的位置。如果只是末位舍入可以接受,某一层突然变大,通常是累加顺序或低精度截断造成的。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 矩阵乘法 GPU 快很多 | 计算量大、数据可复用,线程数足够掩盖延迟 | 算算术强度和线程数,确认不是带宽受限 |
| 小任务 GPU 反而慢 | kernel 启动和数据传输的固定开销超过计算 | 统计启动次数、拷贝字节数和单次计算时间 |
| 分支多的时候明显变慢 | warp 内分支发散,两条路都要执行 | 看代码里的 if/else,尝试改成无分支或查表 |
| 数据来回拷贝吃掉收益 | 主机内存和显存之间走 PCIe,带宽远低于显存 | 算拷贝时间占总时间的比例,尽量让数据留在显存 |
| 显存不够,任务跑不起来 | 模型、输入和中间结果超过显存容量 | 看峰值显存占用,减小 batch 或做分块 |
| 精度不同导致结果对不上 | 运算顺序、FMA、低精度模式不同 | 固定精度和归约顺序,对比逐层误差 |
| 占用率低但调不上去 | 寄存器或共享内存用量限制了同时驻留的块数 | 看编译器的资源报告,减少每线程资源 |
| 多卡加速比不线性 | 通信和同步开销,或任务划分不均 | 看每卡负载和通信时间占比 |
边界与代价
显存容量和带宽是硬边界。算力再高,模型装不下就得切分,切分就要通信;带宽不够,执行单元就空转。很多任务优化到最后,瓶颈不是浮点运算,而是搬数据。
功耗和散热也是边界。一块高端 GPU 的功耗可以到几百瓦,需要专门供电和散热,这些数字是公开资料的量级,本机没有测量条件。笔记本上的 GPU 还要和 CPU 共享散热和功耗预算,长时间负载会降频。
编程模型的学习成本不低。要理解线程层次、共享内存、同步、内存合并访问,还要会看性能分析工具。写一个能跑的 kernel 不难,写到接近峰值很难。
调试也麻烦。并行程序的错误往往不稳定,越界、竞争、同步遗漏可能只在特定调度下出现。GPU 的调试工具比 CPU 少,定位问题要更多经验。
小批量不划算。推理服务如果一次只来一个请求,GPU 的利用率很低,启动和传输开销占比高,CPU 或专用加速器可能更合适。批量上去以后,GPU 的吞吐优势才显现。
还有一条常被忽视的边界:任务的可分性。不是所有算法都能拆成几千个独立线程,有些步骤天然串行,有些需要频繁同步。强行拆开以后,同步和通信的开销可能比并行省下的时间还多。判断一个任务适不适合 GPU,先看它的关键路径能不能并行,再看数据能不能复用。
今天就能验证的五个练习
- 估算一个 1024×1024×1024 矩阵乘法的浮点运算次数和最少需要搬多少字节,算出算术强度。
- 把手上的任务按数据并行度分类:哪些每个元素互不依赖,哪些有前后依赖,哪些控制逻辑复杂。
- 假设一次 PCIe 拷贝的带宽是 10GB/s,算 100MB 数据来回一趟要多久,再和计算时间比占比。
- 把上面的 Python 发散模拟跑一遍,把线程组大小从 32 改成 8 和 64,看有效吞吐怎么变。
- 查一块你能接触到的 GPU 的显存容量和带宽规格,算它跑一个 4GB 模型时,理论最短搬一次要多久。
这些练习不需要 GPU 也能做,重点是建立「算力、带宽、开销」三个量的直觉。
小结
GPU 的快来自大量简单流处理器和 SIMT 锁步执行,靠线程数掩盖显存延迟。它怕分支发散、怕小任务、怕数据来回搬、怕显存装不下。矩阵乘法这类计算密集、数据可复用的任务,正好落在它的舒适区。
下一篇讲 NPU。它比 GPU 更专一,只做矩阵和卷积,算力数字常常写得很漂亮,但限制也更多。40 TOPS 的手机芯片为什么跑不过 10 TOPS 的桌面显卡,那篇会从口径和带宽两个角度拆。
下一篇:NPU 与 TOPS:算力数字背后的限制,从一次卷积的乘加数算起。