现代 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