现代 AI 加速器 GPU / TPU 系统课程
/ 专题二 /
硬件图解简版
/
完整版 →
TPU 与 GPU
一张一张图,看两块芯片在硬件上哪里不一样。
TPU 侧
v7 (Ironwood)
GPU 侧
B200 / GB300 NVL72
22 张图
课程作者
Chris Yang
·
Google Cloud AI Infra 架构师
1
两款芯片,出身不一样
整门课只有一个前提:两款芯片出身不同,于是每一层都不同
GPU
出身:图形处理器
要伺候大量互不相干的小任务
形状、访问模式、控制流全都无法预知
→ 面积大半花在「应付各种情况」上
cache 层次 · warp 调度 · 海量并发线程
不知道你要跑什么 → 处处留一手
TPU
出身:为矩阵乘定做的 ASIC
从第一天就只服务神经网络
形状规则、访问可预测、控制流静态
→ 省下的是复杂度,不是换来更多算力
无 cache · 无调度器 · 同样的算力只切成 4 大块
早就知道你要跑什么 → 一手都不留
vs
两种出身不是优劣,是两条路线 —— 一条靠运行时现判,一条靠编译期算准
2
同一次取数,两条路
同一次访存,两条路 —— 数一数路上有几个「运行时决策点」
这是第 0 节那两种出身第一次变成具体机制
GPU:运行时适应
硬件替你决定,你写得随意也能跑
TPU:编译期安排
运行时零决策,全部提前算好
一个 warp 的 32 个线程各给出一个地址
这些地址能合并成几条 cache line?
◆ 决策点 · coalescing
⇢ 落在同一个 bank 上吗?
支路 · bank conflict
⚠️ bank 是
shared memory
的分区机制,
不在 global load 这条路上
L1 命中吗?(与 shared 合计 256 KB/SM)
◆ 决策点 · 命中 / 未命中
L2 命中吗?(126 MB,全 GPU 共享)
◆ 决策点 · 命中 / 未命中
换出谁?
◆ 决策点 · 替换策略
HBM
编译期:XLA 决定每个数组切成 8 × 128 的块
☑ 已定死
编译期:决定什么时候搬、搬多大一块
☑ 已定死
编译期:算准 VMEM 装不装得下
☑ 已定死
运行时:DMA 整块 HBM → VMEM(64 MiB)
运行时:向量单元直接取,形状必须已经对
(没有这一层)
硬件缓存 = 0
HBM
主路 4 个运行时决策点(+走 shared 再加 1 个)
你能做的是「让硬件更容易猜对」:访问连续、避开 bank、手工 tiling
路上 0 个运行时决策点
没有 cache,就没有命中、未命中、替换这些概念 —— 也没有补救机会
⭐ 这不是「谁更聪明」—— 是两条路线,各自靠一样东西
GPU 靠
运行时适应
:形状对不对都能跑起来;代价是命中率要跑起来才知道,不好的时候只能反复试。
TPU 靠
编译期算准
:形状提前定死,一个决策周期都不浪费;代价是运行时没有补救手段,形状不对只能回去改代码。
同一次访存,两条路
3
整颗芯片
一颗 B200 全景 —— 两个 die 对软件是
一个
GPU · 148 个 SM · 126 MB L2 · 8 TB/s HBM3e
灰=第三方来源
计算:SM
启用/禁用边界
片上 SRAM
片外内存
互联通路
灰字=第三方来源,非 NVIDIA 官方
一颗 B200(封装级)
TSMC 4NP · 2,080 亿晶体管 ·
两个 reticle 尺寸的 die
通过 NV-HBI 连成
单一 CUDA 设备
,L2 全局一致
↔ 对照 TPU v7:也是双 chiplet,但它
反过来
暴露成
2 个独立 device
,两半各有自己的地址空间。同样的封装形态,软件视图完全相反。
die 0
物理 80 个 SM · 启用 74 个
HBM3e 4 堆栈
全片 8 堆栈 = 物理
192 GB
·
8.0 TB/s
(对软件暴露 186 / 180 GB,随产品形态变)
HBM3e
≈24 GB
HBM3e
≈24 GB
HBM3e
≈24 GB
HBM3e
≈24 GB
die 0 的 L2 63 MB
实测本分区 21 TB/s(第三方 Vulkan 压测)
内部再切
2 个分区
(全片 4 个,Hopper 的两倍)
跨到对面 die 掉到 16.8 TB/s,延迟也变高
SM 阵列
每格 = 1 个 SM。
红框 6 个是出厂禁用的
,用来提良率 —— 148 = (80−6) × 2
GPC 分组:Blackwell Ultra 官方是 8 个 GPC / 160 SM;B200 第三方报 10 个 GPC。存疑,图上不画 GPC 边界。
禁用
禁用
禁用
禁用
禁用
禁用
die 1
物理 80 个 SM · 启用 74 个
HBM3e 4 堆栈
全片 8 堆栈 = 物理
192 GB
·
8.0 TB/s
(对软件暴露 186 / 180 GB,随产品形态变)
HBM3e
≈24 GB
HBM3e
≈24 GB
HBM3e
≈24 GB
HBM3e
≈24 GB
die 1 的 L2 63 MB
实测本分区 21 TB/s(第三方 Vulkan 压测)
内部再切
2 个分区
(全片 4 个,Hopper 的两倍)
跨到对面 die 掉到 16.8 TB/s,延迟也变高
SM 阵列
每格 = 1 个 SM。
红框 6 个是出厂禁用的
,用来提良率 —— 148 = (80−6) × 2
GPC 分组:Blackwell Ultra 官方是 8 个 GPC / 160 SM;B200 第三方报 10 个 GPC。存疑,图上不画 GPC 边界。
禁用
禁用
禁用
禁用
禁用
禁用
N
V
-
H
B
I
10
TB/s
die 间
一致
全片合计
SM
148
物理 160
Tensor Core
592
148 × 4
CUDA Core
18,944
148 × 128
寄存器堆
37 MiB
256 KiB × 148
L1 + 共享内存
37 MiB
256 KiB × 148
TMEM
37 MiB
256 KiB × 148
L2
126 MB
4 个分区
HBM3e
192 GB
8 堆栈
↑ 中间三个
37 MiB
不是复制粘贴:寄存器堆、L1+共享内存、TMEM 每个 SM 都正好
256 KiB
,三块面积相当的 SRAM 分给了三种完全不同的用途。
往外的三条路 —— 一颗 GPU 不是孤岛
NVLink 5 对外互联
· 18 条链路 × 双向 100 GB/s =
1.8 TB/s
/ GPU
· NVL72 机架内 72 张卡全互联,域内总带宽 130 TB/s
· ↔ TPU v7 是 3D torus,每片 1.2 TB/s、只连 6 个邻居
· 拓扑差别比带宽差别重要:全交叉 vs 环面
NVLink-C2C 接 Grace CPU
· GB200 超级芯片 = 1 个 Grace + 2 个 B200
· CPU 内存对 GPU 是可寻址的,不必显式拷贝
· ↔ TPU 侧是 4 chip / VM,走主机接口 HIB
·
C2C 具体带宽本图未查实
PCIe Gen6 接主机与网卡
· 管理面 + 数据装载
· NVLink 连通的两点之间,运行时自动走 NVLink 不走 PCIe
· 要点对点直传仍需显式 cudaDeviceEnablePeerAccess
· Gen6 ×16 双向合计 256 GB/s —— 约为 NVLink 5 的
1/7
一颗 B200 的全景
一颗 TPU v7 chip 全景 —— 封装里是两个 die,而它们对软件是两个「独立的」加速器
TensorCore(稠密算力)
SparseCore(稀疏/通信)
MXU 脉动阵列
存储
互连
一个封装 = 一颗 chip
对外名 Ironwood / TPU v7
峰值 bf16 2,307 TFLOP/s · fp8 4,614 TFLOP/s
chiplet / die 0
对软件 = 独立的 device 0
TensorCore ×1 @ 2.2 GHz
两个 MXU 合计 131,072 个格子(cell)
MXU
256 × 256
MXU
256 × 256
VPU 向量单元
8 × 128
一拍处理 8 sublane × 128 lane
VMEM 64 MiB / core
软件自己搬进搬出的暂存,不是缓存
SMEM 1 MiB
标量/描述符(≠ 指令内存 IMEM)
SparseCore ×2
每个 = 1 个标量序列器 + 16 个向量 tile
SC 0
SC 1
HBM3E 96 GiB
这一半只属于 die 0 —— 两个 die 不共享地址空间
整封装 8 个 HBM3E 堆栈、7.37 TB/s;按 die 拆约 3,433 GiB/s(此拆分口径未定位到官方公开出处)
= 封装 192 GiB 的一半
chiplet / die 1
对软件 = 独立的 device 1
TensorCore ×1 @ 2.2 GHz
两个 MXU 合计 131,072 个格子(cell)
MXU
256 × 256
MXU
256 × 256
VPU 向量单元
8 × 128
同左
VMEM 64 MiB / core
同左
SMEM 1 MiB
同左
SparseCore ×2
SC 2
SC 3
HBM3E 96 GiB
另一半属于 die 1,两套地址空间互不可见
= 封装 192 GiB 的一半
die-to-die 互连
官方口径:比一条 ICI 链路快
6×
。但请注意它
没有
把两个 die 缝成一个 device —— 它只是让跨 die 搬运比出封装便宜,
地址空间仍然是两套
。
6 ×
数一遍:一颗封装里有几个什么
TensorCore
2
= 2 个 JAX device
MXU
4
每 core 2 个,各 256×256
SparseCore
4
每 device 2 个
SparseCore 的向量 tile
64
4 × 16
HBM 容量
192 GiB
官方表头就写 GiB;同页正文的 GB 是笔误
HBM 带宽
7.37 TB/s
官方另一处写 7,380 GB/s,差 0.1%
ICI 对外带宽
1,200 GB/s
六条链路双向合计
同样是双 die 封装,软件看到的东西正好相反
NVIDIA B200
两个 die + 一条一致性总线 → 对软件
装成一个 GPU
。缝还在(跨 die 访问更慢),
但由硬件替你扛。
TPU v7
两个 chiplet
如实暴露成两个 device
,各有各的地址空间。缝留在外面,
由你的切分
策略去面对
。
封装之外:一台主机挂几颗
官方规格:
每 VM 4 颗 chip
(= 8 个 device)、224 vCPU、960 GB 内存、2 个 NUMA
域。主机接口 PCIe 侧约 119.2 GiB/s(未定位到官方公开出处)。记住这个 4 —— GKE
机型名里的数字按
device
算,不是按 chip 算。
对外的六个出口 —— 这才是 TPU 和 GPU 差得最远的地方
每颗 chip 有
6 条 ICI 物理链路
,对应三维的正负方向。它们不是「加速卡之间的选配互联」,而是
芯片出厂时就长在硅上的第
一性结构
:拓扑是 3D 环面(torus),超过 64 颗以后由 4×4×4 的 cube 拼起来,cube 内走铜缆、cube 之间走光纤并经过光
路交换机重新配线。
X+
200 GB/s
X−
200 GB/s
Y+
200 GB/s
Y−
200 GB/s
Z+
200 GB/s
Z−
200 GB/s
六条合计 1,200 GB/s(双向)
一个必须说清的口径坑:
官方正文写的是「每
轴
双向 200 GB/s」,可是 3 个轴 × 200 只有 600,对不上同一页表格里的 1,200。
只有把它读成「每条
链路
200」(6 × 200 = 1,200)才自洽 —— 本文按后者画。
对照一下:B200 的 NVLink 5 是
1,800 GB/s
,数字更大 —— 但它
连的是
一个机柜内的 72 颗
,再往外要换成 InfiniBand/以太网。
ICI 这 1,200 GB/s 是
一路铺到 9,216 颗都不换协议
的那种。
读这张图最容易出错的一处
chip 和 device 的比例是 1 : 2,而所有框架日志都按 device 报数。
所以看到「每 device 1,153 TFLOP/s」不要以为掉了一半 —— 那正是 2,307 的一半;看到
tpu7x-128
也不要以为是 128 颗芯片,那是 64 颗。算 MFU 时分母要用 2,307(按 chip)或 1,
153.5(按 device),
两个口径混用会让结论直接差两倍
。
一颗 TPU v7 的全景,同样两颗 die
4
把一个核拆开
一个 SM 的显微镜展开 —— NVIDIA Blackwell(计算能力 10.0) · 4 个处理块 · 128 CUDA Core · 4 Tensor Core · 256 KiB TMEM
灰字=官方未标
指令 · 调度
通用向量:CUDA Core / 寄存器
张量通路:Tensor Core / TMEM
访存单元
整个 SM 共享
官方未公布个数
一个 SM(Streaming Multiprocessor)
B200 全片
148 个
(物理 160,每 die 80、启用 74) · Blackwell Ultra 全片 160 个 · 最多 64 个 warp、32 个线程块同时驻留
L1 指令缓存 · 线程块从 GigaThread 引擎派进来,落在这个 SM 上就不再迁走
一个线程块(CTA)整体钉在
一个 SM
上;块里的每个 warp 再被分派到下面四个处理块中的
某一个
,同样不迁走。这两条「钉死」是后面所有容量除以 4 的前提。
处理块 0
sub-core / partition
L0 指令缓存
Warp 调度器 ×1 + 分发单元
每周期从驻留 warp 里挑 1 个就绪的,发 1 条指令
驻留 warp 槽 ×16
深=已驻留 白=空槽
寄存器堆 16,384 × 32 bit = 64 KiB
= 64K 寄存器/SM ÷ 4 · 单线程上限 255 个
CUDA Core ×32
FP32 / INT32 统一单元
一条指令 → 32 条 lane 同时算 = 一个 warp 一拍做完
Tensor Core ×1 (第 5 代)
1,024 次乘加 / 周期
← 推导值,见下
操作数
不走寄存器堆
,走下面的 TMEM
一次只吃
很薄的一片
矩阵,不是想象中的大方阵
薄到什么程度、怎么攒成大矩阵 —— 见图 G-4
TMEM 本块够得着的 32 lane × 512 列 = 64 KiB
⚠️ 按
列
整体申请,不是各分一块
本块只够得着 lane 0–31
LD / ST
×8
SFU
×4
访存单元
exp · rcp · rsqrt
处理块 1
sub-core / partition
L0 指令缓存
Warp 调度器 ×1 + 分发单元
驻留 warp 槽 ×16
寄存器堆 16,384 × 32 bit = 64 KiB
CUDA Core ×32
Tensor Core ×1 (第 5 代)
1,024 次乘加 / 周期
TMEM 本块够得着的 32 lane × 512 列 = 64 KiB
只够得着 lane
32–63
LD / ST
×8
SFU
×4
处理块 2
sub-core / partition
L0 指令缓存
Warp 调度器 ×1 + 分发单元
驻留 warp 槽 ×16
寄存器堆 16,384 × 32 bit = 64 KiB
CUDA Core ×32
Tensor Core ×1 (第 5 代)
1,024 次乘加 / 周期
TMEM 本块够得着的 32 lane × 512 列 = 64 KiB
只够得着 lane
64–95
LD / ST
×8
SFU
×4
处理块 3
sub-core / partition
L0 指令缓存
Warp 调度器 ×1 + 分发单元
驻留 warp 槽 ×16
寄存器堆 16,384 × 32 bit = 64 KiB
CUDA Core ×32
Tensor Core ×1 (第 5 代)
1,024 次乘加 / 周期
TMEM 本块够得着的 32 lane × 512 列 = 64 KiB
只够得着 lane
96–127
LD / ST
×8
SFU
×4
↑ 与 0 号处理块
完全对称
,说明文字不再重复;只有 TMEM 的 lane 编号各不相同
两个 SM 配对 cta_group::2
这块 SM 的 4 个 Tensor Core,可以和
隔壁那块 SM
的 4 个一起做
同一次
MMA,共用一份操作数。
注意层级
:配对发生在 SM 与 SM 之间,不是上面四个处理块之间 —— 处理块之间连 TMEM 都是切开各管各的。
L1 数据缓存 + 共享内存 —— 同一块 SRAM,四个处理块共用
这是 GPU 上「编译器/程序员能显式管」的那一层,对应 TPU 的 VMEM
合计
256 KiB
/ SM · 其中可划给共享内存最多
228 KiB
(单个线程块最多 227 KiB,CUDA 留 1 KiB)
可选切分:0 / 8 / 16 / 32 / 64 / 100 / 132 / 164 / 196 / 228 KiB · 静态声明仍限 48 KiB,超过要显式 opt-in
分 32 个 bank、每 bank 每周期 4 B —— 历代如此,Blackwell 官方文档未重申
同一个 cluster 里别的线程块能直接读写这块内存
——
分布式共享内存
,Hopper 引入
实测 L1 命中约
39 周期
(第三方实测,非官方)
TMA 张量内存加速器
一条指令搬一整块多维张量:软件填一个
描述符
(基址 · 各维长度 · 各维步长 · 分块形状),硬件自己算地址、自己搬。
这就是 GPU 版的 DMA 引擎,和 TPU 的 DMA 引擎是同一类东西 —— 都是「把地址生成从计算单元手里拿走」。Hopper 引入,Blackwell 沿用。
纹理 / 采样单元
共享内存原子单元
实测 32 次/周期/SM
⚠️ 一个 SM 里有
三块 256 KiB
,归属完全不同 —— 这是全图最容易混的一处
寄存器堆 256 KiB
切成 4 份
,每份 64 KiB
⛔ 严格私有:warp 只能碰自己那份,
跨处理块
完全不能访问
L1 + 共享内存 256 KiB
一整块,不切
,四个块全都能访问
⭐ 四个处理块之间
唯一
的数据通道 ——
「线程块」这个抽象就落在它身上
TMEM 256 KiB
按
列
整体申请(一列跨全部 128 lane)
介于两者之间:
访问权限
四分
(一个 warp 32 lane),
所有权不分
把上面四列乘回去 —— 整个 SM 的账
CUDA Core
128
32 × 4
Tensor Core
4
1 × 4
寄存器堆
256 KiB
64 KiB × 4
TMEM
256 KiB
64 KiB × 4
L1 + 共享内存
256 KiB
四块共用
最多驻留 warp
64
16 × 4
最多驻留线程
2,048
64 warp × 32
每周期发指令
4 条
1 × 4 个调度器
「1,024 次乘加 / 周期」这个数从哪来
A100 白皮书原话:四个 Tensor Core
合计每周期 1,024 次
FP16 乘加(=每核 256)。H100 官方称「张量吞吐 2× A100」,Blackwell 再 2× →
每核 1,024
。
代回 B200 对账:1,024 × 2 FLOP × 4 核 × 148 SM × 1.83 GHz = 2.22 PFLOPS,官方 2.25 —— 差
1.4%
,缺口就是官方没公布的确切时钟。完整对账表见正文 §2。
一个 SM 拆开
把一个 TensorCore 拆开 —— 值得数的不是它有什么,是它「少了」什么
矩阵乘
向量/标量
片上存储
对外搬运
灰色虚线 = 官方未公开
一个 TensorCore (= 一个 JAX device 的全部算力)
@ 2.2 GHz
控制:标量单元发射 VLIW 指令包
一拍发出一整包指令,包里各个槽
同时
喂给下面不同的单元。谁在第几拍动、数据什么时候到位,
全部由编译器在编译期排好
。
标量
向量
矩阵
杂项
9 个发射槽
槽位构成是 v2/v3 论文的公开数字,v7 官方未公布
MXU
256 × 256
65,536 个 cell
× 每 cell 每周期 2 次乘加
= 131,072 乘加 / 周期
官方
MXU
256 × 256
65,536 个 cell
× 每 cell 每周期 2 次乘加
= 131,072 乘加 / 周期
官方
VPU 向量单元
8 sublane × 128 lane
一拍处理 1,024 个元素
激活、归一化、逐元素运算、归约 ——
矩
阵乘之外的活都归它
。后面 §3 讲的
lane / sublane,物理来源就是这张 8×
128 的网格。
跨 lane 单元
×2
转置、跨 lane 归约、
shuffle。VPU 的 128 条
lane
各干各的
,数据要横着
走就得经过这里。
个数未定位到官方公开出处
片上存储 —— 容量出自 JAX 开源代码,带宽官方未公开
VMEM
64 MiB
软件显式搬进搬出的暂存。
不是缓存
——没有自动填充、没
有替换策略、命不命中这件事不存在
SMEM
1 MiB
标量数据与 DMA 描述符
累加器
128 个
每个形状 (8, 256)、32 bit,
挂在每
个 MXU 上
向量寄存器
查不到
v2/v3 论文说每 sublane 32 深;
v7 没有公开
对外:DMA 引擎
HBM ↔ VMEM 的搬运由 DMA 完成,而
描述符是标量单元发出来的
—— 也就是说「什么时候搬、搬多少」同样写在
指令流里,不是硬件自己决定的。
一个 TensorCore 到底有几个 DMA 引擎:查不
到。所以这里只画一个盒子,不标数量。
一个 GPU SM 里有,而这里「没有」
先数清楚少了什么,再问省下的硅去了哪
✕
4 个 warp 调度器
指令由谁选、什么时候发 —— 这里没有「选」这个动作
✕
64 个 warp 槽(2,048 个线程上下文)
没有线程概念,也就没有「切换到别的线程」这条退路
✕
256 KB 寄存器堆
GPU 那么大的寄存器堆主要是
为了同时装下几十份上下文
✕
L1 / 共享内存的自动填充
VMEM 是纯暂存:
谁搬谁负责
,没有命中率这回事
✕
记分板 / 乱序发射
全部前移到编译期。代价见 §7 —— 算错了没有兜底
省下的硅去了哪:软件能直接指挥的暂存
TPU v7 一颗 chip 上的 VMEM 是
128 MiB
(两个 core 各 64 MiB),而且
每一个字
节都由编译器显式安排
。
TPU v7 一颗 chip 的 VMEM
128 MiB
B200 一整颗的共享内存合计
约 34 MB
第三方
口径是
软件可控的暂存
,不含 B200 那 126 MB 的 L2 缓存。
这张图想让你记住的一句话
GPU 的 SM 里,大部分晶体管不是在算数,是在「决定接下来算什么」
—— 调度器、上下文、记分板、缓存控制,全都是为了在运行时动态地藏住延迟和分支。TPU 把这一整套
前移到了编译期
,于是这些部件可以整个不要。
省下的不是「面积换算力」,是这套机构整个不做了
—— 电路更简单、功耗更低。
它没有变成更多算力,也没有变成更多片上存储
(两项 B200 都更多)。这不是「TPU 更简单」,是
把复杂度换了个地方放
—— 从硅上换到了编译器里。
一个 TensorCore 拆开,重点在右边那一栏
5
访存要等多久,谁来藏这段等待
延迟阶梯 ——
同一条 load 指令,30 拍到 659 拍
§3.2b 比的是
容量
,§3.2c 比的是
带宽
。这是第三个轴:
等多久
—— 而三个轴给出的结论方向并不一致。
NVIDIA GPU:一次取数可能落在哪一档
指针追逐微基准实测,单位是
时钟周期(拍)
。前五行是 H100,最后一行是消费级 Blackwell 做对照。
寄存器
≈ 1 拍
—— 直接就在手里
共享内存 / L1 命中
30–40 拍
—— H100 与 Blackwell 都在这一档
L2 命中
273 拍
——
已经比 L1 慢了七八倍
L2 两个分区都打满
508 拍
—— 分区设计在拥挤时优势消失
一路到 HBM
659 拍
——
全 miss 的端到端耗时
(对照)消费级 GDDR7
877 拍
—— 换一种显存这个数就变了
⛔
不要把这几段相加。
659 拍是
一次全 miss 的端到端耗时
—— L1 和 L2 那两次扑空已经含在里面了。
该记住的不是「加起来多少」,是「同一条指令在 30 到 659 之间摆」。
⚠️ B200 没有同类公开数据。
量级与形状是这一代通用的,但别把它当成 B200 的实测值。
出处:arXiv 2507.10789 的指针追逐微基准。
TPU:这个轴上只有常数
不是数字保密 —— 是没有「可能命中、可能没命中」这一档。
VMEM 访问
—— 编译器显式管的暂存。
数在那儿不是因为运气好,
是因为编译器自己发的那条 DMA 把它放在那儿
HBM → VMEM 的 DMA
—— 这一段当然也有延迟,但它是
一次被安排好的搬运
:
延迟已知,等待点也是编译器插的
⭐
所以「缓存缺失」在 TPU 上不存在—— 不是缓存做得好,是根本没有硬件缓存。
缓存是一台猜测机器;
编译期排好的机器不需要猜
。
那怎么规划?—— GPU 根本不规划
这二十倍的差距你在源码里看不出来
—— 同一条 load,长得一模一样。它的三条对策没有一条在试图算准:
① 超量线程
—— 一个 SM 驻留几十个 warp,卡住就切下一个
延迟不是被消除,是被别人的活盖住的
② 记分板 + 动态发射
—— 运行时盯着操作数到没到,到了才发
③ 缓存本身
—— 它就是一台
猜测机器
,赌你还会再用一次
⚠️
调优在两边动的旋钮一样都不挨着
:GPU 调「怎么让别的活足够多」,TPU 调「怎么让编译器排得开」。
⭐ 一句话对照
GPU 用「总有别的活可干」来盖住不确定的延迟;TPU 用「把不确定性删掉」来避免它。
—— 一个是统计学的答案,一个是确定性的答案。
这也是这门课从第 1 节起一直在说的那件事,
第一次落到了「拍」这个单位上
。⚠️ 但别读成「两边越走越远」—— 现代追峰值的 CUDA kernel 用异步拷贝+显式 barrier 自己管双缓冲,
那就是在 GPU 上手写一个静态调度
。
同一条 load 指令,在源码里长得一模一样,实际耗时差二十倍
延迟怎么被藏起来 —— GPU 让
很多人轮流用同一个单元
,TPU 让
不同单元同时开工
这一拍在发指令 / 在干活
在等数据回来(虚线框)
气泡:没人能干活,这一拍白丢
尚未参与 / 已结束
NVIDIA B200 一个处理块(sub-core)
调度器每一拍只能发
一条
指令。谁的数据回来了谁就能上 —— 所以真正决定性能的不是单个 warp 多快,是
手上有多少个 warp 可以
换
。
周期 →
(示意,非等比)
warp 0
发
发
warp 1
发
发
warp 2
发
发
warp 3
发
发
warp 4
发
warp 5
发
调度器发射槽
有没有指令被发出
气泡
气泡
第 6、7 拍两个
气泡
:六个 warp 全在等数,调度器无人可选。如果驻留的是 8 个 warp 而不是 6 个,这两拍就补上了 ——
能不
能补上,取决于寄存器还剩多少。
TPU v7 一个 TensorCore
没有「换一个 warp 上来」这回事。这里的四条泳道是
四个不同的物理单元
,本来就能同时动 —— 编译器要做的是让它们的起止时刻
正好对上。
周期 →
(示意,非等比)
标量单元
个位数周期
跳
W
向量单元 VPU
几十个周期
矩阵单元 MXU
几百个周期
DMA 引擎
几百个周期
单元占用
有没有单元在动
一条 bundle
322 位 · v2/v3
标量
×2
向量
×4
矩阵 推/取
×2
杂项
×1
立即数
×6
发射槽 ×9 —— 这 9 个是同一拍并发出去的
立即数 ×6 不占发射槽
没有一个气泡。
「矩阵槽是一推一取」这件事本身就说明问题:MXU 不是被调用的函数,是一条推进去、过一会儿取出来的流水线 ——
中间那段时间,别的槽照常在发指令。
这两条合成条不能直接比高低 —— 它们问的不是同一个问题。
左边问「调度器这一拍发出指令了吗」(六个 warp 抢
同一个
发射端口,所以会空);右边问「有没有任何一个单元在动」(四条泳道是
四个不同
的物理单元,天然更容易全绿)。图上还做了一处简化:假定每个
warp 手上只有一条
依赖取数结果
的指令 —— 真实 kernel 里编译器会插入无关指令来填这些拍,气泡没有图上这么整齐。
那「有多少个 warp 可以换」由什么决定? —— 寄存器
一个 SM 有
64K 个 32-bit 寄存器
,最多驻留
64 个 warp
(2,048 线程)。warp 是
整个现场都留在寄存器堆里
才能随时切回来
的 —— 切换零开销的代价,就是所有人的寄存器必须同时占着。所以:
每个线程用的寄存器
这个 SM 能同时驻留几个 warp
占满 64 的比例
够不够盖住上面那 8 拍
32 个
64(撞上限)
100%
够,而且有富余
64 个
32
50%
够
128 个
16
25%
开始吃紧
255 个(上限)
8
12.5%
藏不住,气泡成片
这就是 CUDA 调优里那条最基本的取舍。
循环展开、把中间结果存在寄存器里 —— 这些让单个 warp 变快的手段,同时也在
减少能替
它顶班的人
。
那 TPU 凭什么能排得这么准? —— 因为延迟是常数
没有 cache,就没有「命中没命中」这个变量。
取一个数要多少拍,编译期就是已知的:标量个位数、向量几十、矩阵几百。既然是
常数,编译器就能把 WAIT 放在
正好那一拍
:
1
矩阵槽推进去
MXU 开始算,接下来几百拍它自己忙自己的
2
向量槽同时在动
把下一块权重推进权重 FIFO(后台那套权重寄存器)
3
DMA 槽同时在搬
把再下一块数据从 HBM 搬进 VMEM
4
杂项槽放一条 WAIT
算好放在第几拍 —— 早了空转,晚了 MXU 干等
5
标量单元检查同步位
MXU_BUSY 已清 → 直接跳下一条,不停顿
代价也很清楚:算错了没有兜底。
GPU 猜错只是慢一点,还有别的 warp 顶着;TPU 这边 WAIT 放早了就是纯空转,放晚了 MXU 就
真的在干等。
所以这两句话是同一件事的两面
GPU:把不确定性交给硬件
有 cache,延迟就不是常数;不是常数,编译期就排不了班。于是只能准备一大批随
时能上的替补 —— 这直接决定了 SM 长什么样:
256 KiB 的寄存器堆
(装现场)、
64 个 warp 槽
(装人)、
4 个独立调度器
(挑人)。这些硅不算一次乘法,它们的
全部工作是
盖住等待
。
TPU:把不确定性消灭在编译期
没有 cache,延迟就是常数;是常数,就能在编译期把每一拍排满。于是不需要替补、
不需要大寄存器堆、不需要调度器 ——
省下的是这些电路本身
,不是把它们换成了更
多乘加单元。
图 G-8 数的是每周期乘加总量,不是面积占比
—— 而那张图的结论是
两边总量同一量级(切法差 148 倍)。
「谁的硅用得更值」需要 die 面积,而那个
数官方不公布,本课不主张。
为什么这条差异比带宽差异重要
带宽差个百分之几十,是量的差别;
「谁负责知道数在哪」是质的差别
。它决定了两
边的编译器长什么样、kernel 怎么写、调优时该盯哪个指标 —— GPU 盯
occupancy,TPU 盯的是编译器排出来的时间线有没有空隙。
GPU 怎么藏延迟
延迟怎么被藏起来 —— 班表在编译期就排好了,跑的时候改不了
标量:发 DMA、算地址
向量:VPU
矩阵:MXU
杂项
灰色 = 这一拍这个槽是空的(NOP)
一个 VLIW 指令包 = 一拍要干的所有事,打成一包
合计 322 bit · TPU v2 / v3,公开论文
没有乱序、没有记分板 ——
哪条指令在第几拍发、发给哪个单元,全部写死在指令流里
。
标量
标量
向量
向量
向量
向量
矩阵
矩阵
杂项
立即数 ×6
这张槽位构成是 TPU v2 / v3 论文里的公开数字。
v7 的 bundle 宽度和槽位构成,官方没有公开
。这里画它,是因为
「一拍多槽、由编译器填」这个结构本身跨
代没变
,变的只是每种槽有几个。
同一段依赖,编译器怎么排 —— 示意,不是实测 trace
DMA 在飞的这几拍,矩阵槽只能空着 —— 编译器要么找到别的活填进来,要么认了
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
标量槽 ×2
发 DMA
算下一块地址
发下一条
向量槽 ×4
上一块的归一化 / 激活(独立的活)
继续
矩阵槽 ×2
矩阵乘:tile 到位才能开始
杂项槽 ×1
同步
同步
第 14 拍之后所有槽都空了
—— 独立的活用完了。这四拍
不会有任
何东西自动顶上来
,因为没有第二个线程可切。
第 1–6 拍的向量槽里塞的是
上一块
的后处理 —— 和这次搬运没有依赖关系,所以能提前挪过来。
这就是编译器「藏延迟」的全部手段:找独
立的活。
同一个延迟,两边怎么处理
GPU:运行时换一个跑
warp 卡住 → 调度器立刻挑一个能跑的。
代价是要同
时驻留几十份上下文
,那 256 KB 寄存器堆就是为它
准备的。 好处:形状不规则也能跑得不太难看。 坏
处:同一份代码,两次跑的耗时可以差很多。
TPU:编译期提前挪
编译器把独立的活挪进空拍。
不需要驻留上下文,那
片硅省下来给了 MXU 和 VMEM
。 好处:耗时高度可
预测,同样的形状每次都一样快。 坏处:
挪不动就
是真空转
,运行时没有第二次机会。
这个取舍在日常里长什么样 —— 三件事其实是同一件事
① 形状一不规则,性能就掉得很难看
不是编译器不肯优化,是
可挪的独立指令本来就少了
。batch 小、序列不齐、专家路由不均 ——
这几种情况的共同点都是「后一步紧跟着前一步」,空拍没东西填。
② 编译很慢,而且慢得有道理
v7 上一次 XLA 编译常见
10–17 分钟
。它不是在「翻译」,是在
替硬件把整张班表排完
——
GPU 那边这件事是每次运行时由调度器现做的,成本摊在了跑的时候。
③ 但跑起来非常稳
同一个形状重复跑,步时几乎没有抖动 —— 因为根本没有运行时决策可抖。
可预测性是这个设计
买来的东西,不是附带效果
:容量规划、性能回归检测在 TPU 上都因此简单不少。
把 §2 那句话补完整
§2 说 TPU「省下了调度器、寄存器堆、记分板那片硅」。
这张图是那句话的另一半:省下来的东西并没有消失,它被搬到了编译期。
调度这件事总得有人做 —— 区别只在于是硬件每次运行时重做一遍,还是编译器一次做完。
所以「TPU 更简单」是个误解。它
不是把复杂度删掉了,是把复杂度换了个地方放
—— 从硅上换到了编译器里,也从运行时换到了你写模型配置的那一刻。
TPU 怎么藏延迟
6
并行的层级
lane 和 sublane 是
寄存器
的形状 —— 不是内存的概念,也不是「大小」的概念
来源:JAX 公开源码中 v7 那一支的 num_lanes = 128 / num_sublanes = 8
一个向量寄存器
…
…
…
…
…
…
…
…
共 128 列
1 条 lane
红色这一竖条,自己一套 ALU
1 个 sublane = 横着的一整条
128 格那么长 = 512 B
共 8 行
整个寄存器 = 8 × 128 × 32 bit = 4,096 B = 4 KiB
⚠️ 「sub」不是「更小」—— sublane 不是 lane 的一小段,它是横跨全部 128 条 lane 的一整条
立画面只要两步:
先只看一条 —— 128 格那么长;再叠 8 条 —— 就是一个寄存器。
记法:
最内维 → lane,次内维 → sublane
。
⭐ 然后 XLA 故意把内存布局做成同一个形状
数组 […, C, D] 落到内存里:最内维 D → lane(128 一组),次内维 C → sublane(8 一组)。
于是一个 [A, B, C, D] 的数组,在内存里是 A × B × ⌈C/8⌉ × ⌈D/128⌉ 个 4 KiB 的块。
直接后果:⚠️ 「一行」在内存里并不连续 —— 它被切碎在一排块里。下一片讲这件事要付多少钱。
先只看一条 —— 128 格那么长
那六层为什么是六层 ——
每一层都是被一个具体的麻烦逼出来的
包含关系与「谁定的」看那张折叠全表,每层钉在哪块硅上看《GPU 显微镜》G-3 —— 这张只答一个问题:为什么要有这一层
层
有多大
它保证了什么
⚡ 为什么会有这一层
grid
grid
整个 kernel 的全部 block
只剩 L2 和 HBM —— 没有片上快捷通道
—— 它是边界,不是被逼出来的
cluster
thread block cluster
≤ 8 块(H100 起可 opt-in 到 16)
同一个 GPC 内,能直接读写别的块的 shared memory
一个 SM 那 227 KiB 不够用了。代价:邻居的暂存要走 GPC 网络,比自己那块慢
线程块
CTA / block
≤ 1,024 线程 = ≤ 32 warp
保证落在同一个 SM:共享 shared memory、能 __syncthreads
「谁跟谁能共用暂存、能对齐脚步」需要一条边界 —— CTA 就是这个作用域
warp 组
warpgroup
4 个 warp = 128 线程
一条 wgmma 由这 128 个线程整体发出
Tensor Core 大到一个 warp 的寄存器喂不饱了,发指令的单位只好往上抬一级
warp
warp
32 个线程
共用一条指令流;分支分歧只在这一层内发生
取指译码太贵。取一次、译一次、32 份数据一起算 —— 管理成本摊薄 32 倍
线程
thread
1 个
自己的寄存器。没有自己的命运 —— 跟着所在的 warp 走
—— 它是边界,不是被逼出来的
⚠️ 三个最容易记错的点:
1,024 是「一个 block 的上限」
(=32 warp),不是一个 SM 的上限。
一个 SM 同时驻留
64 个 warp = 2,048 线程
(B200 / H100 / A100 这几代如此,消费级和 Turing 更少)—— 这才是「有没有别的活可切」的本钱。
warp 内
「天然锁步」是 Volta 之前的事
—— 现在每个线程有独立的 PC,要对齐得显式写 __syncwarp()。
⭐ 这六层没有一层是为了「让程序好写」加的
它们合起来,就是
「靠运行时适应」这条路线的组织成本
—— 要在运行时换人、分工、组队,就得把这些层级做进硬件,再配上调度器、记分板、常驻的巨大寄存器堆。
✕ TPU 这一整列是空的。
它不做「运行时换人」这个决定,于是这六层同时失去存在的理由 —— T-3 那张对照表上的两个空格,就是这一列不存在时的样子。
六层里只有 grid 和 thread 是边界,其余四层每一层都对应一个具体的硬件麻烦
并行层级逐层对照 —— 按问题对齐,不按名词对齐
NVIDIA B200
TPU v7
TPU 上没有这一层
问的是同一个问题
NVIDIA B200
TPU v7
最小的那个东西是什么
一次能被单独指名道姓的最小执行体
1 个 thread
有自己的程序计数器、自己的寄存器。
可以走自己的分支
。
1 个元素
只是向量里的一格。
没有程序计数器,也不能走自己的分支
—— 它不是执行体,
是数据。
硬件天然锁步的一组是多少
这一组必须一起执行同一条指令
1 个 warp = 32 条 lane
32 个 thread 锁步。分支不一致时
两边都要走
一遍
。
1 条向量指令 = 8 × 128
每格 = 8 条 lane
8 个 sublane × 128 条 lane、共 1,024 个
元素一起动。
连「分支不一致」这个概念都没有
—— 没有分支可言。
共享一块暂存的是哪一组
谁和谁能通过片上暂存互相看见数据
1 个 thread block
同一个 block 里的 warp 共享一块 shared memory,由程序员在核函数里划
定,
运行时才知道有几个
。
✕ 没有这一层
VMEM 属于
整个 TensorCore
,不属于某一组。谁能看见什么,编译期就定死了
—— 没有「一组」这个中间概念。
运行时谁决定接下来跑哪个
延迟出现时,硬件有没有别的活可切
4 个 warp 调度器 / 64 个 warp 槽
某个 warp 卡在访存上,调度器立刻换一个能跑的。
这就是 GPU 藏延迟的全
部秘密
。
✕ 没有这一层
指令什么时候发、数据什么时候到,
编译期就排死了
。卡住了就是真的空转 ——
没有别的活能顶上来(见 §7)。
一个物理核里有什么
最小的、自带完整控制通路的硬件块
1 个 SM
×148
128 个 CUDA Core + 4 个 Tensor Core + 228 KB L1/共享内存
(容
量为第三方)
1 个 TensorCore
×2
2 个 MXU + 1 个 VPU + 64 MiB VMEM + 1 MiB SMEM
一颗芯片对软件是几个
框架里
devices()
数出来是几
1 个
两个 die 由一致性总线缝成一个 GPU。跨 die 更慢,
但 API 里看不出来
。
2 个
两个 chiplet 如实暴露成两个 device。
缝在明处,由你的分片策略面对
。
不换协议能连到多大
超出这个规模就得换一套互联
72 颗
NVLink 5
一个 NVLink 域。再往外换 InfiniBand/以太网,
编程模型也跟着换
。
9,216 颗
ICI 4.0
3D 环面一路铺到整个 pod,
全程同一套 ICI
。这是
互联那一节
的落点。
看这张表要看的是空格
七行里有
两行
TPU 那一栏是红的。而这两行不是随便哪两行
—— 它们恰好是 GPU 用来
在运行时藏住延迟
的那两层。
空的第一格:没有「一组线程」
GPU 的 block 是个
运行时
概念:有几个 block、落在哪个
SM 上,启动时才知道。TPU 没有这个中间层,所有归属在编
译期就写死在指令里。
空的第二格:没有「换一个跑」
GPU 一个 warp 卡住就换下一个,这需要同时驻留几十份上下
文 —— 那 256 KB 寄存器堆主要就是为它准备的。TPU 不留这
些上下文,所以也省下了那片面积(见 §2)。
于是 TPU 的层级全在描述「形状」
lane、sublane、tile、slice —— 每一层说的都是
数据长什
么样
,而不是
谁在执行
。这就是为什么 TPU 编程里你调的是分
片策略,而 CUDA 编程里你调的是线程组织。顺带解释了一件
常被问到的事:为什么 TPU 上「跑一个不规则的算法」这么别
扭 —— 不是编译器不肯,是
硬件层级里根本没有一个能承载「
不规则」的单位
。
一句话总结这张表
GPU 的层级是「执行体的层级」,TPU 的层级是「数据形状的层级」。
thread、warp、block 说的都是谁在跑;lane、sublane、tile、slice 说的都是数据被切成什么样。
这个区别有个非常实际的后果:
GPU 的性能问题多半出在「占用率」上
(同时驻留的 warp 够不够多,能不能把延迟盖住);
TPU 的性能问题多半出在「形状」上
(矩阵维度对不对齐、切片切得均不均匀)。两边的调优直觉
不能互相搬运
—— 这也是为什么
收缩维那一节
里的
head_dim=128
打 TPU 却不打 GPU。
TPU 这边刻意按问题对齐,不按名词对齐
一个 SM 拆开看 ——
它不是一整块,是四个格子
warp 为什么是 32、住得下多少人、换 warp 为什么不要钱 —— 这三个问题的答案都在这个画面里
1 个 SM
(B200 全片 148 个)
处理块 0
sub-core / quadrant
1 个 warp scheduler
32 个 CUDA Core
1 个 Tensor Core
64 KiB 寄存器 · 16 个 warp 槽
处理块 1
sub-core / quadrant
1 个 warp scheduler
32 个 CUDA Core
1 个 Tensor Core
64 KiB 寄存器 · 16 个 warp 槽
处理块 2
sub-core / quadrant
1 个 warp scheduler
32 个 CUDA Core
1 个 Tensor Core
64 KiB 寄存器 · 16 个 warp 槽
处理块 3
sub-core / quadrant
1 个 warp scheduler
32 个 CUDA Core
1 个 Tensor Core
64 KiB 寄存器 · 16 个 warp 槽
四个格子共用:
228 KB 的 L1 + 共享内存
(单个线程块最多要走 227 KiB)· TMA 搬运引擎 · 通往 L2 的出口
⛔ 一个 warp 一旦被分到某个格子,就在那儿待到死 —— 不迁走。这条「钉死」是后面所有「除以 4」的前提。
四格加起来 = 整个 SM
128 个
CUDA Core
4 个
Tensor Core —— 不是 1 个
65,536 个
32-bit 寄存器 = 256 KiB
64 个
warp 槽 = 2,048 个线程
最多 32 个
线程块
⭐ 寄存器堆 256 KiB,
和旁边那块 L1 + 共享内存一样大
(也是 256 KiB,其中最多 228 可划给共享)。
一块芯片上最贵的 SRAM,整整一半拿去当了「让人待命」的本钱。
住得下多少人?
三个闸门,谁先卡住算谁
—— 这就是「占用率」这个词量的东西
① 寄存器 —— 最常先卡住的那个
65,536 ÷ 2,048 = 32
每线程只能用 32 个,才住得满
每线程 32 个
→ 2,048 线程
占用率 100%
每线程 64 个
→ 1,024 线程
占用率 50%
每线程 128 个
→ 512 线程
占用率 25%
每线程 255 个(上限)
→ 256 线程
占用率 12.5%
⛔ 循环展开、把中间结果留在寄存器里 —— 都在削减能待命的人数。
② 共享内存
一个 SM 一共
228 KB
,单个线程块最多要走 227 KiB。
你的 block 要 100 KiB ——
这个 SM 就只住得下 2 个 block
,
寄存器还剩多少都没用了。
⭐ 你问的「100 个线程把资源占没」—— 真会发生的是这一条。
一个 block 独吞 227 KiB,整个 SM 就只剩它一家,最多 1,024 个线程。
③ 槽位本身
最多
64 个 warp
、最多
32 个 block
。
block 开得太小也吃亏:每块只有 32 个线程时,
32 块 × 1 warp = 32 个 warp,
64 个槽只填得满一半
。
资源一点没超,人就是招不满。
⚡ 那为什么不干脆把 warp 做成 128,省得四个凑一堆?
先把问题翻译一下
:32 就是一个格子的宽度,128 就是四个格子各出一个 warp。所以「把 warp 做成 128」=「
把四个格子合成一个
」。
① 合成一个就只剩一个 warp scheduler。现在四个格子能同时跑四条毫不相干的指令流 —— 合并了这个能力就没了。
② 绝大多数指令根本不需要 128 宽(访存、整数、分支、超越函数)。只有 wgmma 那一类要。为它加宽,等于让全部代码替矩阵乘付账。
③ 32 × 4 B = 128 B = 正好一条 cache line;而分支发散的惩罚随宽度线性变重 —— 一个 if 走岔,整组都得两边各走一遍。
⭐ 换 warp 是零成本的 —— 而这张图就是那张账单
CPU 换线程要把寄存器存下来再恢复;GPU
从来不搬
—— 2,048 个线程的寄存器
一直物理占着
,谁的数据到了就发谁。
代价就是那 256 KiB。
「运行时才知道数据什么时候到」—— 为这一条付的账里,最贵的一项不是调度器,是这堆养着待命者的寄存器。
三个都叫「线程」——
中间那个两头都沾:写法像左边,硬件像右边
CUDA 的 thread 借了操作系统线程的名字和写法,骨子里却是一条 SIMD lane —— 把左右两根柱子立起来,中间那根的怪异才看得见
操作系统的线程
CUDA 的 thread
TPU 上对应的位置
有没有自己的取指、发射
有,完全独立的控制流
有自己的 PC(Volta 起),但
发射单位始终是 warp
—— 所以它不能自己决定下一条指令是什么
没有。它是一条向量指令覆盖到的一个位置
有没有「名字」
有 ——
pthread_self()
有 —— threadIdx。这是 GPU 最特别的一点
你能写「第 37 号线程去干点别的」,而且它真的会去
没有。
你写不出「第 37 号 lane 干点别的」
—— 能写的只有整块整块的操作
换人要多少钱
把寄存器存下来再恢复 —— 微秒级
零。
寄存器物理常驻,从来不搬
代价是那 256 KiB 一直占着 —— 见「一个 SM 拆开看」那张
不存在「换人」这回事 —— 顺序编译期就排死了
一次处理多宽
你的代码说了算
一条 32-bit lane。
访存可向量化到 128-bit,fp16 一拍两个
但基本盘就是一格 —— 跟你的直觉一致
8 sublane × 128 lane 那张网格里的
一格
谁决定它什么时候跑
操作系统调度器,会被抢占
warp scheduler,运行时挑
—— 谁的操作数到了就发谁
编译器,编译期排死
。没有调度器
有多少个
几十到几百
一个 SM 驻留
2,048
,全片 148 个 SM = 约
30 万
一条向量指令一次盖住
1,024
格
⭐ 一句话:CUDA 的 thread 是「
有名字的 SIMD lane
」
你按操作系统线程的写法去写它 —— 标量代码、if、循环,全都成立;但它
没有自己的取指
,三十二个一起听同一句口令。
而这个「有名字」,就是两边的分界线。
GPU 把 lane 暴露给你,代价是它得配调度器、记分板、和那堆养着待命者的寄存器;
TPU 把 lane 藏在编译器后面,于是省掉那一整套 —— 但你也就
再没有「单独指挥某一条 lane」这个动作
了。
「那六层为什么是六层」那张,讲的是同一件事的另一半。
它没有自己的取指,三十二个一起听同一句口令 —— 这一头像 TPU 的 lane
一块数据怎么进到共享内存 ——
GPU 走了四代,TPU 出厂就在终点
只看两件事:
数据在半路要不要经过寄存器
,以及
地址、跨步、边界是谁算的
—— 这两件事一变,线程就从「搬运工」退成了「发号令的」
中转这一格 ——
整张图的差别都在这儿
地址、跨步、边界谁算
发起它的线程接下来干什么
一直都有
普通
ld / st
全局内存
寄存器
数据在这儿过一道
共享内存
Tensor Core
线程
自己算
,自己跑循环
被占住
—— 搬完才轮到算
Ampere 起
cp.async
(SASS:LDGSTS)
全局内存
直通
不落寄存器
共享内存
Tensor Core
还是线程自己算
省了寄存器这一道,
地址和循环仍要自己跑
Hopper 起
TMA
+ 一张拷贝描述符
全局内存
TMA 引擎
按张量维度+块坐标
共享内存
Tensor Core
硬件算
:跨步、偏移、
边界全由它接管
一个线程发完就走
;
搬完引擎自己去 barrier 报数
Blackwell 起
tcgen05
+ 一块专用矩阵暂存
共享内存
TMEM 256 KB/SM
操作数与累加器都住这儿
矩阵暂存
Tensor Core
仍是硬件算
;而这一代
连结果都不回寄存器堆
一个线程代表整个 CTA 发
;
要用结果得再显式取回来
TPU:
出厂就是这样
编译器显式发的
DMA
HBM
DMA 引擎
和上面那行是同一类东西
VMEM
MXU
编译期就排好了
这一栏对 TPU 不成立
——
这边压根没有「线程」这个角色
⭐ 一条线看下来:搬运从「
取数指令的副作用
」,变成了「
一台按描述符干活的引擎
」
GPU 用了
四代
走到这儿,TPU 第一天就在这儿。
这不是谁抄谁
—— 是同一个物理约束逼出来的同一个答案:
矩阵单元越快,喂料这件事就越不能占着算的人
。⛔ 但
别把这条线读成「GPU 在往编译期挪」
—— TMA 那张描述符是
运行时建的
。
收敛的是
怎么搬
(整块、按描述符、不占线程);
谁决定
那一层一步没动 —— GPU 是运行时某个线程发,TPU 是编译期就排好的一步。
这正是全课那条主线。
—— 「搬运是取数的副作用,还是一条独立的 DMA」这句话,在《GPU 显微镜》图 G-6 里已经出现过;这张图给的是它
怎么一步步变成现在这样
。
⚠️ 图上
没有 L2
,这是故意的 ——
它在这条路上是「透明」的
所有 global 访问都
路过
L2(全片 126 MB、4 分区、在
SM 外面
,所有 SM 共用),但
它不是任何一步的目的地
—— 这几行搬运的终点都是共享内存 / VMEM。
⛔
别把共享内存当成 L2
:
共享内存在 SM 里,和 L1 是同一块 228 KB
;L2 在 SM 外、大三个数量级。
TMA 引擎也在 SM 里(Hopper 起每 SM 一个),它的目的地同样是共享内存。
⚠️ 生产者一换人,
对齐的办法也得跟着换
第三行那台引擎
不是线程
,它不会「到达」,只会「往里放了多少字节」。而
__syncthreads()
数的是人头
,对它没用。
所以 Hopper 的 barrier 多了一项本事:
连字节数一起数
—— 人到齐
并且
字节够了,才放行。
这就是「异步事务 barrier」这个名字的来历。
📌 这一张全部出自官方:
cp.async
的直通路径见 CUDA 编程指南;
TMA 的单线程发起、硬件接管地址生成
与
异步事务 barrier 数字节
,是 Hopper 架构官方博客的原话。
Blackwell 那一行:
tcgen05 由单个线程代表整个 CTA 发射
、
TMEM 256 KB/SM 且由软件在 MMA 作用域显式管理
—— 出自 PTX ISA 与第三方微基准,本图不额外推导。
四行里只有中转那一列在变,两头是同一个东西
7
矩阵单元:一条指令吃多大一块
Tensor Core 一次吃多大矩阵 —— 五代演进,以及一张真实比例的叠图
全部出自 PTX ISA
warp 级(32 线程)
warp 组级(128 线程)
双 SM 级(256 线程)
TPU MXU,同一把尺子
五代演进 —— 变的是「一次动员多少线程」,不变的是「K = 16」
Volta
第 1 代
8 个线程
参与一次 MMA
mma.sync.m8n8k4
—— 一个 quad-pair 八条 lane 凑一次 MMA
PTX 目标注记:
m8n8k4 requires sm_70
,并注明「为 sm_70 优化,别的架构上会明显更慢」
操作数住在哪
寄存器
8 条 lane
Turing
第 2 代
32 个线程 = 1 个 warp
参与一次 MMA
mma.sync.m16n8k8
—— warp 级形状从这一代进 PTX
同一页还写着:
u8/s8 的 m8n8k16、u4/s4 的 m8n8k32、b1 的 m8n8k128 都要 sm_75
——
整数与亚字节精度
是从 Turing 开始的
操作数住在哪
寄存器
32 条 lane
Ampere
第 3 代
32 个线程 = 1 个 warp
参与一次 MMA
mma.sync.aligned.m16n8k16
—— K 从 8 加倍到 16,加 BF16 与 TF32
PTX 目标注记:
m16n8k16 requires sm_80
。这条形状一路活到今天
操作数住在哪
寄存器
32 条 lane
Hopper
第 4 代
128 个线程 = 1 个 warp 组
参与一次 MMA
wgmma.mma_async.m64nNk16
,N 从 8 到 256 可选
NVIDIA 原话:
Warp-group MMA across 128 threads
。
只在 Hopper 有
(要 sm_90a)
操作数住在哪
A 在寄存器或共享内存,B 在共享内存
128 条 lane
Blackwell
第 5 代
两个 SM 配对 · 单线程发射
参与一次 MMA
tcgen05.mma
· 单 SM:M = 64/128,N = 8,16,…256(步长 8) · 两 SM 配对:M = 128
/256,N = 16,32,…256(
步长 16
) ·
K 仍然只有 16
配对时 M 和 N 的步长
都翻倍
—— 这不是「同一条指令做得更大」,是
粒度本身变粗了
。
⚠️ 这一代趋势反转
:前
四代是「一次动员越来越多线程」,tcgen05
由单个线程发射
(cta_group::2 说的是哪两个 CTA 供数,不是
256 线程一起发),操作数改由 TMEM 供给 ——
所以这条轴该读成「操作数的作用域有多大」,不是「动员多少线
程」
操作数住在哪
操作数与累加器都在 TMEM
,不占寄存器
256 条 lane
同一把尺子上叠一遍 —— 大方框是 TPU 一个 MXU 的 256×256,里面三块是 GPU 三条指令各自的输出矩阵
每个元素画 1.17 像素,三块和大框用的是同一个比例,没有任何缩放作弊。三块共用左上角,所以是
嵌套
关系,不是并排。
TPU v7 一个 MXU 256 × 256
65,536 个乘加单元,一条指令喂满
tcgen05 m128 n256
wgmma m64 n256
tcgen05.mma M×N = 128 × 256
输出块占 32,768 个位置,是 TPU 那个 256×256 的
1/2
Blackwell 最大的一条。两个 SM 配对时 M 到 256 —— 那时它的高度正好是这个大方框的一半,宽度已经铺满。
wgmma M×N = 64 × 256
输出块占 16,384 个位置,是 TPU 那个 256×256 的
1/4
Hopper 的 warp 组指令。宽度和上面那条一样满,只有高度是它的一半 —— 两条的差别全在 M 上。只在 Hopper 有,Blackwell 换成了 tcgen05。
mma.sync M×N = 16 × 8
输出块占 128 个位置,是 TPU 那个 256×256 的
1/512
在这张图上它只有
9 × 19 像素
—— 就是左上角那个圈住的小蓝点。从 Turing 一路留到今天的 warp 级指令,
Blackwell 上不但没被砍,消费级那颗 die 的
块量化还只挂在它身上(见图 G-5)。
还有更关键的一维:收缩维 K —— 上面画的是输出矩阵,K 才决定「一次能吃多深」
M 和 N 决定输出块有多大,
K 决定一次乘加链有多长
。GPU 这一维从 Turing 的 8 加倍到 Ampere 的 16 之后
就再没变过
:fp16/bf16 是 K=16,fp8 是 K=32,fp4 是 K=64 —— 换算成位宽全都是 256 bit,也就是同样的
8 个 32-bit
字
。
GPU Tensor Core 的 K = 16 ← 就这么窄
TPU MXU 的收缩边 = 256 —— 同一把尺子,差 16 倍
这 16 倍不是「GPU 只能算 16 深」。
它连发多条 K=16,累加器一直待在 TMEM 里不落地,深度照样累得上去。差的是
一条指令的粒度
,
不是能力上限。
粒度粗细各有代价。这就是为什么注意力里
head_dim=128
这件事
打 TPU 却不打 GPU
:128 撞上 TPU 的
256 收缩边,只喂满一半;而 128 是 16 的整数倍,对 GPU 来说刚好切成 8 条指令,一点不浪费。
Tensor Core 一条指令吃多大一块
MXU —— 256×256 的阵列里,数是斜着穿过去的
乘加单元(权重驻留其中)
激活:从左边进,每拍前进一列
部分和:向下累加,最后落进累加器
灰色 = 这一拍还没轮到
一次矩阵乘在阵列里的样子 —— 第 16 拍的快照
颜色深浅表示这个单元
什么时候开始干活
:左上角最早,右下角最晚。同一条
反对角线
上的单元在同一拍工作 —— 这就是「
脉动」两个字的意思。
← 第 16 拍的波前
一个 MXU 256 × 256
图上 1 格 = 16 × 16 个真实单元
激活
逐行进入
权重:预先载入,整趟计算期间驻留不动
累加器 128 个 · 形状 (8, 256) · 32 bit
激活
一行一行从左边进来,每拍往右挪一列
;第 r 行比第 0 行晚 r 拍到齐。部分和则沿着列往下累加,走到底就落进累
加器。
延迟和吞吐是两回事。
一个数从进阵列到出结果要走满 2N−1 拍 —— 对 256×256 就是
511 拍
。但阵列一旦灌满,
每一拍
都有一整列结果落地
。所以矩阵越大越划算:填满流水线的那 511 拍被摊薄了。
反过来说,
小矩阵在 TPU 上格外亏
:算一个 256×256×256 的乘法,光是灌满和排空流水线就占掉
三分之二
的时间(256
+ 511 = 767 拍,其中 511 拍不在稳态)。这是 §7 那条「编译器必须提前排班」的物理根源之一。
峰值这条链是官方的,不是推的
262,144 FLOP / 周期 / MXU
×
2.2 GHz
×
4 个 MXU
=
2,307 TFLOP/s
Google 工程博客逐字给出这三个数,乘出来精确等于官方峰值
把它摊到单个 cell 上:
262,144 ÷ 2 ÷ (256×256) = 2
,也就是
每个 cell 每周期做 2 次乘加
。注意这是
新架构才有的
—— 128×128 的那
几代(v3 / v4 / v5e / v5p)全部还原成每 cell 1 次。
至于「2 次」在硅上怎么实现(每个 cell 真放了两个乘法器?还是 256×256 是逻辑视图?)—— 公开资料答不了,本文不猜。
256 是「粒度」,不是「上限」—— 这两件事常被搞反
K 比 256 大,一点不亏。
K = 1024 就是走 4 趟、累加器一直不落地,跟一趟算完的效率几乎一样。
K 比 256 小,才是真亏。
阵列的收缩边是物理的 256 行,喂进去 128 就只有一半行在动 ——
另一半在空转,而且没有办法把别的活塞进去
(
回到 §3:TPU 没有「换一个跑」这一层)。
对比 GPU:它的收缩维 K 是
16
,128 是 16 的 8 倍,切成 8 条指令一点不浪费。
同一个模型配置,在两边的「浪费」完全不在一个位置。
一个真实例子:注意力的 head_dim = 128
多头注意力里,
QKᵀ
的收缩维和
PV
的输出维都等于
head_dim
。
head_dim = 128 时,两处各只喂满 256 的一半
—— 纯几何,不需要任何
内部信息就能推出上限是 50%。
实测佐证:把 Qwen3-30B 的注意力从 32 头 × 128 改成 16 头 × 256(参数量和 FLOP 完全不变),MFU 在 8K / 16K / 32K 上分别提升
21% / 32% / 46%
。
结论不是「TPU 不适合注意力」
,是
模型配置和硬件收缩边要一起选
。同样的改动搬到 GPU 上,收益接近于零。
喂满率:三种 K,同一个阵列
K = 256
100%
刚好铺满收缩边。理想情况。
K = 128
50%
只有一半行在动,另一半空转。
head_dim=128
就是这一格
。
灰色那一半
不能拿去干别的
—— 没有第二个任务可以
填进来。
K = 512
100%
分两趟走,累加器不落地。
和第一格一样满
。
第 1 趟
第 2 趟
这就是「粒度不是上限」的意思
:大于 256 的维度
只是多走几趟,不产生浪费。
MXU 是 256×256,收缩维比 GPU 大 16 倍
同一把尺子上 —— 两个方块面积等比,
总量几乎一样
,
切分粒度差 128 倍
B200:一个 Tensor Core
TPU v7:一个 MXU
推导值 —— 推导链与它的验尸见正文 §2 / §8
NVIDIA B200 一整颗
148 个 SM × 每 SM 4 个 Tensor Core
592 个 Tensor Core
× 每个
1,024
乘加 / 周期 =
606,208
1 个 Tensor Core
1,024 乘加 / 周期 (推导值)
面积比
1.16×
TPU v7 一整颗 chip
2 个 TensorCore × 每核 2 个 MXU —— 官方数字,见右下
MXU
256×256
131,072
乘加/周期
MXU
256×256
131,072
乘加/周期
MXU
256×256
131,072
乘加/周期
MXU
256×256
131,072
乘加/周期
4 个 MXU
网点只示意密度:真按 256×256 画,每 cell 只有 0.27 像素
× 每个
131,072
乘加 / 周期 =
524,288
把账摊开
B200
TPU v7 chip
倍数
每周期乘加 · 总量
606,208
524,288
1.16 ×
切成多少个独立单元
592 个 Tensor Core
4 个 MXU
148 ×
单个单元多大
1,024 乘加/周期
131,072 乘加/周期
128 ×
↑ 两行为什么不等
148 ÷ 1.16
= 单元大小差 128 ×
自洽
公布的峰值 ˟
2,250 TFLOPS FP16
2,307 TFLOPS BF16
1.03 ×
这些数怎么来的
148
第三方拆解
,×4 官方;
每核 1,024 官方 + 推导
4 MXU × 262,144 FLOP/
周期 × 2.2 GHz,
三个数全
是官方的
见左
右边这一列不是推导,是官方的。
Google 工程博客逐字给出:
262,144 FLOP/周期/MXU × 2.2 GHz × 4 MXU
= 2,307 TFLOPS
。
→ 262,144 ÷ 2 ÷ (256×256) =
每 cell 每周期 2 次乘加
但 128×128 那几代(v3/v4/v5e/v5p)全部还原成
每 cell 1 次
所以这个常数是分代的。
本文上一版把老架构上验过的「每 cell 1 次」顺手套到了 256×256 上,算出 8 个
MXU ——
错了,返工记录见正文 §8
。
˟ 2,250 是
HGX B200
的口径。
NVL72 里那颗 GB200 更高
—— 每 GPU dense BF16 约
2,500
。
比域内算力
时要用后者
,别混 SKU。
这 128 倍意味着什么 —— 三个方向,没有哪边天然更好
GPU 为什么必须切碎
细粒度买来的是「什么都能跑」
一颗 B200 上同时挂着许多互不相干的线程块,谁先算完谁先走。要让通用调度器管
得住,单元就得小到
一个 warp 就能独占一个
。代价是这 592 份里每一份都要自带
操作数通路、累加器和控制逻辑 ——
控制的开销乘了 592 遍
。
TPU 为什么敢切粗
粗粒度买来的是「几乎没有开销」
一个 MXU 一条指令就吃满 65,536 个 cell(131,072 乘加 / 周期),这意味着
取指、译码、控制这些开销
被摊到六万多个乘法上,趋近于零
。但它只有在「确实有
这么大一块矩阵要算」时才成立 —— 而这件事得由
编译器在编译期保证
,做不到就空
转。
所以什么形状喂得满
回到图 G-4 那个例子
GPU 的收缩维 K 一直是 16,几乎什么形状都是它的整数倍,喂满很容易。TPU 的
MXU 收缩边是 256 —— 注意力里常见的
head_dim=128
只能喂满一半。
同一个模
型配置,在两边的「浪费」完全不在同一个位置
,这就是为什么调优经验不能直接搬。
别把这张图读成排名 —— 它是一张取舍图,不是分数表
总量接近、峰值接近,说明两家在同一代工艺上做出的
算力密度是可比的
。真正的分歧在前面几张图里:
谁来知道数在哪
(G-6)、
谁来盖住延迟
(G-7)、
切多细
(本图)。这三个选择互相咬合 ——
换掉任何一个,另外两个都得跟着换
:切得细就必须有大寄存器堆去养替
补,养了替补就不需要编译期排班,不排班就只能靠 cache 兜住不确定的延迟。反过来那条链同样成立。
总量几乎一样,切法完全不同
8
各自多出来的那一块
SparseCore 拆开看 ——
「处理不规则访存」处理的是什么
地址由数据算出来、编译期不知道 —— 这件事难在两处,而这颗核对着这两处各配了一个解法
TensorCore
本课前六小节拆的都是它
MXU × 4
256×256 脉动阵列
VPU
向量寄存器 8 sublane × 128 lane
VMEM
——
TensorCore 专用
。SparseCore 不直接管它
⛔ 它是编译期就排死的机器:地址得提前知道
SparseCore
按 device 看 2 颗(物理 4 颗/chip)· 占的面积很小
标量子核 × 1
· 标量运算
·
动态索引
·
发起 DMA 和 stream
· 自带 SMEM
向量子核 × 16
(文档里也叫 tile)
每个子核自带 VMEM + SMEM,数据流各走各的
SIMD 宽度 16(F32)/32(BF16)—— 一次动的是十几个数,不是一千个
共享 VMEM
OpenXLA 文档里
叫它
SPMEM
很小、很快、
编译器显式管,不是缓存
⭐ 它原生支持
数据相关的控制流和访存
—— 地址可以是刚算出来的
HBM
—— 192 GiB(v7)。
大表、中间结果都在这儿。两颗核都直接连它
⭐ 所以「操作 VMEM 还是 HBM」这个二选一本身是个陷阱:
两块都碰
—— 只是它碰的那块 VMEM 是
它自己的
,不是 TensorCore 那块。
那「最小粒度」到底是多少 ——
先把两件被混为一谈的事分开
TensorCore 那个 (8,128)
它是向量寄存器的形状
(8 sublane × 128 lane = 1,024 格),
也是 VMEM 里的布局单位 —— fp32 下一块 4 KiB。
⛔
它不是「DMA 的最小粒度」
。把这两件事说成一件,是我讲这一段时犯过的错。
但方向是对的:你要的若只是散落的几行,按这个单位对齐取数就会付冤枉钱。
SparseCore 的 DMA 粒度
64
字节
—— 这是
可执行的官方口径
,不是文档里的形容词:
pltpu.get_tpu_info().sparse_core
在 TPU 7x 上报
num_cores=2, num_subcores=16, num_lanes=16, dma_granule_size_bytes=
64
⭐ 所以回答「能不能不搬 (8,128)」:
这个问题问的是两台机器的两套单位
—— 它按 64 字节走。
一次 gather 在这张图上怎么走
①
索引
放在 SparseCore 自己的 VMEM 里 → ②
标量子核
照着索引发一堆 DMA → ③ 十六个向量子核
各追各的地址
,从
HBM
里取回来
Pallas 里就是一行:
sync_copy(data_ref.at[indices_ref], target_ref)
——
data 在 HBM,indices 在 VMEM。scatter 是同一条路反着走。
⭐
这条路不只用来查 embedding
:Ironwood 上 Qwen 3.5 那篇公开调优记录里,SparseCore 干的是
按路由索引把 token 从 HBM 间接 gather 出来
,
直接喂给 TensorCore 做 GMM ——
同一个形状,换到稀疏注意力上就是「把 top-k 那批零碎的 KV 取回来」
。
⚠️
取回来之后落在哪,公开资料没有明写。
那篇只说「写进一块连续的虚拟缓冲,
绕开了在 HBM 里物化中间张量
」—— 绕开 HBM 是明写的,
但
是不是直接落进 TensorCore 的 VMEM,没有一处公开文档这么说
;而 OpenXLA 那篇讲 embedding 的又说 SC 与 TC 之间「frequently involves HBM as an intermediary buffer」。
两处口径不一致,这里不下结论。
⭐ 它扛延迟的方式,不是让每一次取数变快 ——
是同时欠着很多次取数
散乱访存的痛点从来不是带宽,是
每一次都得等
。十六个子核各自独立的数据流,就是为了把一大把请求同时抛出去、各自回来。
换个说法:TPU 把 TensorCore 上砍掉的「运行时才知道地址」那套能力,单独做了一颗小的放在旁边。
主核保持纯静态、拿满算力;需要动态的时候,交给它。
⚠️ 规格出自 JAX Pallas SparseCore 文档与 OpenXLA SparseCore 文档;「为什么这套本事也适合卸载 collective」
是推的,官方没有公开解释
。
把 SparseCore 拆开 ——
里面有哪些子核、各干什么、线怎么连
「SparseCore 对比 TensorCore」那张把它当成一个整体在用;这一张掀开盖子。
形状上它更像一台十六路的搬运机,而不是一台计算器。
一颗 SparseCore
—— v7 上每颗芯片
4 个物理核
,按 device 算
2 个
。整颗核占的面积很小,但它是这一节的第二个主角。
⭐ 读法:
橙色虚线=派活(控制与 DMA 请求),蓝色实线=真正的数据搬运
。两种线分开画,是因为这颗核最反直觉的一点就是——
发命令的人自己不搬数据
。
标量子核 × 1
scalar subcore
· 标量运算(一次一个数)
·
动态索引
—— 地址可以是
刚从数据里算出来的
·
发起 DMA 与 stream
· 自带
SMEM
(它的私有便签)
⭐ 它是调度中枢:
不算数据,只决定谁去搬什么
向量子核 × 16
—— 公开文档里也直接叫
tile
十六个完全同构
,每个自带内存、数据流各走各的
① tile 0
tile 1
tile 2
tile 3
tile 4
tile 5
tile 6
tile 7
tile 8
tile 9
tile 10
tile 11
tile 12
tile 13
tile 14
tile 15
⛔ 别把它当成「小一号的 TensorCore」:
这里面没有 MXU
。
共享 VMEM
文档里叫
SPMEM
· 十六个 tile 都能访问
·
跨 tile 交换数据
走的就是这块
· 很小、很快
·
编译器显式管
,
不是缓存
⛔ 不是 TensorCore
那块 VMEM
① 把一个 tile 放大看
十六个长得一样,看懂一个就看懂全部
向量 ALU
SIMD
16 lane
(F32)/
32
(BF16)
本地 VMEM
文档里叫
TileSPMEM
/ local SPMEM
本地 SMEM
这个 tile 自己的标量便签
⭐ 一次动的是十几个数,不是一千个
派活
数据
HBM
——
大表、权重、中间结果都在这儿
。每次 DMA 的最小粒度
64 字节
(
pltpu.get_tpu_info().sparse_core
直接报得出来)
三种角色都直连 HBM
—— 标量子核往那儿发 DMA,tile 往那儿取数、写回,SPMEM 里周转的东西也从那儿来。
⭐ 对照一下就知道这颗核为什么存在:TensorCore 那边按
向量寄存器的形状
(8 sublane × 128 lane)成块地取,要的若只是散落的几行,就得为整块付钱;这边按
64 字节
走。
一次 gather 沿着这些线怎么走
1.
索引先到位
—— 要取哪些行,这份索引本身也是数据,放在 SparseCore 自己的内存里
2.
标量子核照着索引发 DMA
——
橙色虚线
—— 它一次抛出一大把请求,不等任何一个回来
3.
十六个 tile 各追各的地址
——
蓝色实线
—— 从 HBM 取回自己那份,互不排队
4.
要跨 tile 汇总时经 SPMEM
—— scatter 就是同一条路反着走
⭐
它扛延迟的方式不是让每一次取数变快,是同时欠着很多次取数。
它擅长的四类活(官方文档原话,不是我归纳的)
小向量算术
—— 一次十几个数的加减乘
gather / scatter
—— 按索引取、按索引写
排序 · 去重 · 计数 · 直方图
—— 全是「先看了数据才知道下一步」的活
ragged 操作
—— 每一行长度都不一样的那种
⭐ 四条共用一个形状:
要么地址是算出来的,要么形状是不齐的
—— 正好是静态编译的机器最难受的两件事。
⭐ 为什么这台「搬运机」后来被拿去扛集合通信
All-Gather、Reduce-Scatter 这些活,拆开看
恰好也是「发一大把 DMA、各自回来、中间顺手加一下」
—— 跟 gather 是同一个形状,只是对面从 HBM 换成了别的芯片。
于是就有了这一节最后那件事:
把集合通信从 TensorCore 手里接过去,让计算和通信真正并行
。Pallas 里这条路是公开的 ——
VectorSubcoreMesh
让你
「用写 TensorCore collective 的同一套模型,在 SparseCore 上写 collective」(JAX Pallas 官方文档原话)。
这件事在 XLA 里就是一组 flag 开关。
⚠️ 「为什么这套本事也适合卸载 collective」是
从形状推的
—— 官方公开了开关和收益,没有公开这段设计理由。
一颗 SparseCore = 1 个标量子核 + 16 个同构的向量子核(tile)+ 一块共享 SPMEM, 三种角…
9
64 颗连在一起
64 颗连在一起 ——
同样是 64,两边连的方式不是一回事
这门课那组招牌实测就是 64 对 64。摆那两个数之前,得先知道这 64 颗
各自是怎么连起来的
。
⛔ 这张图只说结构,不说快慢
哪种通信模式吃亏、EP 为什么对拓扑最挑剔 → 专题五
GB300 · NVLink 5 + NVSwitch
每颗 GPU 18 条,一条接一台交换机 = 18 条轨
9 tray × 2 = 18 颗
16 个 compute tray × 4 颗 = 64
第 10 台交换机 = 第 10 条轨
四色都汇到这一台,其余 60 颗也在
四色 = 被点名的四颗,
每颗都连满 18 台
;其余 60 颗一样(1,152 条全画成一团)
一条轨长什么样,轨与轨之间又是什么关系
·
一条轨 = 一台交换机 + 它到全部 64 颗的链路
,也就是一张
完整的星
·
交换机彼此之间没有链路
→ 18 条轨互不相干,谁也不经过谁(单层非阻塞)
⭐ 于是「任意两点一跳」在图上是
数出来的
:任取两颗,它们在
每一条轨上都碰头
,
所以中间永远只隔一台交换机,而且
有 18 条并行的路
可选 ——
谁跟谁都一样,位置无关
。
64 张卡
,而域的上限是
72
——
64 整个装得下同一个域
。
TPU v7 · ICI 三维环面
没有交换机
:每颗只连六个邻居(±x ±y ±z)
红色虚线 = 环绕链路
(每个方向画一条示意,实际三个方向都首尾相接)
x
z
y(往里)
这一颗的
6 条
全是直连邻居
x 环绕
y 环绕
z 环绕
一维上的 4 个点
首尾一接 ——
最远 2 步
(不接环绕要 3 步)
每一维 4 个点。
不接环绕
最远走 3 步,
接上环绕
只要 2 步
三维加起来:
2 + 2 + 2 = 6 跳
—— 最远的一对;近邻 1 跳
⭐ 这一侧
谁跟谁说话,贵不贵取决于离多远
⚠️ 那 6 跳全靠环绕撑着 —— 所以申请的是「一个 4×4×4」,不是「64 颗」
⭐ 同一套 ICI 一路铺到 9,216 颗,中途不换协议
⚠️ 两边的「1 跳」不是一个单位 —— 这是这张图最容易被误读的地方
GB300 那一跳
是「卡 → 交换机 → 卡」:两段链路 + 一次交换。
代价与位置无关
,但它不等于零。
TPU v7 那一跳
是
一条直连线
,没有交换机。所以 6 跳指的是「走 6 条线」,
不是「慢 6 倍」
。
⛔ 因此
1 对 6 只能读成结构差别,读不出延迟比
。 每颗几条链路、每条多宽、这个数的官方口径为什么对不上 ——
「从一颗到一个 pod」那张图专门算这笔账
。
同样是 64 颗,两边连的方式不是一回事
从一颗到一个 pod —— 关键不是能连多少,是在哪儿被迫换一套编程模型
TPU v7:ICI
NVIDIA B200:NVLink
换协议的那一刀
灰色虚线 = 官方未公开
为什么是「环面」而不是「网格」
每颗芯片有
6 条 ICI 物理链路
,对应三维的正负方向。把最边上的一颗和最那头的一颗接起来 ——
多接这一条,直径就少一半
。
●
红桩 = 环绕链路,接到那一头去;第三维同理,图上没画
环绕:第 3 颗的邻居就是第 0 颗
← 一条轴
一颗芯片的 6 个出口
chip
X−
X+
Y+
Y−
Z+
Z−
每条 200 GB/s(双向),6 条合计 1,200
直径的差别是实打实的:
4×4×4 如果只是网格,最远要走 3+3+3 = 9 跳;接成环面之后是 2+2+2 =
6 跳
。规模越大差得越多
—— 这决定了 all-reduce 的最坏时延。
但环面不是白拿的:
它要求切片在物理上必须是连续的一块立方体。所以 TPU 上你申请的不是「64 颗芯片」,是「一个 4×4×4」
——
形状本身是调度的一部分
,这一点在 §3 那张表里就已经埋下了。
同一根对数轴上,两边各能走多远
横轴是
一个互联域里的加速器颗数
(对数)。真正要看的不是端点,是那条
红线
:过了它,你的通信代码就得换一套写法。
1
8
64
256
1,024
4,096
16,384
TPU v7
全程同一套 ICI,3D 环面一路铺到底
DCN
1 chip
1 台主机
1 个 cube 4×4×4
1 个 pod
9,216 颗 = 144 个 cube
B200
NVLink 域
RoCE / RDMA
1 台机器(上一代 HGX)
1 个机柜
换协议就在这儿
128 倍的差距不在带宽上,在「不换协议能连多远」上。
9,216 ÷ 72 = 128 —— 而且这两个数量级之间,TPU 那一侧
集合通信的写法
一个字都不用改
(
这句只在一个 pod 之内成立,跨 pod 走 DCN 时并行配置照样要改
)。越过红线那一侧,实测 all-reduce 从
约
840 掉到约 325 GB/s
(
2.6 倍
,不是一个量级),而且
通信库要换一条实现路径
。
反过来说也别夸大:
单颗算力两边几乎打平
(NVL72 里那颗
GB200
每 GPU dense BF16 约 2,500 TFLOP/s,TPU v7 一颗 chip 2,
307 ——
注意别拿 HGX B200 的 2,250 来比,那是另一个 SKU
),而且在 72 颗以内
NVLink 的每颗带宽还更高
(1.8 TB/s 对
1.2 TB/s)。
这张图比的是拓扑能延展多远,不是单芯片谁快。
口径警告:「pod」有两个官方定义
同一批官方材料里,「pod」既被用来指
9,216 颗芯片的整机规模
,也被用来指
一个 256 颗的可售单元
。两个都是官方说法,
互
相矛盾,而且没有一处说明哪个作准
。
所以看到「一个 pod」这四个字,
先问是哪个 pod
。本文提到 pod 一律指 9,216 那个,并且每次都把数字写出来。
这一节里我查不到的
1. 实际能一次调度到的最大切片。
物理上 9,216 颗连成一个环面是官方数字,但「一个作业最多能拿到多大一块」取决于调度系
统,
公开资料里没有一个可引用的上限
。
2. 环面在多大规模上会退化成非环。
边缘切片能不能拿到环绕链路,公开资料同样没说。
不猜。
1,200 GB/s 这个数,官方自己写拧了
官方正文写的是「每
轴
双向 200 GB/s」。可是三个轴 × 200 = 600,对不上同一页表格里的
1,200
。
只有把它读成「每条
链路
200」才自洽:6 条 × 200 = 1,200。
本文按这个读法画
,并且在这里写明原文是另一种措辞 ——
遇到官
方文档自相矛盾,正确做法是标出来,不是挑一个顺手的悄悄用。
两份文档合起来的那一句话
GPU 那份的最后一张图讲的是:一颗 B200 里有
592 个 Tensor Core
,而一颗 TPU v7 里只有
4 个 MXU
—— 同样一块矩阵乘的活,
份数
差 148 倍,而
单个单元多大
差
128
倍 ——
本文反复说的那个 128 指的是后者,别顺口说成 592 对 4
。
GPU 的协调主要发生在芯
片内部。
这张图讲的是另一半:TPU 一颗芯片里只有两个核要协调,但
不换协议能一路连到 9,216 颗
,而 GPU 在 72 颗上就得换。
TPU 的协调主要发生在芯片之间。
两边不是「谁更强」,是把同一份复杂度放在了不同的地方 —— 这也是这整份材料从头到尾在说的同一件事。
3D 环面一路铺到 9,216 颗,全程同一套 ICI