第八代 TPU 与 TorchTPU 全链路拆解:两颗芯片、Boardfly 拓扑与 PyTorch 原生后端

25395 字
127 分钟
第八代 TPU 与 TorchTPU 全链路拆解:两颗芯片、Boardfly 拓扑与 PyTorch 原生后端

为什么要从资源配比看第八代 TPU

TPU 的历史主线在站内已经沿着两代讲得很完整:v1 用 256×256 脉动阵列证明了推理 ASIC 的可行性,可参考 TPU v1 完全拆解(一):为推理而生的领域专用架构与指令集,脉动阵列的数据流与 Roofline 归因则在 TPU v1 完全拆解(二):脉动阵列、weight-stationary 数据流与 Roofline 性能归因 里展开;v2 到 v8 的世代取舍与 TorchTPU 的背景,在 Google TPU 世代技术全景:从 bfloat16、光交换到 Ironwood,以及 TorchTPU 的 PyTorch 原生后端 里已经有一张全景图。

本篇不再重复世代叙事,而是沿着一条更窄也更硬的线往下钻:第八代 TPU 的每一份硬件资源,分别被哪类软件机制兑现成了性能。第八代把产品线拆成训练用的 TPU 8t 和推理用的 TPU 8i,这本身不难理解;真正值得逐项拆开的是:为什么 8i 要 288 GB HBM 加 384 MB 片上 SRAM、为什么 MXU 与 VPU 的算力配比会决定长上下文注意力的上限、为什么 Boardfly 要把网络直径从 16 跳压到 7 跳、CAE 放在 ICI 边上意味着什么、TorchTPU 的 DeferAndFuse 在什么条件下才真正省时间,以及 Google 的模型-硬件协同设计指南中那 13 条建议背后的定量依据。

一句话概括这条线:形状与精度决定有效计算,存储与数据流决定搬运代价,拓扑与调度决定等待。这篇的每一节都会落到这三句话中的某一句上,并给出可以自己复算的数字。

TorchTPU 的软件栈:PyTorch 与 TorchTPU 后端经 StableHLO 或 Mosaic 进入 OpenXLA 编译器,生成 TPU 可执行文件

上图是 PyTorch 官方 TorchTPU 发布博客给出的软件栈示意。左侧是 PyTorch 侧的应用与框架(TorchTitan、TorchRec、Ray、SGLang 等),TorchTPU 作为后端把它们接进 TPU 编译路径;中间两条入口分别是高层的 StableHLO 和低层的 Mosaic(Pallas kernel 编译到这一层);两者都汇入 OpenXLA 编译器,经过 HLO 与 LLO 两级优化后生成 TPU executable。理解这条链路是理解后文所有性能讨论的前提:PyTorch 侧看到的每一条指令,最终都要落成这张图里的某个环节,而没有一条环节可以直接看到 HBM 的物理地址。

代际演进里真正改变设计空间的几个节点

把第八代放回整条世代线上,可以看到七个关节点,每个都引入了一种后来被反复使用的新机制:

  • v1:脉动阵列加面向推理的矩阵 ASIC,用数据复用降低矩阵计算成本。
  • v2 / v3:加入训练支持(bfloat16、HBM)与多芯片 ICI,从单芯片加速走向训练系统。
  • v4:OCS 可重构光互联与 SparseCore,让系统拓扑与稀疏计算开始协同设计。
  • v5e / v5p:同一代里配置分化。v5e 用较少的 TensorCore 与 256 芯片的 2D Torus 做成本效率,v5p 用双 TensorCore、4 个 SparseCore 与 3D Torus 做大规模训练,pod 达 8,960 颗芯片。
  • v6e Trillium:每个 TensorCore 配 2 个 256×256 MXU,第三代 SparseCore 专门服务嵌入。
  • v7 Ironwood:双 chiplet,每个 chiplet 有独立的存储空间,一颗芯片暴露为两个计算设备;FP8 峰值 4.614 PFLOP/s,是 BF16 的 2 倍;数据放置与跨 chiplet 通信开始需要协同考虑。
  • 8t / 8i:双 ASIC,分别配置 SparseCore 与 CAE,原生 FP4,并分别使用 Torus 与 Boardfly;跨 pod 由 Virgo 承担。

这条线上还有一个常被引用的历史对照:TPU v4 论文中的系统级训练速度,BERT 是 A100 的 1.15 倍、ResNet 是 1.67 倍,而每芯片功率 BERT 场景是 197 W 对 380 W,约 1.93 倍差距。这类数字的意义不在于”谁更快”,而在于说明定制 ASIC 的收益来自整条系统路径(芯片、互联、编译器)的协同,而不是单个矩阵单元的峰值。

Chip、Pod、Fabric、Host 四层

理解 TPU 的性能问题,先要把系统分成四层,每一层都有独立的瓶颈:

  • Chip:TensorCore / VMEM / HBM / 专用引擎。瓶颈是单芯片的算力、容量与带宽配比。
  • Pod:ICI 加 3D Torus 或 Boardfly。瓶颈是片间带宽与网络直径。
  • Scale-out:NIC 加 Virgo,把多个 Slice / Pod 连起来。瓶颈是跨域带宽与故障隔离。
  • Host:Axion CPU 负责预处理与编排,加速器侧负责计算、存储与通信。瓶颈是主机与加速器之间的 PCIe 带宽以及主机内存容量。

软件栈(PyTorch / JAX → XLA / Pallas → Runtime)横跨这四层:编译器决定每一层上的数据怎么排布、通信放到哪里、kernel 怎么切。这个分层也解释了为什么”换一颗更快的芯片”经常带不来线性收益——如果 Pod 层的网络直径没变、或者 Host 层的喂料跟不上,芯片的提升会被上下两层的瓶颈吃掉。

两颗芯片的分工:同一代里做两种资源配比

训练与推理在关键路径上的差别

Google 在 2026 年的第八代 TPU 发布材料里给出的说法很直接:硬件开发周期比软件长得多,设计一代芯片时必须预判几年后市场需要什么。当年的判断是推理需求会随着前沿模型大规模部署而抬升,同时智能体(agent)负载会让交互延迟的影响被放大——因为多个智能体在复杂流程中协同、互等,单个请求的小低效会在整条链路里叠加。于是同一代里做了两颗芯片:8t 偏训练吞吐,8i 偏推理延迟;两颗芯片都能跑两类负载,但专门化才带来显著效率。

这个判断和 TPU v7 Ironwood 的定位一脉相承。Ironwood 是第一次明确”为推理而生”,官方在发布时给出的口径是 FP8 原生、192 GB HBM、7.37 TB/s 带宽。第八代在这个基础上做了三件事:把训练与推理彻底拆开、把互联从 3D torus 拓展到 Boardfly、把 PyTorch 原生后端从”能跑”推进到”能竞争”。

8t 与 8i 的公开规格

官方给出的两颗芯片公开规格如下。表中 LDE 是 LLM Decoder Engine 的缩写,官方目前只列名,没有公开其职责与覆盖的算子范围,所以下文不对它的内部结构做任何推测性描述。

项目TPU 8tTPU 8i
主要优化方向大规模预训练Sampling / Serving / Reasoning
Pod 拓扑3D TorusBoardfly
专用引擎SparseCore + LDECAE
HBM 容量 / chip216 GB288 GB
VMEM 容量 / chip128 MB384 MB
HBM 带宽 / chip6,528 GB/s8,601 GB/s
FP4 算力 / chip12.6 PFLOP/s10.1 PFLOP/s
Host CPUArm AxionArm Axion

三个数字最值得注意。第一,8i 的 HBM 容量(288 GB)反而大于 8t(216 GB)。推理芯片的 HBM 不是用来装模型权重的全部,而是用来同时装下权重、KV 缓存和一批并发请求的中间状态。第二,8i 的 VMEM 是 8t 的三倍:384 MB 对 128 MB。VMEM 是片上 SRAM,带宽远高于 HBM,它的容量决定了 kernel 能把多少中间数据留在片上、减少多少 HBM 往返。第三,8i 的 FP4 峰值(10.1 PFLOP/s)低于 8t(12.6 PFLOP/s),说明 8i 并没有为了更大的算力去做权衡,而是把面积花在了存储与互联上。

需要强调的是,官方在多个页面里给出的口径并不完全一致:博客里提到”近 3 倍于上一代的每 pod 算力”,而部分规格页面列出了绝对峰值。这类差别在跨来源引用时很容易混淆 BF16、FP8、FP4,以及是否带稀疏(Sparse)加成的口径。下文凡涉及对比都注明精度和来源,不做跨口径直接相除。

Superpod、Virgo 与公开带宽

8t 的单 superpod 最多 9600 颗芯片,共享 2 PB 高带宽内存,片间带宽是上一代的两倍。官方口径是单个 superpod 121 EFLOPS(FP4 口径)。跨 superpod 的扩展由新引入的 Virgo Network 承担,配合 JAX 与 Pathways,宣称可以在单个逻辑集群内接近线性扩展到一百万颗芯片,单 Fabric 可连接超过 134,000 颗 8t,最高 47 Pb/s 对分带宽。

可靠性被放到了与性能同等的位置:8t 的目标是 97% 以上的 goodput(有效计算时间占比),手段包括几万颗芯片的实时遥测、ICI 链路故障的自动检测与绕行、以及用 OCS(Optical Circuit Switch)在硬件故障时自动重构拓扑。这和 TPU v4 的光交换思路一脉相承:把拓扑视为可以在资源分配与故障处理阶段重配置的资源,而不是一次布好就固定的结构。区别在于 v4 的 OCS 主要服务 3D torus 的立方体之间的光路,而第八代把 OCS 用在了 Boardfly 的群组间连接和 superpod 级别的可重构上。

两张官方对比表把代际跃迁摊开得很清楚。下图对比的是 Ironwood 与 8t:pod 规模从 9,216 颗芯片增到 9,600 颗,pod 级低精度算力从 42.5 涨到 121 EFlops,每芯片双向 scale-up 带宽从 9.6 涨到 19.2 Tb/s,scale-out 网络带宽从 100 涨到 400 Gb/s。pod 规模只增加了不到 5%,算力却涨了近三倍——这说明这一代训练侧的重点不是堆芯片数,而是每颗芯片与整条互联链路一起加宽。

Ironwood 与 TPU 8t 的官方对比表:pod 规模、FP4 算力、scale-up 与 scale-out 带宽

上图来源是 Google 第八代 TPU 发布博客。这里有一个必须指出的口径问题:121 EFlops 恰好等于 9,600×12.69{,}600 \times 12.6 PFLOP/s,也就是 8t 单芯片 FP4 峰值的 pod 级乘积;而 42.5 EFlops 恰好等于 9,216×4.6149{,}216 \times 4.614 PFLOP/s,用的是 Ironwood 的 FP8 峰值。所以这两个数字并不是同一精度的严格对比,只能当作官方给出的代际量级参考;跨精度直接相除会得到错误结论。

Ironwood 与 TPU 8i 的官方对比表:pod 规模、低精度算力、HBM 容量与 scale-up 带宽

上图同样来自 Google 第八代 TPU 发布博客,对比的是 Ironwood 与 8i。官方口径的 pod 规模从 256 颗芯片增到 1,152 颗(注意 Ironwood 的 9,216 是 superpod 口径,两张对比表对”pod”的定义并不一致),pod 级总 HBM 容量从 49.2 TB 涨到 331.8 TB,约 6.7 倍;每芯片双向 scale-up 带宽同样从 9.6 涨到 19.2 Tb/s。表中 11.6 EFlops 同样等于 1,152×10.11{,}152 \times 10.1 PFLOP/s,即 8i 单芯片 FP4 峰值的乘积,与表头的 FP8 字样不一致,引用时应保留原始表头与换算依据。HBM 总容量的增幅最值得注意:它直接决定同一个 pod 能装下多大的模型、能缓存多少 KV,也就是下一节要算的容量账。

8i 的四项关键创新与官方性能口径

Google 在发布材料里把 8i 的改进归纳为四项,每项都对应推理栈的一个关键路径,而不是单纯的峰值数字:

  • 打破内存墙:288 GB HBM 配 384 MB 片上 SRAM,后者是上一代的 3 倍,目标是让模型的活跃工作集尽量留在片上。后文会算,光靠 384 MB 装不下完整 KV;它的意义在于”放热点、减少往返”,而不是”全放片上”。
  • Axion 主机:每台服务器的物理 CPU 主机数量翻倍,换成自研的 Axion Arm CPU,并用 NUMA 做隔离。这一项针对的是 Host 层:预填充的输入处理、请求编排、KV 的跨层搬运,都发生在主机侧。
  • 扩展 MoE:ICI 带宽翻倍到 19.2 Tb/s,Boardfly 把网络直径降低 50% 以上。MoE 推理的 all-to-all 是随机全局通信,这两项分别提高带宽、压低最坏跳数。
  • 消除延迟:新的片上 CAE 把全局操作卸载出计算核,官方口径是片上集合通信延迟降低最多 5 倍。对 decode 阶段每层都要同步的 TP 来说,这是直接打在关键路径上。

官方给出的综合口径是:每美元性能比上一代提升 80%,同样成本能服务接近两倍的客户量;两颗芯片的每瓦性能最高是 Ironwood 的 2 倍,配第四代液冷。这些是商业口径的数字,不能直接换算成单 kernel 的加速;但它们与前面几节的机制分析方向一致——8i 的收益来自存储、互联与专用引擎的协同,而不是更高的峰值算力。

芯片内部:MXU、VPU、VMEM 的配比如何决定注意力上限

芯片里的五类计算资源

不同的 TPU 世代规格在变,但芯片内部的组件划分相对稳定。一颗 TPU 芯片里,与推理性能直接相关的有五类资源:

  • TensorCore:包含一组 MXU(矩阵乘单元)、一个 VPU(向量处理单元)和一个标量单元。MXU 是脉动阵列,负责矩阵乘;VPU 负责逐元素的向量运算(norm、softmax 的指数、格式转换等);标量单元跑控制流与地址计算,自带一小块标量内存。
  • SparseCore:专门处理稠密矩阵乘不擅长的部分——嵌入查表、gather/scatter、排序、去重,以及把集合通信从 TensorCore 上卸下来。TorchTPU 博客的说法是它可以和 TensorCore 并行执行,从而实现计算-计算、计算-通信两种重叠。
  • VMEM:MXU 和 VPU 旁边的片上 SRAM,带宽远高于 HBM,kernel 把数据分块(tile)暂存在这里。
  • HBM:高带宽显存,装模型权重、KV 缓存以及所有不在片上的中间状态。
  • DMA 引擎:在 HBM、VMEM 和远端设备之间搬运数据,异步执行——kernel 发起一次拷贝,之后可以去算别的,需要时再等这次拷贝完成。

官方没有公开一张完整的 8t/8i 芯片平面图,能确认的结构信息来自规格页与博客:两颗芯片都由多个 TensorCore、HBM 堆栈、内存与 DMA 互联层以及负责出芯片链路的 SerDes chiplet 组成;差别体现在专用引擎上,8t 一侧挂的是 SparseCore,8i 一侧是 CAE,8i 的 HBM 堆栈更多、VMEM 更大。这个差异也是理解后文”为什么 8i 适合推理”的起点:推理延迟的关键在存储与互联,而不在更大的矩阵阵列。

MXU 与 VPU 的算力配比:一个可以复算的比值

TPU 的 MXU 是 256×256 的脉动阵列(v7x 这一代),VPU 则按 FP32 向量加法的口径提供算力。把两者的峰值算力相比,可以得到一个非常关键的比值,这个比值决定了长上下文注意力的上限。

以 TPU v7x 为参照(约 2.2 GHz,MXU 用 BF16,VPU 以 FP32 向量加法计),每 TensorCore 的峰值大致是:

  • MXU:约 1,153 TFLOP/s;
  • 普通 FP32 VPU:8×128×4×2.2 GHz≈9.08 \times 128 \times 4 \times 2.2\ \text{GHz} \approx 9.0 TFLOP/s。

这个 VPU 数字的拆法是:VPU 的向量寄存器按 8 条 sublane × 128 条 lane 组织,每条 lane 每个周期处理 4 个 FP32 值(128 位),乘上频率就是峰值。于是

Rmxu=PmxuPvec≈11539.0≈128:1R_{\text{mxu}} = \frac{P_{\text{mxu}}}{P_{\text{vec}}} \approx \frac{1153}{9.0} \approx 128 : 1

也就是说,MXU 在单位时间内能完成的浮点运算量,是 VPU 的约 128 倍。这个比值不是巧合:它恰好接近 d=128d = 128 时的注意力比例。

看一个注意力头的前向工作量。设序列长度 NN、head dimension dd,单头的主项有两块:QK⊤QK^\top 需要 2N2d2N^2 d 次浮点运算,PVPV 也需要 2N2d2N^2 d 次,合计

Wmm=4N2dW_{\text{mm}} = 4N^2 d

而 softmax 需要对每一个 score 做一次指数运算,共 N2N^2 次:

Wexp⁡=N2W_{\exp} = N^2

比例就是

WmmWexp⁡=4d:1\frac{W_{\text{mm}}}{W_{\exp}} = 4d : 1

当 d=128d = 128 时,这个比例是 512:1512 : 1。但完整的 softmax 远不止一次 exp:它还包括每行的最大值、减去最大值、行内求和与重缩放。把这些都折算成 FP32 向量等价操作,记为每 score 的有效成本 csmc_{\text{sm}}(以 FP32 向量加法为单位),那么理想重叠下 softmax 与矩阵乘的时间比就是

tsoftmaxtmm=128 csm4d=csm4(d=128)\frac{t_{\text{softmax}}}{t_{\text{mm}}} = \frac{128\, c_{\text{sm}}}{4d} = \frac{c_{\text{sm}}}{4} \quad (d = 128)

推导过程是这样的:softmax 的总工作量是 N2csmN^2 c_{\text{sm}} 个 FP32 向量操作,VPU 峰值是 PvecP_{\text{vec}};矩阵乘的总工作量是 4N2d4N^2 d,MXU 峰值是 PmxuP_{\text{mxu}}。两者耗时之比为

tsoftmaxtmm=N2csm/Pvec4N2d/Pmxu=csm4d⋅PmxuPvec=csm4d⋅128=csm4\frac{t_{\text{softmax}}}{t_{\text{mm}}} = \frac{N^2 c_{\text{sm}} / P_{\text{vec}}}{4N^2 d / P_{\text{mxu}}} = \frac{c_{\text{sm}}}{4d} \cdot \frac{P_{\text{mxu}}}{P_{\text{vec}}} = \frac{c_{\text{sm}}}{4d} \cdot 128 = \frac{c_{\text{sm}}}{4}

分子分母里的 N2N^2 约掉了,最后的系数只剩 csm/4c_{\text{sm}}/4。这个结论很干净:当每 score 的有效 softmax 成本超过 4 个向量等价操作时,softmax 就会比矩阵乘更慢;当它小于 4 时,才有机会被矩阵乘覆盖——而且还必须满足流水依赖。

这就是 FlashAttention-3 一类工作的出发点:在 GPU 上,softmax 的向量工作与 GEMM 在同一类 SM 上竞争资源;在 TPU 上,softmax 落在 VPU、矩阵乘落在 MXU,两者是不同单元,理论上可以重叠。但重叠的前提是 csm<4c_{\text{sm}} < 4,否则 VPU 本身就是瓶颈。8t 的官方说明强调”增强了 VPU 配比与重缩放能力”,但没有给出绝对的 VPU 吞吐,所以这个定量基线使用的是 v7x,换到 8t 上只能按方向定性判断:VPU 变强意味着临界成本 csmc_{\text{sm}} 的阈值也会变化,具体数值需要按实际 kernel 测量。

head_dim 与 MXU tile 的对齐

MXU 与 VPU 的配比之外,另一个经常被忽略的细节是 head dimension 与 MXU tile 宽度的对齐。QK 计算时归约轴是 head dimension dhd_h,如果 dhd_h 不是 256 的倍数,归约就会被补齐到 256 的 tile 上,补齐的部分乘的是零。

考虑固定的投影宽度 4096:32 个 head、每个 128 维,与 16 个 head、每个 256 维,两者参数量和 FLOPs 完全相同。但 head_dim = 128 时 QK 与 PV 只填满 256×256 MXU 的一半,注意力这部分最多只能跑到 MXU 峰值的一半;head_dim = 256 时则是全宽度匹配。Google 的协同设计指南在 Qwen3-30B MoE 上做了实测:把注意力从 32×128 改成 16×256,参数与 FLOPs 不变,8K 上下文时训练 MFU 从 23.1% 升到 28.1%,16K 时从 23.3% 升到 30.8%,32K 时从 23.7% 升到 34.7%。上下文越长,提升越大,原因也直接:注意力的耗时占比随序列长度平方增长,空闲的那一半阵列在 32K 时浪费得最多。

这个建议对推理同样成立。对推理服务来说,head_dim 的选择在模型定型时就固定了,推理框架能做的只是把一个已经对齐的模型放到正确的硬件上;但如果要设计新模型,或者要决定在哪种 TPU 上服务哪种模型,这一条就是最省力的收益来源——它不需要写新 kernel,只需要在模型结构上做一次参数不变的重排。

TPU 与 GPU 的计算组织差异

把 TPU 的一个 TensorCore 与 GPU 的一个 SM 并排看,能解释很多”为什么 TPU 的 kernel 要这样写”的问题。

TPU v7x 的 TensorCore 内部是协同工作的整体:一个 256×256 的 MXU 加一个 VPU,VMEM 由编译器或 kernel 显式管理数据复用,旁边还有 SparseCore / CAE 承担专用能力。GPU(以 A100 为例)则是许多 SM 并行:每个 SM 有 4 个 Tensor Core、CUDA / SFU 单元、寄存器堆、共享内存 / L1,所有 SM 共享一块 L2 Cache 与 HBM。A100 每个 SM 的 4 个 Tensor Core 每拍合计 1,024 次 FP16 FMA,按吞吐折算约等于 16×16 个 MAC 的规模——这个 16×16 是等效规模,不是物理阵列;完整的矩阵乘还要沿 K 维归约。

两种组织的后果是:

  • TPU 靠一个大阵列吃大 tile:归约轴与输出维度对齐影响阵列利用率;一个 kernel 内可以安排很长的 DMA 流水。
  • GPU 靠很多小单元吃并行:多个 block 分到不同 SM,靠占用率与延迟隐藏;单个 Tensor Core 的 tile 较小,但可以同时跑很多个。
  • TPU 的片上存储是显式管理的:VMEM 不是缓存,放什么由编译器 / kernel 决定;GPU 的 L1 / L2 是硬件缓存,命中率由访存模式决定。

这就是为什么同一份注意力代码在 GPU 与 TPU 上需要不同的分块策略:GPU 侧优化的是占用率与合并访存,TPU 侧优化的是 tile 形状与 MXU 对齐。

多精度峰值对照

第八代官方只列出了 FP4 峰值,没有给出 FP8 / BF16 的绝对数字。把已知的各代与 NVIDIA 对照放在一起,可以看清精度口径的差异(NVIDIA 数据统一采用 Dense 口径,H200 的 Sparse 值除以 2,B200 由 HGX 8-GPU 表换算为单 GPU):

矩阵精度单位8t8iv7 / v7xv6eH200 SXMB200 SXM
FP4PFLOP/s12.610.1———9.0
FP8PFLOP/s——4.6140.9181.9794.5
BF16PFLOP/s——2.3070.9180.98952.25
FP16PFLOP/s————0.98952.25
INT8POP/s———1.8361.9794.5

”—“表示官方未列该精度峰值。读这张表要注意三点:第一,INT8 的单位是 POP/s(每秒操作数),不能与 PFLOP/s 直接比较;第二,不同厂商的”峰值”是否含稀疏、是否按 boost 频率计算并不统一;第三,8t/8i 的 FP4 格式(编码、缩放细节、是否等同 NVFP4)官方尚未公开,所以 FP4 那一行的横向比较只能看数量级。对推理选型来说,真正有意义的比值是”同一芯片上低精度与 BF16 的峰值比”,因为它决定了用低精度换来的理论加速上限。

SparseCore 与 CAE:两个专用引擎的位置与职责

SparseCore 的数据通路

SparseCore 是 TPU 从 v2 起就存在的单元,v4 把它做成每芯片 4 个、每个 16 个计算 tile,tile 各绑一条 HBM 通道,配 2.5 MiB 的分 bank 片上存储(spmem),内部有 8 宽 SIMD 的 scVPU 以及取数与写回单元。它执行的是类似 v1 的 CISC 指令,操作数长度可变,单条指令的运行时间依赖数据。

它的数据通路大致是”取数 → 向量计算 → 写回”:Fetch 单元按索引从 HBM 读入参数或激活,交给 scVPU 做 8 宽 SIMD 运算(排序、稀疏归约、fork/concat 等),再通过 Cross-Channel Unit 跨 tile 聚合后 Flush 回去。对应的工作包括按 ID 查找嵌入向量、聚合结果、在反向传播时写回更新。重点是细粒度、不规则的数据访问与搬运,而不是把稀疏输入直接送进大矩阵阵列。

这个设计的动机来自推荐模型:嵌入表从几十 MiB 到几百 GiB,查表本身是低算术强度的随机访存,放在 TensorCore 上会浪费宽 VPU 与 MXU,放在主机 CPU 上又会被 DRAM 带宽卡死。SparseCore 用大约 5% 的芯片面积和功耗,把这类负载加速了数倍。

在第八代上,SparseCore 的用法又多了一条:TorchTPU 的 Stream API 可以把某个 stream 手动绑定到 SparseCore。这样集合通信(如 all-gather)与稀疏 gather 就能和 TensorCore 上的矩阵乘并行执行。PyTorch 侧的同步语义与 GPU 一致,但底层落在不同单元上。这个能力在 8t 上尤其重要,因为训练里全归约和 reduce-scatter 每层都出现;而 8i 不用 SparseCore,用 CAE 来承担集合通信。

CAE:为什么把集合通信引擎放在 ICI 边上

CAE(Collectives Acceleration Engine,集合通信加速引擎)是 8i 的专用引擎,负责跨核心的聚合与同步。官方给出的结果非常明确:相对 Ironwood,片上集合通信延迟约为五分之一。但 CAE 的内部结构官方没有公开,所以能做的只有两类有依据的推断,并明确标为推断:

  1. 靠近通信接口。CAE 位于 ICI 区域附近,意味着数据从 ICI 进来之后不需要先往返 VPU 做归约,可以缩短搬运、控制交接与物理路径延迟。
  2. 专用归约数据通路。多路加法树或流水线可能每拍接收多组向量数据,减少通用 VPU 的指令与中间结果往返。

这两点都是基于架构图的合理推测,每拍宽度与流水线深度没有公开,不能当成定论。可以确定的是收益的量级:五倍的片上集合通信延迟下降。对推理意味着什么?张量并行(TP)的每个 Transformer 层都要做 all-reduce 或 reduce-scatter,推理 decode 阶段每生成一个 token 都要走一遍,且 batch 小、每层通信数据量小、通信延迟占比高。所以”集合通信延迟降五倍”不是锦上添花,而是 decode 延迟的关键路径优化。这也是 8i 与 GPU 推理集群的差异所在:GPU 靠 NCCL 在 SM 上执行集合通信,与计算争抢资源;8i 把集合通信交给专用引擎,并放在离 ICI 最近的位置。

上图是 Boardfly 的三级结构。最底层是一块板上 4 颗芯片的全连接(building block,下文简称 BB),中间是 8 块这样的板全连接成一个 Group,最上层是 36 个 Group 通过 OCS 配置的光路连接成 pod。物理上一共 36×8×4=115236 \times 8 \times 4 = 1152 个位置,最多可启用 1024 颗芯片。CAE 就位于每一颗芯片的集合通信路径上,负责把这一层层结构中的聚合操作从 TensorCore 手里接走。

VMEM 与 KV Cache:384 MB 片上容量能装多少

片上存储的分工

VMEM 与 HBM 的分工可以用一句话概括:VMEM 保存可复用的 tile 和中间状态,HBM 容纳更大的工作集;增加 VMEM 可以减少重复读取 HBM。8i 的 384 MB VMEM 大约是 8t 的 3 倍,也大概是 Ironwood 每芯片的三倍(Ironwood 每 chip 192 GiB HBM、每 device 96 GiB,VMEM 每 TensorCore 64 MiB)。这个容量改动直接改变了一件事:更大块的中间 tile、热点状态或部分 KV 工作集可以驻留在片上,减少往返 HBM 的次数。

但容量如何分工,必须算清楚:VMEM 远小于 HBM,模型大小、序列长度与 batch 仍然决定容量需求。VMEM 由编译器或 kernel 显式管理数据驻留——它不是一个自动缓存,什么时候把什么放进 VMEM 是 kernel 作者和编译器共同决定的事。

KV Cache 的片上容量估算

一个自然的疑问是:384 MB 的 VMEM 能装下多少 KV 缓存?用一个具体模型来算,会比空泛地谈”能装下部分 KV”清楚得多。以 Qwen2.5-72B 为例:L=80L = 80 层,隐藏宽度 dmodel=8192d_{\text{model}} = 8192,KV head 数 Hkv=8H_{kv} = 8,Hq=64H_q = 64(GQA 分组),head dim dh=128d_h = 128。KV 的宽度是 Hkvdh=1024H_{kv} d_h = 1024,而不是隐藏宽度 8192——这是 GQA 的关键。

单层单 token 的 KV 字节数为

Mtoken=2⋅L⋅Hkv⋅dh⋅b/PkvM_{\text{token}} = 2 \cdot L \cdot H_{kv} \cdot d_h \cdot b / P_{kv}

其中系数 2 是 K 与 V 各一份,bb 是每值的字节数,PkvP_{kv} 是 KV 被切分的份数(张量并行时每张卡只持有其中一份)。全 80 层、所有请求合计可驻留的 token 总数上限为

Ttotal=⌊CMtoken⌋,C=384×106 bytesT_{\text{total}} = \left\lfloor \frac{C}{M_{\text{token}}} \right\rfloor, \quad C = 384 \times 10^6 \ \text{bytes}

把几种情景代入:

缓存情景HkvH_{kv}PkvP_{kv}KiB / token / chip可驻留 Token 总量
MHA,BF16(同宽度参照)6412,560146
GQA,BF16(模型实际结构)813201,171
GQA,8-bit(容量情景)811602,343
GQA,BF16,8 路 KV 分片88409,375

读表有三点需要注意。第一,MHA 那一行只是同宽度参照,不代表模型真实结构;真实结构是 GQA,KV 宽度只有 1024,容量一下就上去了。第二,表中是”全 80 层、所有请求合计”的理想容量上界,没有计算量化元数据与内存对齐;384 MB 是每 chip 的汇总 VMEM,实际要按 core 分配、还要给计算 tile 留空间。第三,多条请求共享表中的 token 总预算——这说明即使 384 MB 在单 chip 口径下能装几千 token,真正部署时仍然是”片上放热点、HBM 放主体”的分层结构,VMEM 的作用是减少而非消除 HBM 往返。

VMEM 在 kernel 中的三种用法

把上面这段容量账和 kernel 写法对照,VMEM 的价值体现在三种具体用法上:

  • 让更大的 tile 驻留:注意力 kernel 分块时,把 Q tile 和若干 K/V 块放进 VMEM,避免每块都从 HBM 重新读。
  • 让中间状态驻留:混合精度运算中的 FP32 累加器、softmax 的中间缩放因子。
  • 让部分 KV 工作集驻留:长上下文的推理中,把当前正在解码的请求的 KV 放进片上,其余留在 HBM。

这三种用法都不是”自动”的:VMEM 需要编译器或 kernel 显式管理。TorchTPU 博客里对 TPU 编程模型的描述也印证了这一点——TensorCore 可以想象成单线程处理器,达到峰值性能的关键是让形状足够宽以充分利用 MXU,这与 GPU 上”启动许多小 kernel 并行”最大化利用的策略不同。

互联:DMA、RDMA、TPUDirect 的数据路径

在讨论拓扑之前,先把”数据怎么进内存”讲清楚,否则拓扑的收益很容易被误解成”跳数少就等于快”。

本地 DMA 与远程 RDMA

DMA(Direct Memory Access)让搬运引擎直接读写内存,不需要 CPU 逐字节参与。本地 DMA 在一个设备或主机范围内搬数据,比如把一个 tile 从 HBM 搬到片上缓冲区。RDMA(Remote DMA)把这种直接访存扩展到远端:数据跨设备或主机直接到达远端存储,绕开 CPU 的 staging(中转)拷贝。

一个常见的误解是”用了 DMA/RDMA 就不再需要 CPU”。事实并非如此:CPU 仍然负责配置与协调,DMA/RDMA 减少的是数据路径上的逐字节搬运,不表示整个流程可以脱离 CPU。在 TorchTPU 的工具链里,这一点也通过初始化流程体现出来:TPU 的分布式初始化需要事先知道拓扑形状和每台设备的地址,这些信息由进程在启动时显式配置,而不是像 GPU 上那样运行时自动发现。

TPUDirect:从 HBM 直连 NIC,再延伸到存储

TPUDirect 把 DMA/RDMA 的思路延伸到主机侧的网络与存储。它有两个变体:

  • TPUDirect RDMA:HBM 与 NIC 直接交换,减少 Host staging。
  • TPUDirect Storage:把路径进一步延伸到存储系统(如 Managed Lustre),让存储数据绕过主机内存直接进 TPU。

不启用 TPUDirect 时,数据路径是 TPU HBM → Host DRAM → NIC;启用后是 TPU HBM ↔ NIC,远端再按具体场景处理。对训练来说,这两项解决的是数据管道喂料问题:算力越大,存储读不上来的代价越高。官方给出的提升包括 10 倍速的存储访问。

这三者(本地 DMA、远程 RDMA、TPUDirect)的关系可以用一句话概括:DMA 是机制,RDMA 是机制的远端版本,TPUDirect 是把它接到主机网络与存储上的一套路径改造。它们都只降低数据搬运的开销,不改变数据在哪个设备上;后者由拓扑与并行策略决定,也就是下面几节的内容。

通信语义:三类 Collective 与 LLM 里的出现位置

三类操作的区别

集合通信有三类基本操作,区别在于结果如何分布。以四个 rank 为例:

  • AllReduce(求和):四个 rank 分别持有 1、2、3、4,归约后每个 rank 都得到 10。
  • AllGather:各持有 A、B、C、D 的一片,拼接后每个 rank 都得到完整的 [A, B, C, D]。
  • AllToAll:各 rank 按四个目的地切分数据,每个 rank 收到来自四个发送方、发给自己的片段。

容易混淆的三件事:AllGather 是拼接,不做求和;AllReduce 是归约,不保留各 rank 的独立输入;AllToAll 是重分布,每个目的地通常收到不同的数据。这三类操作在 LLM 训练与推理里出现的时机完全不同,理解时机才能理解为什么拓扑要按通信频率来设计。

LLM 中的 Collective 出现在哪里

操作训练场景推理场景发生时机 / 数据
AllReduceDDP 同步梯度;TP 汇合局部结果Attention 输出投影与 MLP 的局部和汇合每个 TP 层;TP 局部输出
AllGatherFSDP 在层计算前收集参数;部分 SP/TP 收集激活需要完整激活的 TP/SP 布局转换参数 shard 或激活 shard
AllToAllEP 把 Token 分配给远端 Expert,计算后 CombineMoE Expert Parallel 的 Dispatch / Combine每个 MoE 层;目的地取决于 Router

一个可以从头复算的数量级算例能说明通信规模。假设 80 层 Dense、TP = 8、隐藏宽度 8192、BF16,普通 TP 无 Sequence Parallel,每层 2 次 AllReduce。

Prefill 输入 4096 个 token 时,每次 AllReduce 的输入大小是

M=4096×8192×2 bytes=67.1 MBM = 4096 \times 8192 \times 2 \ \text{bytes} = 67.1\ \text{MB}

Ring 算法下每个 rank 的发送量为 2(P−1)M/P2(P-1)M/P,一次前向共 80×2=16080 \times 2 = 160 次 AllReduce,于是每 rank 的发送总量约为

160×2×78×67.1 MB≈18.8 GB160 \times 2 \times \frac{7}{8} \times 67.1\ \text{MB} \approx 18.8\ \text{GB}

Decode 阶段如果 batch = 1、单 token,每次 AllReduce 的数据降到约 16 KiB 量级,总发送量约 4.6 MB / rank——数据量小了两个数量级,但同步次数不变,仍然是 160 次。这正是推理与训练对互联要求不同的原因:训练在乎吞吐(大量数据要被送出去),低并发推理在乎延迟(很多次同步,每次数据很少)。预填充阶段是带宽受限,解码阶段是延迟受限,而这两个阶段恰好对应 8t 和 8i 的两种设计取向。

这个算例只计了这一种 TP 方案的 AllReduce 发送量,不包含协议开销、MoE 与 FSDP 通信;融合、分片和算法(如 Ring 换成 Tree)都会改变结果。GB / MB 按十进制计。

Pod 内拓扑:从 3D Torus 到 Boardfly

3D Torus 的逻辑连接与物理布线

Torus 规定每颗芯片六个逻辑邻居——沿 x、y、z 三个方向各成环,每个方向两个邻居。这个规则是固定的;可变的是物理成员与边界光路:同样大小的逻辑 Torus,可以由不同的健康立方体(Cube)成员组成,立方体之间的邻接和回绕连接由 OCS 配置。

这里要把两件事分清:Torus 规定”谁和谁是邻居”,OCS 决定”哪些物理立方体通过哪条光路拼成这个网络”。两者并不矛盾。Torus 本身就是一种可以绕过故障节点的拓扑:把相邻逻辑边与回绕逻辑边区分开,回绕边就能通过 OCS 跳到更远的一个健康立方体上去。重配置发生在资源分配与故障处理阶段,而不是每个数据包到来时换一次拓扑。

一条链路可以走铜也可以走光,协议名称本身不指定传输介质。这是理解 ICI 与 NVLink 对比时的关键——两者都是”scale-up 链路”,只是承载的介质与拓扑组织方式不同。

最坏跳数:一个可以直接算的数

3D Torus 里最远的点只需要走半周,所以三个维度的最坏距离相加就是网络直径:

D=⌈nx/2⌉+⌈ny/2⌉+⌈nz/2⌉D = \lceil n_x / 2 \rceil + \lceil n_y / 2 \rceil + \lceil n_z / 2 \rceil

对一个 8×8×168 \times 8 \times 16 的 Torus,三个维度的最坏距离分别是 4、4、8,合计

D=4+4+8=16 hopsD = 4 + 4 + 8 = 16\ \text{hops}

这是一个理想最短路径模型,实际通信延迟还取决于拥塞、每跳时延和消息大小。但它的价值在于:它给出了一个可以横向比较的硬指标。Boardfly 的设计目标就是把这个数字压下来。

Boardfly 的七跳路径

TPU 8i Boardfly 拓扑的三级结构:4 芯片全连接组成 BB,8 个 BB 组成 Group,36 个 Group 组成一个 pod

上图来源是 Google 第八代 TPU 发布博客的 Boardfly 拓扑图。Boardfly 借鉴了 Dragonfly 的分层连接原则:4 芯片全连接 → 8 个 BB 全连接成 Group → 36 个 Group 通过 OCS 光路互连。在 1024 颗 chip 的官方对照中,网络直径从 Torus 的 16 跳降到 7 跳,降低约 56%(官方口径是”超过 50%”)。

七跳的来源可以沿着官方给出的路线逐跳数:源芯片 → 本地 BB → 本 Group → 跨群组的光路 → 目的 Group → 目的 BB → 目的芯片。关键在于跨群组的那一段是一次光路直连,而不是像 Torus 那样在每个中间节点上逐跳转发。所以 Boardfly 让一个 1024 芯片规模的网络拥有近似”分组交换 + 高 radix”的直径,代价是群组间的连接要靠 OCS 配置——这与 Torus 的优点是两条不同的路:Torus 用规则的邻里关系扩展,布线简单、每颗芯片只需六条链路;Boardfly 用分组与远程连接来降低直径,换取更低的平均与最坏跳数。

Torus 与 Boardfly 的取舍

两种拓扑的优劣取决于通信流形,不能脱离工作负载判断:

  • 规则通信多的负载(如大规模张量并行的环形 all-reduce、邻近 chip 的集合通信):Torus 的邻里链路能把这些流量放到相邻芯片上,走一两跳就完成,效率高。
  • 随机、全局通信多的负载(如 MoE 的 all-to-all,目的地取决于 router 选出的专家):Boardfly 的低直径把最坏跳数从 16 压到 7,等价于把这一类流量的上限压低。

8t 用 3D Torus,8i 用 Boardfly,这个分工与上一节的通信时机分析一致:训练侧的大部分通信是规则的、按层的、可以预测的,Torus 的邻居链路能覆盖;推理侧尤其是 MoE 推理的 all-to-all 是随机且全局的,低直径更有价值。这也是为什么 8i 要专门强调 Boardfly 是为”今天最强推理模型的通信需求”设计的。

跨 Pod:Virgo 与 Leaf-Spine

ICI 的扩展范围有边界;跨 Slice / Pod 的通信由 Virgo 与 DCN 承担。Virgo 用两层交换组织跨 Pod 连接,并以独立的 Plane 划分控制域,减少层级并隔离故障影响。单 Plane 的 Leaf-Spine 结构是这样的:TPU 通过 NIC 接入 Leaf,Leaf 连接到不同 Spine,Spine 再连接其他 Leaf。

Virgo 的公开结构可以概括成”两层交换 + 独立 Plane”:Leaf 层接入各 pod 的 NIC,Spine 层连接不同 Leaf;多个 Plane 各自有独立的控制域,一个 Plane 出故障不会影响其他 Plane。这与 ICI 在同一 pod 内走直接链路的结构完全不同——跨 Pod 的数据交换走的是独立的网络层级,因此带来了一个非常实际的性能差异:ICI 带宽与 DCN 带宽差一个数量级,任何并行策略的第一步都是把通信最重的维度放到最快的 ICI 维度上。

Leaf-Spine 本身描述的是连接关系,不规定铜还是光介质,也不指定 ICI、NVLink 或 RDMA 协议。这个区别在跨厂商对比时经常被混淆:NVIDIA 的跨 NVLink 域也是 NIC 接入 InfiniBand / Ethernet 的 Leaf-Spine,而 NVSwitch 专门负责 NVLink 域内的交换;TPU 侧 ICI 负责 pod 内,Virgo 负责跨 pod。两套体系的层次划分是对应的。

物理连接与公开带宽

把各代 pod 的规模与公开带宽放在一起,可以看到一个趋势:Pod 规模随代际增长,但真正改变的是每条链路的带宽与拓扑类型。

范围规模与连接方式公开带宽口径
v6e Pod256 chips;2D Torus800 GB/s / chip ICI双回聚合
v7 / Ironwood Pod9,216 chips;3D Torus1,200 GB/s / chip ICI6 条链路,双向;每条 ICI link 200 GB/s
8t superpod9,600 chips;3D TorusICI 约为 v7 的 2 倍官方代际比较
8i Pod1,152 位置,最多 1,024 active;Boardfly,组内铜 / 组间光ICI 19.2 Tb/s原文 ICI 总带宽,算术换算 2.4 TB/s
Virgo 跨 Pod Fabric超过 134,000 颗 8t最高 47 Pb/s整个 Fabric 对分带宽

两个容易出错的点。第一,47 Pb/s 是 Fabric 级指标,不能与每 chip 的 ICI 数字直接相除比较——一个是整个网络的对分带宽,一个是单芯片的链路带宽,口径完全不同。第二,铜 / 光的单链路速率与端口分配未完整公开,不能从 per-chip 总带宽反推单链路速率。这两条限制在横向引用时都必须保留,否则会得到一些看似精确实则无意义的数字。

软件栈:从 PyTorch 到 TPU 执行的四个角色

四个角色的分工

理解 TorchTPU 的第一步是认清四个角色,以及它们分别负责什么:

工作TPU 路径负责什么GPU 生态参照
模型表达PyTorchTensor、模型与自动微分同样使用 PyTorch
接住算子TorchTPU Backend接收 ATen 操作,保持框架语义PyTorch CUDA Backend
编译计算图StableHLO + XLA融合算子、安排布局、生成程序Inductor / Triton 路径
设备执行PjRT / libtpu编译请求、Buffer 与异步执行CUDA Runtime / Driver
编写热点Pallas + Mosaic手动控制 tile、DMA 和流水CUDA / Triton / CUTLASS

这张表的最后一列是理解 TorchTPU 的关键参照:它并非另起炉灶,而是与 GPU 生态一一对应的路径。PyTorch 的 dispatcher 里注册一个新的 C++ 后端(设备类型 PrivateUse1),张量存储用 c10::StorageImpl 加 c10::UniqueVoidPtr 指向 TPU 侧的 Deferred Op 对象;上层 autograd、view、分布式都照常工作。这就把”PyTorch 程序如何落到 TPU”变成了一个可以在框架层面理解的问题,而不是”把 PyTorch 翻译成 JAX”。

TPU 的编程模型与 GPU 的差别

PyTorch 官方博客给出的一段描述值得一字不差地理解:一个 TensorCore 设备可以想象成单线程处理器,带一个或多个巨大的矩阵乘单元(MXU)。因此要达到峰值性能,关键让模型的形状足够宽,以充分利用 MXU;这与 GPU 上”启动多个较小的 kernel 并行,最大化硬件利用率”的思路不同。

由此推出对工程有实际含义的三个推论:

  • 性能可预测:TensorCore 同一时刻只执行一条指令流,没有乱序、没有多线程抢占;只要程序结构固定,执行时间就基本固定。
  • 并行度来自数据分块而不是线程:Pallas 的 grid 默认按字典序串行迭代,相邻迭代如果复用同一块输入切片,HBM 传输会被自动跳过;多次迭代写同一块输出切片也不会竞争,只要这些迭代是连续的。
  • 异步执行靠 DMA 引擎:kernel 发起 DMA 拷贝后可以去算别的,需要结果时再等。这就是后文所有流水线优化的基础。

Pallas 文档里有一个很准确的类比:TPU 更像 CPU 而不是 GPU——它是一台顺序执行的机器,带一个非常宽的向量寄存器,允许软件把某些操作调度到后台异步执行(HBM 访存、矩阵乘、转置与 permute)。这个心智模型在写 kernel 时比”类比 GPU”有用得多,尤其是在讨论流水与异步时。

TorchTPU 的 Eager 执行:DeferAndFuse 与物化点

三种 eager 模式

TorchTPU 的 eager 执行与普通 PyTorch 有一个本质区别:Aten 算子可以以三种方式被送到 TPU 上——立即执行(逐算子提交)、延迟到某个自动确定的物化点(materialization point)后与之前所有延迟的算子聚合编译、或介于两者之间的任何粒度。这种灵活性带来额外复杂度,但它是从设计之初就刻意保留的,因为要实验不同的策略来改善 eager 性能。

三种模式如下:

  • Strict(默认):一次派发一个 Aten 算子,在 TPU 上异步执行,CPU 不等结果。等价于在 GPU 上跑 PyTorch eager。
  • Debug(TORCH_TPU_LAUNCH_BLOCKING=1):一次派发一个算子,但 TPU 执行与 CPU 同步。很慢,用于调试,等价于 GPU 上的 CUDA_LAUNCH_BLOCKING,额外打开了边界检查。
  • DeferAndFuse(TORCH_TPU_DEFER_AND_FUSE=1):把多个 Aten 算子延迟并融合成更大的块。官方给出的说法是它可以比 Strict Eager 快 50% 以上,同时降低峰值 HBM 占用(算子融合减少了 HBM 中的临时存储)。

DeferAndFuse 的执行路径

以 aten::mul 为例,DeferAndFuse 模式下收到 dispatcher 回调时会发生四件事:

  1. 创建一个 Deferred Op 实例,内含一个 StableHLO builder(被调用时返回实现 aten::mul 语义的 StableHLO 函数)、一个可选的静态算子参数映射(用于计算缓存 key,比如 native_batch_norm 的 training/momentum 参数)。
  2. 返回一个新的 at::Tensor,其 c10::StorageImpl 通过间接方式指向这个 Deferred Op 实例。
  3. 收到 mytensor.to("cpu")、mytensor.item() 之类触发物化点时,分析到目前为止累积的 deferred ops 中、计算 mytensor 所需要的区域 RR。
  4. 对 RR 做存活分析,确定哪些算子需要被物化——有副作用的算子(如集合通信)总是保留,且保持调用顺序;在 RR 之外不存活的算子可以确定性地检测出来,因为 Python 的内存管理基于引用计数,跨不同负载副本结果一致。

然后是缓存检查:为要物化的图 GG 构造编译缓存 key,查缓存;命中则直接派发可执行文件,未命中则在线程池里异步编译后派发。最后等待 TPU 值就绪,拷贝到 CPU 目标张量。

这里有一个容易被忽略但非常重要的细节:CPU 只在到达 .to("cpu") 时才启动 TPU 执行,表面上看很浪费。但对真实负载来说,在几次初始迭代填充编译缓存之后,CPU 执行只涉及 PyTorch 的 tracing 与算子派发,永远跑在 TPU 的数值计算前面。为进一步加速那些重复多次的算子序列(比如一叠 Transformer 块),还加入了 Repeated Ops Heuristic,检测这类重复并在到达 TPU→CPU 传输之前就触发物化点。

编译缓存的三层结构

编译缓存分三层,与存储系统的缓存层级类似:

  • Tier-1:进程内的内存缓存,同一进程内共享编译结果,最快。
  • Tier-2:主机内共享内存,跨进程共享;多设备训练 / 推理时有用。分布式程序默认启用,单设备程序默认关闭。
  • Tier-3:远程文件系统(如 GCS)支持的持久缓存,跨主机、跨程序、跨任务重启复用。默认关闭,需要显式指定共享存储路径。

缓存 key 的设计值得单独说:不使用 StableHLO 图本身作为 key,而是把计算、编译选项和主要组件版本指纹化成三个 64 位整数,组成 192 位的 key:

  • shape-less key:捕捉图的结构,但不含张量输入输出的尺寸;
  • dimensions key:捕捉张量尺寸;
  • compile options key:捕捉传给 XLA 编译器的选项,以及 TorchTPU、libtpu、PjRt runtime 的版本。

前两者合称 graph key。192 位的 key 空间在实践中足够大,不会出现不同图、编译选项与组件版本之间的碰撞。这个设计与 GPU 侧 Triton 的 JIT 缓存思路一致,但 key 的维度划分更细——特别是把组件版本纳入了 key,这正是 TPU 栈”编译器本身就是系统的一部分”的体现。

视图语义:StableHLO 的纯函数性与 PyTorch 的可变性

PyTorch 与 StableHLO 在可变性和共享内存视图上的语义差异,是 TorchTPU 必须自己解决的一个问题:

  • PyTorch 假设每个 Tensor 是指向线性字节数组的指针,带 stride 元数据描述逻辑索引到线性偏移的转换。多个 Tensor 可以共享同一底层数组,就地写入对任何其他 Tensor 可见;view 操作可以在 CPU 派发时通过更新元数据廉价地完成。
  • StableHLO 是纯函数语言,所有张量值构造后不可变,物理布局对用户抽象、反映编译器做的 tiling 决策,不支持直接改 stride;就地写入不支持,子切片更新通过 dynamic_update_slice 来把一组新值合并进已有张量。

在有写入的情况下在 TPU 上正确实现视图语义并不简单,TorchTPU 用了”视图分解、视图反演、deferred ops”的一套机制做这件事。这个语义桥接让 PyTorch 里一些本来无法实现的模式(比如分布式训练里拼接的参数数组)可以原生支持。这是纯 PyTorch 后端必须自己承担的工作,也是它区别于”把 PyTorch 翻译成 JAX”的根本。

Stream 与 SparseCore

GPU 上为了同时执行三类操作(计算、集合通信、主机-设备数据传输),用不同的命令队列(Stream)让设备把工作分派到不同硬件单元。PyTorch 的 Stream API 在 TorchTPU 中也实现了,但并非所有情况都能做到和 GPU 一样:

  • 由于 TensorCore 本质上是单线程执行处理器,一个 TensorCore 同一时刻只能派发一个计算。
  • 一个 TensorCore 关联一个或多个 DMA 引擎和一个或多个 SparseCore 引擎。DMA 引擎可以在 TensorCore 计算的同时做数据传输;SparseCore 是独立单元,擅长稀疏操作,也能支持集合通信。
  • 因此,一个 TorchTPU stream 可以手动绑定到 SparseCore,这类 stream 与默认的 TensorCore stream 在性能与算子支持完整性上不同。
  • Stream 也可以用来协调异步数据传输(用 DMA 引擎),与 GPU 上类似。

这里的工程含义很具体:GPU 上”多 stream 并发”的直觉,在 TPU 上只能通过”计算在 TensorCore、通信或稀疏工作在 SparseCore、搬运在 DMA”这种分工来实现。这也是为什么 8i 要把集合通信放到 CAE——当集合通信不再需要和计算争同一个单元时,并发的收益才真正落地。

编译模式、bounded dynamism 与 kernel

torch.compile 走 Dynamo

TorchTPU 的编译模式与其他 torch.compile() 后端保持一致,注册一个新的 TorchDynamo 后端:

compiled_model = torch.compile(model, backend="tpu")

Dynamo 传入 torch.fx.GraphModule 和示例输入张量,TorchTPU 像在 eager 模式下那样 tracing 整张图,但所有算子都被延迟、没有实际执行。这样可以为整个 FX 图生成并编译一个 StableHLO 程序,最后返回一个包装 TPU 可执行文件调用的 Python callable。一个临时限制:在 TPU 机器上调用 torch.compile 时会自动 dynamic=False,因为 bounded dynamism(支持 SymInts 需要它)还没有默认启用。这一点对推理服务有直接后果——形状变化较多的负载要么把序列长度分桶,要么接受重编译。

bounded dynamism:固定形状,动态描述数据

XLA 传统上基于静态形状生成优化的硬件布局与融合 kernel。在实践中这不算太严重的问题:某个维度(batch 或序列长度)变化时,开发者常用预分配更大的张量、前后手动 padding / slicing 来解决。但这样做的两个代价都很明显:手动改代码,以及形状变了要重编译。

bounded dynamism 的思路是:在编译期知道每个维度尺寸的最大上界,但实际维度在运行期才知道。于是动态缓冲区按最大上界在主模型模块内分配,图只编译一次;计算在这个有界缓冲区上执行,XLA 跟踪逻辑维度尺寸并自动处理 padding 与 slicing,不触发重编译。

这个机制和 TPU 的硬件特性很契合。看 Google 协同设计指南给的例子:变长请求与 MoE 路由不必每次重新编译,保持缓冲区形状固定,用小型整数元数据决定实际访问范围。

  • Dropless MoE:一个固定 TT 行的缓冲区、固定 tile 高度;group sizes 如 [96, 48, 120],group offsets 如 [0, 96, 144];一个 tile 可以跨两个 group,越界的行被 mask 掉;kernel 用 group sizes / offsets 描述各 Expert 的 token,循环边界是 cdiv(kv_len[seq], block) 之类,只 mask 掉 group 之外或超过 kv_len 的行。
  • Paged attention:KV 缓存是一个页池,用页表与 kv lengths 定位有效缓存;shape 静态,extent 是运行期整数。
  • Scalar Prefetch:把元数据(几百个 int32)在 grid 启动之前先送进标量内存(SMEM),让标量单元在 kernel 开始时就能读到它们,据此计算 DMA 地址与循环次数(如 PrefetchScalarGridSpec(num_scalar_prefetch=k, ...))。

如果不做这件事,每次新的 group 划分或序列长度就是一个新形状,XLA 要重编译、主机要等;或者每个 group 都 padding 到最大,MXU 去乘零。做了之后,形状在编译期固定,整数每一步都在变,kernel 按未 padding 的 FLOP 数运行。前一种的代价是编译停顿,后一种的代价是浪费算力;bounded dynamism 把两者都消掉了。

三档精度模式

TorchTPU 把 PyTorch 的精度设置映射到 XLA/StableHLO 配置,以暴露硬件能力:

维度CUDA 上的 PyTorchTPU 上的 PyTorch(TorchTPU)
默认精度模式highest(纯 FP32)medium(Precision.DEFAULT)
快速数学加速元件Tensor Cores(TF32)脉动 MXU(BF16)
快速数学位宽1 符号 + 10 尾数 + 8 指数(19 位 TF32)1 符号 + 7 尾数 + 8 指数(16 位 BF16)
累加精度FP32(highest 与 high),TF32(medium)所有模式均 FP32
更高精度机制专用 FP32/TF32 单元多遍算法分解(3 遍或 6 遍 MXU)
high/highest 的性能影响基线速度或小幅变慢(约 1–2 倍)high 约 3 倍 MXU 计算成本;highest 约 6 倍开销
作用域 API全局 torch.set_float32_matmul_precision全局 + torch.tpu.precision 上下文管理器

三档模式的工作原理可以这样理解。medium:乘法时把输入转成 MXU 原生的 BF16,累加在 FP32 里做,以保持稳定;这是 TorchTPU 的默认模式,因为单遍 BF16 乘 FP32 累加对几乎所有深度学习负载都足够精确。high:用 3 遍算法,把输入拆成高、低两部分,计算三个交叉项,以约 3 倍的计算成本恢复大部分 FP32 精度。highest:用 6 遍算法,计算所有交叉项,逼近完整 IEEE FP32 精度,MXU 上约 6 倍开销。

官方推荐绝大多数负载使用 medium;显式选择 high / highest 会触发一次性的性能警告。需要局部更高精度时,可以用线程局部的 torch.tpu.precision 上下文管理器,只对数值敏感的那几层提高精度,而不是全局付出 3 倍或 6 倍开销。

这个设计的核心思想是把精度换取算力的关系从硬件固定变成算法可调。在 GPU 上,FP32 有两种实现:专用 FP32 单元或 TF32;在 TPU 上,MXU 只有 BF16 原生,想要更高精度就得用多遍算法。多遍的遍数与恢复的精度成正比,但与 MXU 的峰值算力成反比——这正是后文”先判断多遍计算是否值得”那一条建议的来源。设低精度与 BF16 的峰值比为 rr,用 nn 遍低精度逼近高精度时,相对耗时至少为 n/rn/r;只有当 n<rn < r 时,多遍计算才可能比原生 BF16 更快。v7x 上 r=2r = 2,所以 high 的 3 遍在纯矩阵计算上就已经不划算;它存在的价值主要在于数值稳定性,而不是加速。

三种写 kernel 的方式

TorchTPU 把 kernel 分成两类:框架自带的(如 torch.nn.functional.scaled_dot_product_attention)和用户为加速模型特定部分写的自定义 kernel。对后者提供了三种方案:

  1. Pallas(生产可用):用 Pallas 写 TPU kernel,通过 @torch.tpu.pallas.jax_op 包装成 JAX 函数,再像普通 PyTorch 函数一样调用。这里有一个语义细节:out_shape 用 jax.ShapeDtypeStruct 描述,kernel 内部通过 pl.pallas_call 调用。
  2. Tokamax(生产可用):一个高性能 TPU kernel 库,与 PyTorch 无缝互操作,提供 MoE 构建块(分组矩阵乘、token gather/scatter)、注意力变体(paged attention、Gated DeltaNet、Kimi Delta Attention、multiheaded latent attention)以及 TopK 计算。它自带自动调优(tile size 搜索)、低开销的 XProf 基准测试与回归测试。kernel 本身用 JAX/Pallas 写,但基础设施通过 torch.tpu.pallas.jax_op 透明管理互操作。
  3. Helion(实验性):一个基于 PyTorch 的 DSL,可以针对多个加速器用同一套代码,@helion.kernel(backend="pallas") 指定 pallas 后端。

这三种方式的层次很清楚:Pallas 是底层、灵活性最高;Tokamax 是经过工程化的 kernel 集合,开箱即用;Helion 面向将来”一份 kernel 多平台复用”的场景。对推理服务来说,Tokamax 覆盖的 paged attention、gated deltanet 等都是长上下文与线性注意力模型的关键 kernel,这决定了新模型在 TPU 上能否”day-one”支持。

分布式:把集合通信做进编译器能看到的图

Process Group 层的 TPU 后端

TorchTPU 没有另造一套分布式 API,而是在 PyTorch 的 Process Group 层实现 TPU 后端:继承 c10d::Backend,注册为 tpu_dist。这样 eager 与编译模式下的集合通信都能被拦截,DTensor、FSDPv2、SimpleFSDP、FairScale 这些框架可以照常工作。

实现上有几个 TPU 特有的坑,每个都值得单独说。

初始化顺序不同。GPU 上一个 torchrun 启动的进程能看到主机上所有设备,可以先 model.to(f"cuda:{local_rank}") 再 init_process_group。TPU 上一个进程只能看到一个设备,也不知道主机上挂了几颗芯片。所以初始化之前,进程必须知道三件事:要跑分布式、world size 是多少、TPU 类型是什么(决定拓扑)。TorchTPU 用两个环境变量承载:TORCH_TPU_TOPOLOGY 给出 slice 的物理网格形状(如 "2,2,1"),TORCH_TPU_SLICEBUILDER_ADDRESSES 给出每台设备的地址和端口(如 "localhost:8471,localhost:8472,..."),用来构造 ICI 网络网格。也可以用 Python 的 torch.tpu.distributed.set_tpu_launch_env() 在 Google Cloud 环境里设置这些变量。

默认进程组的知识。torch.distributed.all_reduce 只接收当前子组;而 stablehlo.all_reduce 需要知道所有子组的划分,即使当前进程不在某些子组里。比如两个子组 (4, 0, 1, 3) 与 (5, 2, 6, 7),stablehlo 需要 replica_groups=dense<[[4,0,1,3],[5,2,6,7]]> 这样的完整信息。这就是为什么 TorchTPU 必须把整个默认进程组的信息传进编译后的模块。

MPMD 与集合通信不一致。TPU 栈历史上是为 SPMD 设计的:用户写一份单机程序,Shardy 负责在几千颗芯片上切分,XLA 负责在正确的位置插入集合通信。PyTorch 生态不是纯 SPMD:用户可能写 if rank == 0,DTensor 在维度不能整除时也会产生不均匀切分。不同 rank 生成不同的 StableHLO 模块时,sync flag ID 和缓冲偏移可能对不上,导致不可预测的死锁或内存损坏。

Skinny Collectives、@spmd_safe 与编译握手

TorchTPU 的默认对策是 Skinny Collectives:把每个集合通信算子单独编译成一个”瘦”StableHLO 模块,保证各 rank 的缓冲与同步 ID 一致。这能保证正确性,但代价是 XLA 无法把通信和计算重叠,端到端性能损失 30% 到 40%(官网博客给出的数字)。正在做的优化是把这些瘦模块放到绑定 SparseCore 的独立 stream 上,让它们和 TensorCore 上的数学重叠,官方预期能收回大部分损失。

如果用户确定某段代码是 SPMD 的,可以用 @spmd_safe 装饰器标出来。在 torch.compile 下,这会让 TorchTPU 不在集合通信周围插入 graph break,从而生成一个包含通信的大模块,让 XLA 自由移动集合通信、最大化重叠。这条路径在 SimpleFSDP 或手工放置集合通信的场景里收益明显;风险是 MPMD 代码不容易肉眼识别,标错了会变成脆弱配置。

更保守的路径是 Compilation Handshake(RFC):编译前在所有副本之间做一轮共识,确认 FX 图完全一致,再放开 graph break。由环境变量 TORCH_TPU_SPMD_HANDSHAKE_STAGE 控制:OFF(默认)、COMPILE_STAGE(开始 FX 图编译前握手)、DISPATCH_STAGE(开始执行编译后的 FX 图前握手,只在预期有 rank 特定重编译时使用)。发布时默认关闭。

拓扑感知 mesh 的用法

上一节的分层原则在代码里落成一个 API:torch.tpu.topology_aware_mesh 根据物理 ICI 拓扑计算最优的 rank 排布。它的用法是先声明逻辑 mesh 形状与维度名(按”通信强度从低到高”排列),再让 API 返回对齐物理 ICI 环路的 rank 张量:

from torch.distributed.device_mesh import DeviceMesh
# 单 Slice 上的 2D mesh:逻辑形状 (dp=4, tp=2),共 8 芯片
mesh_shape = (4, 2)
dim_names = ("dp", "tp")
optimal_rank_tensor = torch.tpu.topology_aware_mesh(
mesh_shape=mesh_shape,
dim_names=dim_names,
)
mesh_2d = DeviceMesh(
"tpu",
mesh=optimal_rank_tensor,
mesh_dim_names=dim_names,
preserve_rank_order=True,
)
dp_mesh = mesh_2d["dp"]
tp_mesh = mesh_2d["tp"]

preserve_rank_order=True 是关键:它保证 mesh 里的 rank 顺序就是物理设备顺序,否则后续的集合通信会把数据发到拓扑上错误的位置。这一步与 GPU 上手动排列 rank 等价,但 TPU 侧把它封装成了拓扑感知的自动布局,因为手工推导 Torus / Boardfly 上的最优顺序非常容易出错。

通信进图:从串行到重叠

TorchTPU 把 ProcessGroup 的集合通信降为 StableHLO 操作,让 XLA 同时安排计算与通信,争取覆盖通信等待。这个优化要落到”逻辑并行轴怎么映射到物理链路”上才有意义,而这一步的分层原则非常具体:

  • 频繁通信(TP 的 all-reduce / reduce-scatter,EP 的 all-to-all):先放到 D2D 或局部 ICI。
  • 跨 Slice:优先 DP,容量不足再考虑跨 Slice 的 FSDP;PP 也可以跨 Slice(但要注意每个 microbatch 都会放大重复收集)。
  • 绝不把 TP、EP 或 CP 放到 DCN 上——它们的通信太频繁,跨 Pod 的带宽差一个数量级,会直接把性能拖垮。

官方在单 slice 内的默认分片策略是:FSDP 跨 slice、EP 放在一条短的 Torus 轴上(X 轴),这样所有 all-to-all 的跳数最少,并且在回绕链路上是对称的。当每设备的 batch 太小、FSDP 的 all-gather 暴露出来时,可以验证 pod 内的 PP(只搬阶段激活、不搬权重),并通过 Roofline 加一个 20 到 30 步的短 profile 确认。

分布式初始化代码

TorchTPU 的分布式初始化遵循标准 PyTorch 语义,只是多出两个 TPU 特有的变量:TORCH_TPU_TOPOLOGY 给出 slice 的物理网格形状,TORCH_TPU_SLICEBUILDER_ADDRESSES 给出每台设备的地址。在 Google Cloud 环境里,也可以用 torch.tpu.distributed.set_tpu_launch_env() 一次性设置。一个最小示例:

import torch
import torch.distributed as dist
def worker_main():
# 1. 用 tpu_dist 后端初始化进程组
dist.init_process_group(backend="tpu_dist")
# 2. 查询 rank、world size,构造 TPU device
rank = dist.get_rank()
world_size = dist.get_world_size()
device = torch.device("tpu")
# 3. 在一次集合通信上验证连通性
x = torch.ones(4, 4, device=device) * (rank + 1)
dist.all_reduce(x, op=dist.ReduceOp.SUM)
print(f"[Rank {rank}] reduced sum: {x[0, 0].item()}")
dist.destroy_process_group()
if __name__ == "__main__":
worker_main()

启动方式是先让 Python 打印出需要设置的环境变量,再交给 torchrun:

Terminal window
# 单主机:8 芯片节点上每个芯片一个进程
eval $(python -m torch.tpu.distributed | sed 's/^/export /')
torchrun --nproc_per_node=8 train.py

注意最后一条:某节点的默认进程组就是该节点的 slice。这与 GPU 上”默认进程组覆盖整个作业”的直觉不同,跨节点的通信必须显式使用更大的组,或者通过 Virgo / DCN 对应的高级 API。对推理服务来说,这意味着多机部署时 TP 的切分范围要与 slice 的边界对齐,而不能假设一个默认进程组能横跨所有设备。

分布式 Pallas kernel:RDMA 进 kernel

TorchTPU 支持在 Pallas kernel 里直接用 pltpu.make_async_remote_copy 做芯片间 RDMA,不经过主机 CPU,可以写 Ring Attention、自定义 all-to-all、流水并行的阶段传递、halo exchange 这类点对点通信 kernel,并像普通 PyTorch 函数一样调用。写法上需要两步包装:先在 Pallas kernel 里用 pltpu.make_async_remote_copy 与 DMA semaphore 发起异步远端拷贝,再用 jax.shard_map 包装,最后用 torch.tpu.pallas.get_pallas_mesh 拿到 TorchTPU 侧的 mesh 并包装成可调用的 PyTorch 算子。

这里的 async_copy.start() 与 async_copy.wait() 是显式的:kernel 作者自己决定什么时候发起、什么时候等。这正是 TPU 编程模型的”可预测”特性带来的好处——调度在作者手里,而不是隐藏在某些运行时机制后面。

精选案例:数字背后发生了什么

8 倍规模保留约 94% 的每设备吞吐

Qwen3 235B 在 TPU v7 上的弱扩展(weak scaling)测试是一组很干净的测量。这组数据来自训练负载,但检验的是”分片与通信方案能否随规模保持效率”,而同一套 TP/EP 集合通信机制在推理侧同样存在;训练流程本身不是本文主题。测量条件是:每 TensorCore 的 batch 固定 16、序列长度 4096、BF16 加 FP32 混合精度归约,全局 batch 随设备数增长。结果如下:

TPU v7 chipsTPS / TensorCoreMFU
1,0242,23628.8%
2,0482,21428.5%
4,0962,09526.9%
8,1922,10427.1%

八个 slice、16,384 个 TensorCore 时,每 TensorCore 的吞吐只下降约 6%(2104/2236=94.1%2104 / 2236 = 94.1\%),总吞吐约为原来的 7.53 倍(8×2104/22368 \times 2104 / 2236)。这说明这套分片与通信方案没有随规模扩大而迅速退化。

Qwen3 235B 在 TPU v7 上的弱扩展:总吞吐随芯片数线性增长

上图是同一组测试的总吞吐曲线,来源是 PyTorch 官方 TorchTPU 博客的 Case Study 3,横轴是 TPU v7 芯片数。曲线几乎是一条直线,这就是”弱扩展”的定义:每个设备的输入量固定,总吞吐随设备数线性增长。

跨 Slice 通信如何不拖慢每一步

多 slice 的 HSDP 配置里,前向不跨 slice 通信,每个 slice 处理自己的那份 batch;反向时每个 slice 先算第 tt 层的梯度,再通过 DCN 做一次 all-reduce 汇总所有 slice 的梯度,然后继续算第 t−1t-1 层。关键优化是 XLA 让第 t+1t+1 层的 all-reduce 与第 tt 层的计算完全重叠。

XProf trace:第 t+1 层的梯度 all-reduce 与第 t 层的计算在时间轴上并行

上图是 PyTorch 官方 TorchTPU 博客 Case Study 3 给出的 XProf trace 截图。可以看到 grad all-reduce for layer t+1 的时间条与第 tt 层的计算时间条在时间轴上并行,而不是在计算全部结束后才串行出现。这是 TPU 侧的性能诊断方式的一个好例子:用暴露的等待判断瓶颈,而不是直接累加 AllReduce 总时长。AllReduce 的总时长可能很长,但只要它被计算覆盖,对关键路径就没有影响;真正要看的是 trace 上”暴露”的那一段。

MoE 应先优化暴露的数据搬运

MoE 层的优化是一个很好的教训。原实现在 DP8 + EP 配置下,prefill 为主、并发 256 时,ReduceScatter 每层 1,190 微秒,占全部设备时间的 22%,而且这段时间没有其他计算在跑。如果只加速专家 GEMM,这个 22% 的空白仍然存在。

优化后的路径是:每个 TensorCore 把自己的行量化成 FP8,在 SparseCore 上异步 all-gather;用 Pallas top-k 选出自己 token 的专家,用一个小型 all-gather 共享专家索引与行缩放因子;Pallas kernel 按索引取出路由到本地的行,跑每个本地专家的两次矩阵乘;结果按 FP8 加逐行 scale,用 remote DMA push 到拥有该 token 的 TensorCore;推送与后续专家的矩阵乘重叠。

结果由谁汇总这一点值得强调:专家输出按行 push 回 token 所属设备,由接收端按 router 权重累加。这改变了数据流的形状——原来是”算完再集中归约”,现在是”按行产出、按行远程推送”。一个设备托管多个专家时,发送 A 的结果时就可以继续算 B,于是回传与计算形成流水。对单个专家来说,则需要 token 分块与 kernel 支持,才可能有传输与计算重叠;整块算完再发送就没有这个窗口。结论是:MoE 的优化单位应该是”路由—计算—分发”整条数据流,不能只看 GEMM 耗时。

FLUX 的收益来自整条执行路径

FLUX 的累计优化是一个能说明”优化是分层的”的例子(同样是训练负载,但优化对象的层次与推理栈一致):从 eager baseline 的 11.49 秒每一步,经过 DeferAndFuse 降到 9.95 秒(1.15 倍),加分片到 6.52 秒(1.76 倍),加 Pallas SplashAttention kernel 到 5.55 秒(2.07 倍),开启完整的 torch.compile(backend="tpu") 到 3.02 秒(3.80 倍),最后加目标模型的 peephole 改写到 2.78 秒。收益来源分别是执行模式、分片、专用 kernel、整图编译和模型局部等价改写——每一层都解决不同的问题。

这个案例对推理的启发在于顺序:先让 eager 跑对、再让编译与 kernel 到位、最后才做模型局部改写。把顺序颠倒是常见的错误:在 eager 路径还没有被 DeferAndFuse 优化时就去写 Pallas kernel,常常会发现瓶颈其实在编译缓存或图边界上。

推理栈实战:megakernel、KV 布局与智能体缓存

前面的案例多来自训练侧,但第八代 TPU 的 8i 和 TorchTPU 的推理栈才是这次发布真正的落点。PyTorch 在 2026 年 11 月发布的 SGLang-TorchTPU 案例给出了一组非常具体的推理优化,可以把上文所有关于”搬运、延迟、KV 容量”的分析串起来。

被服务的模型与硬件形状

Muse Spark Open 是 Meta 的开放权重 MoE 模型,816B 总参数、约 42B 活跃参数,62 个解码层全部是 MoE,每层把每个 token 路由到 256 个专家中的 8 个。注意力是混合结构:46 层用 2048 token 的滑动窗口注意力,另外 16 层做全上下文注意力,最长 1M token;128 个 query head、16 个 KV head,每个 head 64 维。专家权重是 NVFP4:4 位,每 16 个值一个 scale 的微缩放格式。

硬件是一台 4 芯片的 TPU v7 主机。每颗芯片有两个 chiplet,各自带一个 TensorCore 和自己的 HBM,框架把每个 chiplet 暴露成一个 device,所以一台主机有 8 个 device,模型按 8 路张量并行切分,每个 device 一份。这个”一颗芯片两个 device”的模型与 8i 一致,对推理服务有一个直接后果:每 device 只有一半的 HBM 与一半的 VMEM 可用,KV 容量与权重容量都要按 device 而不是按芯片来算。

每个 device 是单线程处理器,一个程序同一时刻只有一个在跑,所以速度来自”把矩阵单元喂饱”和”在同一个程序里把访存与计算重叠”。这与上文 TorchTPU 编程模型的分析完全一致。

megakernel:把 62 层变成一个程序

小 batch 下,生成一个 token 所做的数学运算相对于权重字节数很少,所以一步的速度上限就是 HBM 能把权重多快地流进 MXU——只要这条流不被打断。但原来的路径(下称 native)把每一层拆成多个 kernel 加集合通信,每个 kernel 边界都会打断这条流。TorchTPU 的做法是把一个 decode 或 verify step 的 62 层写成一个 Pallas program,每个 device 一个 pallas_call,让下一层的权重始终在途。

megakernel 中一层的流水示意:权重、KV 与跨设备部分和的 DMA 流各自提前于使用它们的计算

上图是 megakernel 中一层的流水示意,来源是 PyTorch 官方的 SGLang-TorchTPU 博客。白色框是每一层都要走的计算流程,阴影框是 kernel 自己发起的数据搬运。可以看到三条流:权重沿一个 tile 环提前预取、跨设备的 partial sum 用 remote DMA 直写、KV 的读写各自成流。三条流都在对应计算之前或旁边运行,而不是串行等待。

效果是:单请求每输出 token 从 3.78 毫秒降到 1.95 毫秒(1.94 倍),两个并发请求时 1.85 倍。native 路径的 verify step 本来就要花掉”流完权重所需时间”的 2.9 倍;profile 显示 batch 1 时矩阵乘与注意力几乎不花时间,而集合通信每层约 45 微秒——瓶颈是程序边界上的开销,不是带宽。这印证了上文”通信暴露在关键路径”的诊断方法:要看暴露的等待,而不是看通信总量。

三个关键流水手段值得记住:

  • 权重环:注意力、o-proj、router 的权重通过一个跨层预取的 tile 环流动,约 10 个 tile 在途可以维持每 device 3.34 TB/s,而单条 DMA 流只能到 1.13 TB/s。这说明带宽不是靠一条更快的流,而是靠多条流同时在途。
  • 专家权重按路由结果即时请求:router 的选择在层中间才知道,所以路由一结束就请求被选中专家的权重,三个专家同时在途。
  • 集合通信折叠(collective folding):不是每个矩阵乘后做一次独立集合通信,而是把 partial 结果用 remote DMA 直接写进所属 device 的内存,小规模一轮约 3 微秒;o-proj 的每个输出 tile 一算完就发走,下一个 tile 还在乘。

还有一个与上文”合并 all-gather 与 matmul”呼应的技巧:Muse Spark 在两层之间做 RMS norm,norm 的两个因子(每行一个标量)与矩阵乘可交换,所以可以把”已到达的 slice”立刻乘进结果,而不是等整个 all-gather 完成再乘。一层能这样折叠两次 all-gather(MoE 输出进下一层 qkv、注意力输出进 pooler 与 router)。代价是矩阵乘输入的 bf16 舍入点变了,结果不再 bit-identical,需要精度检查覆盖。

注意力:去掉 running max,让 chunk 独立流水

长上下文下注意力是一步中最大的部分。标准 online softmax 维护”到目前为止的最大值”,每个 chunk 的指数都要等前一个 chunk 的最大值确定,于是 chunk 之间形成一条串行链;微基准里这条链每 chunk 约 0.17 微秒(fp8 与 bf16 都一样)。

Muse Spark 的 QK-norm 没有学习权重,q 还有一个固定 gain,因此任何注意力 score 的绝对值都不超过 43.8,离 f32 的 exp 溢出点很远。running max 的唯一作用就是防溢出,所以 kernel 直接去掉它和重缩放,并在构建时从模型常量检查这个上界。没有 max 之后,各 chunk 相互独立:kernel 在每次循环开头就发起所有 DMA 等待,把 chunk 分到多条独立的 softmax 流上,最后合并,并对循环做软件流水——在把上一批 chunk 的概率乘 V 时,已经在给下一批 chunk 打分。

微基准里,更长的 chunk 加独立流把注意力时间降到 2.4 分之一,去掉 running max 后到 3.9 分之一;在服务里,两个请求、500K 上下文时每请求 decode 速度提升 18%。这个案例说明:模型结构上的一个可证明的数值上界,可以换来 kernel 层面一整条串行依赖的消失。它不是”近似”或”跳过”,而是把不需要的保护去掉了。

上图是 DFlash2 的一次投机步示意,来源是 PyTorch 官方的 SGLang-TorchTPU 博客。草稿模型读取从完整模型捕获的隐藏状态,块内双向注意力,一次前向提出整块 token;完整模型用一次 megakernel step 检查整块,保留与自身选择一致的最长前缀再加一个 token。理解这张图的关键是”verify 是一步、而不是逐 token”:正因为 verify 是单次前向,块中所有行才共享同一次权重读取。

KV 布局:sequence-on-lane 为什么能省一半

8 路张量并行下每 device 只持有 16 个 KV head 中的 2 个,每个 64 维——正好是向量寄存器 128 条 lane 的一半。token-major 布局把一个 head 的 K 与 V 并排填满 lane,这在 bf16 下可行;但 FP8 每个 32 位字塞 4 个值、沿 sublane 排,K 与 V 的一对就被 padding 到四个槽位,只切 FP8 并不能省内存。

sequence-on-lane 把一页的 token 排在 128 条 lane 上、head 维度放在 sublane 上,于是一个字里是同一个 token 的四个 FP8 值,没有浪费。KV 每 token 每层每 device 从 512 字节降到 256 字节,内存与每步读取的 KV 字节都减半。这和站内已分析过的 vLLM-TorchTPU 优化是同一类思路:布局必须服从硬件的字宽与 lane 结构;可参考 Google TPU 世代技术全景 里对 sequence-on-lane 的说明。

会话感知驱逐示意:主智能体空闲期间,朴素 LRU 会先驱逐它的 KV,会话感知策略则保留到其他数据都驱逐完

上图是会话感知驱逐的示意,来源是 PyTorch 官方的 SGLang-TorchTPU 博客。一个 agent 会话是一棵对话树:主智能体可能空闲十几分钟等子智能体跑完,再带着完整上下文回来。对朴素 LRU 驱逐来说,这段空闲的会话看起来是缓存里最冷的数据,于是最先被驱逐,下一轮就得重新 prefill 一段长前缀。会话感知驱逐让同一会话的 KV 在其他数据都驱逐完之后才淘汰,并且只在主机内存里做这种保护——HBM 对正在运行的请求仍保持朴素 LRU。混合注意力模型让这个损失更严重:复用前缀需要同时持有全注意力 KV 与最后 2048 token 的滑动窗口 KV,丢掉小的窗口就会让大的全注意力 KV 变得无用。

更关键的是对”KV 容量即吞吐”的量化:在 agent 流量下,每个从前缀缓存里掉出去的 prefix 都要以一次 10 万 token 的重新 prefill 回来。权重之外每 device 只剩约 20 GiB 给 KV,还要在全注意力池(16 层)与滑动窗口池(46 层)之间分。把 draft model 的 KV 从”按全上下文分配”改成放进滑动窗口池,同样的 HBM 能多装 38% 的 token;开启主机 DRAM 作为 L2 的 HiCache 后,工具暂停期间被 HBM 换出的前缀留在主机内存里,下一轮直接拷回,agent 流量下吞吐最高提升 77%。再加上 session-aware 驱逐(同一会话的 KV 在其他数据都驱逐完之后才走),prefill 计算的 token 数从”最优缓存的约 1.2 倍”降到”1.05 倍以内”。

这三件事对 8i 的意义很直接:8i 的 288 GB HBM 与 384 MB VMEM 是同一套分层缓存的底层;CAE 降低的集合通信延迟与 Boardfly 降低的网络直径,决定了 TP/EP 的每一步同步有多贵。硬件给的是容量与延迟,软件要做的仍然是把”哪些数据留在片上、哪些留在 HBM、哪些放到主机”这个问题答对。

投机解码与 prefill

DFlash2 一次投机步:草稿模型读取目标模型的隐藏状态,一次前向提出整块 token,目标模型一次 verify 全部检查

DFlash2 的草稿模型一次前向提出一整块 token,目标模型一次 verify 全部检查并保留最长匹配前缀。TPU 上这件事特别划算:MXU 的时间随行 tile 与输出 tile 的数量增长,而不随乘加次数增长,一块草稿的少数几行和单个 token 落在同一个行 tile 里,所以验证一块草稿的成本只比验证一个 token 略高。实测单请求每输出 token 从 3.93 毫秒降到 1.95 毫秒,2.0 倍。

prefill 侧的优化则是另一条线:一个 chunk 有足够多的行把 MXU 喂饱,时间花在计算与跨设备搬结果上。MoE 层里每个 device 对每个 (token, expert) 对算一个 partial,一个 token 的 owner 要加总 8 个 partial;把小写入一个个搬过去比矩阵数学还贵。融合的 MoE kernel 一边流一个专家的权重、一边预取下一个,跑 gate/up、SwiGLU、down,每算完一行就直接写进 owner 的 HBM,并与后续 tile 重叠。这再次说明:prefill 的瓶颈常常不是 FLOPs,而是 partial 结果的搬运。

把这一节与 8i 的硬件对照,可以得到一个清晰的结论:8i 的 Boardfly、CAE、384 MB VMEM 与 288 GB HBM,恰好对应推理栈最贵的四件事——跨设备同步、KV 容量、片上驻留与权重读取。硬件把这些成本压低之后,剩下的差距就由 kernel 的数据流设计决定,而 megakernel 正是把”一层一个边界”改成”一步一个程序”的极端做法。

模型-硬件协同设计:13 条建议的定量依据

Google 在 2026 年发布的模型-硬件协同设计指南是一份很罕见的材料:它把”模型结构怎么设计才能榨出硬件”写成了具体建议,并且给出了实测数据。下面按”形状与模型结构”和”执行与系统设计”两组逐条拆解最关键的几条。

建议 1:输出维度按每设备 256 对齐

第一条是”对齐分片后的归约输出维度”:head dim、FFN、latent 等都按每设备 256 对齐。注意是”每设备”,不是”全局”。因为张量并行切分之后,每个设备看到的归约轴宽度才是真正决定 MXU 利用率的量。这条建议在上一节”head_dim 与 MXU tile 的对齐”里已经给出了实测依据:32×128 与 16×256 参数与 FLOPs 相同,但 32K 上下文时 MFU 从 23.7% 升到 34.7%。

要注意的是,对齐约束要检查的是分片后的每设备形状;token 轴、head 数本身不要求是 256 的倍数,这一点在实现时经常被误解成”所有维度都要对齐”。

建议 2:先规划所有目标规模的并行

并行配置应该在模型定型前确定:从 4 芯片调试、单 slice 部署,到跨 pod 扩展,维度和 batch 都要能整除。做法是先列出部署 Mesh(推理侧通常是 DP × TP × EP,训练侧再加上 FSDP × PP),再检查分片后的 FFN / Head 宽度与每设备 token 数;高频的 TP/EP 留在 slice 内;跨 pod 优先放同步频率最低的维度。

对推理来说,这条建议的直接含义是:TP 与 EP 必须能在 slice 内整除地放下,否则只能退到跨 pod 的 DCN,而 DCN 的带宽差一个数量级。对训练侧,官方给出的对照是:梯度累积 mm 次时 DP 每个 step 只同步一次梯度,FSDP 每个 microbatch 都要收集参数,PP 又产生多个 microbatch,所以跨 pod 优先 DP;实测双 slice、跨 pod 使用普通 DP 时每芯片吞吐损失约 1%。两者背后的原则是同一个——把同步频率最高的维度放在最快的链路上。

建议 3:固定形状,动态描述有效数据

这一条在 bounded dynamism 那一节已经讲过机制,这里补上它的必要性论证:变长请求和 MoE 路由如果用”每个形状一种编译”,会在服务中频繁触发重编译;如果”每组 padding 到最大”,MXU 就去乘零。静态形状 + 动态 extent 的做法两边都避开了:形状编译一次,整数每一步都变,kernel 按未 padding 的 FLOP 数运行。检查结果要看 padding 浪费的 FLOPs 与尾部 tile 浪费;Dropless 路由同时要检查零丢弃下的训练质量。

建议 4:LatentMoE 压缩路由通信

MoE 的 all-to-all 搬运量是 token 数×d×字节数\text{token 数} \times d \times \text{字节数}。如果在 dispatch 之前把 token 先降到较窄的 latent 空间(宽度 ℓ\ell),搬运量就变成 token 数×ℓ\text{token 数} \times \ell,压缩比是 d/ℓd/\ell。代价是新增一次 down 投影(d→ℓd \to \ell)和一次 up 投影(ℓ→d\ell \to d)。

官方在 30B MoE 上的结果需要仔细读:路由 token 宽度压缩约 2.67 倍(d/ℓd/\ell,30B / 128 experts,ℓ=768\ell = 768),片上 token permute 阶段改善约 2.8 倍,端到端训练吞吐只提升 14%(tokens/s),有效计算吞吐从 270 升到 322 TFLOP/s/chip(约 19%),每 token FLOPs 约增加 5%,激活 HBM 节约约 25 GB/device(把 remat checkpoint 放在压缩 latent 上)。

这里最重要的数字对比是:字节压缩 2.67 倍,端到端收益只有 14%。原因在官方的解释里:attention、非路由计算和其他等待仍然存在,还新增了投影计算。所以对比应同时报告 tokens/s 与 FLOP/s——只看字节缩减会高估收益。

建议 5:Expert 粒度与 Shared Expert

这一条是把”更多、更窄的 Expert”换成”更少、更宽的 Expert”。一个例子:把 routed experts NN 从 512 减到 256、Top-K 从 16 减到 8、Expert FFN 宽度从 1792 加到 3584、Shared Expert 从 1 倍加到 2 倍。K/NK/N 保持 1/32 不变,均匀路由下每 Expert 平均 token 数(TK/NTK/N)不变。收益来自更宽的 GEMM、减半的 KK 比例 dispatch、以及更多规则的 Shared Expert 计算。

测得的数字:63B LatentMoE(ℓ=768\ell = 768、K/N=1/32K/N = 1/32、8K 上下文)在 512 颗 v7x 芯片上(EP = 128),从 9.6K 升到 15.1K tokens/s/chip,约 1.57 倍,且在 120.8B tokens 的训练里 loss 保持更低(-0.007 nats)。一个关键解释:2 倍宽 Shared Expert 每 token 增加约 7% 的活跃 FLOPs(3.7B vs 3.5B active),却把 step time 降低 36%,因为它把工作转移到了稠密的 MXU GEMM 上。单独把 d_ff 加宽 2 倍(1 倍 shared,匹配 3.5B FLOPs,在 1,024 颗 TPU v4 上跑 50B tokens)也能提速 28%、loss 下降 0.013。

这条建议的道理其实很朴素:MoE 的稀疏性带来的是”路由与搬运”的代价,而 Expert 越宽,单位搬运换来的 MXU 利用率越高。但要注意不是专家越宽越好,K/NK/N 的比例被保持住了,活跃参数只涨了 7%,所以这是一个”在不增加激活计算量的前提下提高计算强度”的操作。

建议 6 与 9:混合精度设计与 FP8 Block Scaling 的向量开销

混合精度设计需要同时控制数值范围、选择敏感路径精度、并考虑 scaling 的执行开销。具体做法:大 GEMM 走 FP8 等低精度路径;Softmax 输入、Router、Norm 等保留 BF16/FP32;用 QK-Norm / QK-Clip 限制注意力异常值;用 Z-Loss 约束输出 logits。为什么只降 GEMM 精度不够?因为更细的 Block Scaling 虽改善数值表示,也会增加 VPU 的重缩放工作。

这里有一个可以复算的定量分析。把归约轴 KK 切成大小为 BB 的 block,每块输出一个 partial product,再施加 scale 并累加。每个输出元素上:MXU 约 2K2K 次浮点运算(KK 次乘、KK 次加),VPU 做 3⌈K/B⌉3\lceil K/B \rceil 次操作(scale、加、或许还有别的重缩放)。隐藏条件是 VPU 的这笔开销不超过 MXU 的时间窗:

3⌈KB⌉<PmxuPvpu=1283 \left\lceil \frac{K}{B} \right\rceil < \frac{P_{\text{mxu}}}{P_{\text{vpu}}} = 128

忽略取整,把 ⌈K/B⌉\lceil K/B \rceil 近似为 K/BK/B,上式化为 3K/B<1283K/B < 128,即

B>3K128=1.5×PmxuPvpu⋅K128B > \frac{3K}{128} = 1.5 \times \frac{P_{\text{mxu}}}{P_{\text{vpu}}} \cdot \frac{K}{128}

按 128:1 的峰值比代入 K=7168K = 7168,得到 3K/128=1683K/128 = 168。Google 模拟给出的是 341,按”给定峰值复算”约 360——两者都明显高于 168,说明实际 kernel 的 MXU 有效效率低于峰值(或所用的峰值比更保守),隐藏条件比理想模型更苛刻。这个差异本身就是提醒:推导出的阈值只能定方向,block 大小必须结合目标 GEMM 实测选择。Google 的模拟里给出的具体数字:B=512B = 512 时 VPU 约 77 微秒、完全被 MXU 约 130 微秒的窗口隐藏;B=256B = 256 时 VPU 约 155 微秒,暴露 25 微秒,step 慢 1.19 倍;B=128B = 128 时 VPU 约 309 微秒,step 慢 2.37 倍。注意这个模拟的 block 越大越好、但 block 太大数值精度会变差,所以有一个”够大且数值可接受”的区间。

这里还隐含了一个硬件代际的差异:v7x(Ironwood)的 block scaling 由 VPU 执行;8t 加入了 MXFP4/MXFP8 的 scaling 专用支持,会改变这一平衡。所以在 8t 上,block 的选择需要重新调优,不能直接沿用 v7x 的经验值。

建议 7:用混合 Attention 控制长上下文成本

先决定哪些层需要全局交互,再选择有成熟 kernel 的 local、linear 或压缩 KV 层,同时预算质量与缓存。三种可选结构:

  • Local / Global:多数层只看窗口 WW,少量层保留全局。全局 KV 是 O(L)O(L) 每层,local KV 是 O(W)O(W) 每层。
  • Linear / Recurrent:固定大小的 state 替代随长度增长的 KV。
  • 压缩 KV / 稀疏:缩小每 token 的条目或实际读取范围。

一个容量估算:5 个 local 层加 1 个 global 层,L=32KL = 32K、W=1KW = 1K,等宽时 KV 为全局方案的 (5×1K+32K)/(6×32K)≈19.3%(5 \times 1K + 32K) / (6 \times 32K) \approx 19.3\%。也就是说,同一套 6 层结构里只用 1 层做全局注意力,KV 容量就能压到不到五分之一。这个数字解释了为什么推理侧的长上下文模型越来越多采用混合注意力——它不是”少算一点”,而是 KV 容量直接决定能服务多少并发请求。

选型标准是:在目标窗口 / 长度下的实际 kernel 时间 + KV/State 字节 + 长程任务质量。少 FLOPs 不保证更快,如果数据搬运占比变大,需要重新看 HBM/VPU 瓶颈。这条与前文 VMEM 的分析呼应:KV 读取的字节数是 decode 的关键路径,压缩 KV 的价值不在于减少矩阵乘,而在于减少每步从 HBM 读的字节。

建议 8:把一次权重读取用于更多 Token

低并发 decode 常受权重读取限制。有两条路:

  • 路径 A:更多 chip 分摊读取。理想权重下限是 tweight≳W/(Bw)t_{\text{weight}} \gtrsim W / (B_w),TP/EP 聚合 HBM 带宽,但 collective 延迟和最少 rank 会抵消收益。官方给的量级示例:397B MoE、FP8、4 颗 Ironwood、batch 触及全部 Expert 时约 100 GB/chip,权重读取下限约 13.5 毫秒,尚未计 KV。这正是低直径 Boardfly 对 decode 的意义——更多芯片分摊读取的前提是芯片间通信足够快。
  • 路径 B:Draft → Verify → Commit。MTP heads 或小 drafter 先预测多个 token,目标模型并行验证;接受率高,还要确认完整周期确实更快。

建议 10:训练与 Decode 的 TP 选择

同一条模型在训练与推理两个阶段可以选择不同的 TP。训练侧的选择只需记住一句话:要隐藏每层高频 collective;本文关注的是 decode 侧——低并发 decode 更关心权重读取带宽。

在 Ironwood 的单芯片封装里,两个 chiplet 之间的 D2D 链路约为 ICI 的 6 倍,所以训练时 TP = 2 放在同一个 chip 内(跨 D2D),把 ICI 留给 FSDP/EP;而 decode 时 TP 要跨 ICI 来分摊 HBM 权重读取,比如 Qwen3-Coder-480B-A35B 用 TP8 + EP,把活跃权重字节按 8 路跨 chiplet 切开,让 HBM 带宽线性放大。为什么不 TP = 4 放在一个 chip 内?因为跨 1D ICI 后每层 all-reduce 需要更大的 MLP batch(约 46K)才能隐藏——这就是”扩展节省的读取/计算 vs 新增通信”的量化权衡。

还有一个细节:TP = 2 可以映射到双 chiplet,但 TP = 4 就跨了 ICI;判断依据不是”越少越好”,而是”每层高频 collective 能否隐藏”。

建议 10 之二:SparseCore 异步卸载

无卸载时,TensorCore 串行执行:MXU 算子 1 → 通信与稀疏 gather(暴露)→ MXU 算子 2。SparseCore 异步卸载后:SparseCore 在 MXU 算子 1 执行期间完成异步通信与稀疏 gather,赶在 MXU 算子 2 使用数据前完成。官方在 tpu-recipes / Ironwood 上实测,step time 降低约 15–22%,而且只是 XLA flags(零模型改动,recsys 嵌入用原生引擎)。

这个收益的量级与它的条件必须一起看:收益取决于通信能被计算覆盖的时间窗口。通信比计算慢时,SparseCore 也无法凭空变快——它只是让原本暴露的等待不再落在关键路径上。

建议 11:让搬运与计算形成流水

在 VMEM 容量内选择合适的 tile,通过 DMA 预取与双缓冲,把下一块数据的搬运藏在当前块计算之后。串行时每 tile 时间是 tload+tcomputet_{\text{load}} + t_{\text{compute}};双缓冲时稳态每 tile 时间是

max⁡(tload,tcompute)\max(t_{\text{load}}, t_{\text{compute}})

双 buffer、输出、临时量都占 VMEM。v7x 每 TensorCore 64 MiB VMEM,scratch 调大也会挤占权重预取空间。每次改变维度或序列长度,都应重新搜索 block,必要时选选择性 remat。官方配置例:DeepSeek-V3 的 Ironwood recipe 使用 65,536 KiB scoped VMEM、2,048 的 Splash block,配合自定义 remat。调整后要检查 HBM stall、VMEM 峰值和额外重算的总时间——三个指标一起看,因为 remat 多了会抵消流水的收益。

建议 12:为 Prefill / Decode 分离设计 Serving

两阶段的目标不同:prefill 关注 TTFT 和计算吞吐,低并发 decode 关注 TPOT 和 HBM 带宽,可以分池并采用不同配置。做法:prefill 池用较大的 token batch,优先高效 GEMM / attention,把生成的 KV 传给 decode 池;decode 池按权重 / KV 容量选 TP、EP 和并发,控制单 token 延迟。

分池也引入新成本:KV 交接量是 2LHkvdhb2LH_{kv}d_hb 每 token(每个 token 都要把全部层的 KV 搬一遍并乘上精度字节数),TTFT 需要计入排队、prefill、KV 传输以及 decode 启动。指南给出的 vLLM / Ironwood 起点是 FP8 KV、256 token page block;小模型用 D2D TP = 2,大型 MoE 用 TP = 8 + EP。最终要以端到端 TTFT / TPOT / 吞吐验收。

建议 13 与”先调好系统基线”

建议 13 是”先判断多遍计算是否值得”。对精度敏感的 matmul,指南提出用多遍低精度路径逼近 BF16,但成立的前提是低精度吞吐优势大于遍数及附加开销。设 r=Plow/Pbf16r = P_{\text{low}} / P_{\text{bf16}} 是低精度与 BF16 的峰值算力之比,需要 nn 遍低精度 matmul:只算矩阵工作,相对耗时至少为 n/rn / r(再加拆分、缩放与累加)。如果要 n>rn > r,则 n/r>1n/r > 1,仅矩阵计算就已经不如原生 BF16。v7x 的 FP8/BF16 峰值比 r=2r = 2,所以若需要超过 2 遍,v7x 上应优先使用原生 BF16。这是一个不需要任何实测就能做出的判断,先算这个必要条件,再谈数值精度。

最后一条不是建议编号,但同等重要:先调好系统基线。Google 的 30B MoE 仅通过系统调优(Offload + Tile + Remat 等),MFU 就从 12% 提升到 23%,没有先改模型。四个诊断维度:MXU(大 GEMM 是否接近形状对应的 Roofline)、通信(有多少真正暴露在关键路径)、VPU(非 matmul / scaling 占多少时间)、端到端(step time、tokens/s 与质量是否一起改善)。结构评估应在调好的基线上做控制变量对照。

这一条其实是对整篇文章的一个收束:没有调好的基线,任何结构变化的比较都不可信。这也是为什么”形状与精度决定有效计算,存储与数据流决定搬运代价,拓扑与调度决定等待”这三句话必须一起看——单独优化任何一句,都会被另外两句的低效抵消。

这套架构的边界

把第八代 TPU 与 TorchTPU 放在一起看,边界同样清楚,而且有些边界是硬件本身决定的,短期内不会被软件绕开。

静态形状的遗产还在。bounded dynamism 解决了大部分变长问题,但它需要用户显式给上界;torch.compile 目前还默认 dynamic=False;超出上界的形状仍会重编译。对推理服务来说,这意味着要么把序列长度分桶,要么接受一定比例的重编译。

一颗芯片只能被一个用户态进程访问。这是 TPU 的硬件约束,TorchTPU 因此采用 one-process-per-device。对推理服务来说,这意味着每个推理进程绑定一个设备,“多个小模型共享一卡”之类的部署需要自己规划设备切分,或者依赖推理框架在进程内把多个模型放在同一个程序里编排。

MPMD 代码是脆弱的。Skinny Collectives 能保证正确性但损失 30% 到 40% 性能;@spmd_safe 能恢复性能,但要求用户真的确认代码是 SPMD 的,标错了会出难查的死锁;编译握手是更安全的路径,但仍在 RFC 阶段。

算子覆盖与 kernel 生态仍在补齐。TorchTPU 支持约 450 个 Aten 算子,覆盖主流架构,但 FlexAttention 还不支持,TorchTitan 的案例里需要把它换成普通的 F.scaled_dot_product_attention。新模型结构出现时,TPU 侧的 kernel 支持通常晚于 GPU,Tokamax 的算子组合虽然在扩展(并在 8i 上做 day-one 支持),但仍是一个持续维护的清单。

专用引擎的价值依赖负载匹配。SparseCore、CAE 的收益都建立在”这类工作确实存在且能被卸载”的前提上。如果模型里没有稀疏操作或集合通信不频繁,这些引擎就无法发挥作用——8i 的 CAE 收益是”片上集合通信延迟降五倍”,但它不能把一个几乎不做集合通信的模型变快。

性能上限依赖手写 kernel。纯 PyTorch 代码在 TPU 上能跑,也能拿到不错的 MFU(官方给出的例子是 Muse Glimmer 30B 纯 PyTorch 实现、只用标准模块,在单颗 v7 上 prefill 约 25.7K TPS、59% MFU),但要接近峰值,还是得用 Pallas 或 Tokamax 的专用 kernel。官方的态度很明确:开箱即用是及格线,峰值性能要靠设备特定的优化。

这些边界并不否定 TPU 的价值,它们只是说明 TPU 仍然是一台需要专门优化的机器。它的优势在于:当负载匹配它的执行模型时,同样的功耗和成本能给出更高的吞吐与更低的尾延迟;当负载不匹配时,迁移的代价会体现得非常明显。

小结

第八代 TPU 与 TorchTPU 的关系可以概括成三句话,每一句对应一篇文章主线:

  • 芯片层面,资源配比就是性能上限。8i 的 288 GB HBM、384 MB VMEM、19.2 Tb/s ICI 与 CAE,是冲着推理的”内存墙”与”集合通信延迟”设计的;MXU 与 VPU 约 128:1 的配比决定了长上下文注意力在 softmax 上的理论上限,head_dim 与 MXU tile 对齐则是唯一不需要写新 kernel 就能拿到的收益。
  • 系统层面,拓扑与调度决定等待。Torus 到 Boardfly 把 1024 颗芯片的网络直径从 16 跳压到 7 跳;Virgo 把跨 Pod 的扩展交给独立 Fabric;TP 放在 D2D 或局部 ICI、DP 才放到跨 Pod——每一步都是在”高频通信贴近最快的链路”这个原则下做的取舍。
  • 软件层面,编译器与 kernel 决定数据流。DeferAndFuse 把逐算子执行汇成可以融合的计算片段;bounded dynamism 把形状变化从”重编译”变成”运行期整数”;通信进图让 XLA 把 all-reduce 挪到能重叠的位置;协同设计指南的 13 条建议则是把这些机制落到模型结构上的具体参数选择。

把这三层串起来,就是 Google 反复强调的”协同设计”:不是先造芯片再适配软件,也不是先写编译器再补硬件,而是让模型的形状、精度的选择、并行的映射、kernel 的数据流共同决定每一颗芯片的利用率。理解这条链条之后,再看到任何一组 TPU 性能数字,都可以先问三个问题:形状对齐了吗、搬运暴露了吗、通信被隐藏了吗——答案通常就藏在数字的差异里。

参考资料

  1. Google Cloud Blog:Our eighth generation TPUs: two chips for the agentic era
  2. PyTorch Blog:Introducing TorchTPU
  3. PyTorch Blog:Optimizing Muse Spark Open on TPU v7 with SGLang-TorchTPU
  4. Google Blog:TPU 8t and TPU 8i at Cloud Next(第八代 TPU 的规格与发布信息)
  5. Jouppi et al.:TPU v4: An Optically Reconfigurable Supercomputer for Machine Learning with Hardware Support for Embeddings(ISCA 2023)
  6. JAX:Writing TPU kernels with Pallas(Pallas 编程指南)
  7. FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision(arXiv 2024)
  8. TorchTPU GitHub 仓库(google-pytorch/torch_tpu)
  9. OpenXLA 编译器仓库
  10. TorchTitan:PyTorch 的大规模训练参考实现(含 TPU 分支)

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

第八代 TPU 与 TorchTPU 全链路拆解:两颗芯片、Boardfly 拓扑与 PyTorch 原生后端
https://pinghaoyang.com.cn/articles/insights/posts/tpu8-boardfly-torchtpu/
作者
平昊阳
发布于
2026-11-22
许可协议
CC BY-NC-SA 4.0

评论区

访客信息
--°天气加载中

正在获取所在地区…

💨 风力--
💧 湿度--

正在读取天气

Profile Image of the Author
平昊阳
乘长风,破巨浪, 展鸿图于未央!
公告
欢迎来到我的个人博客!欢迎关注交流吖!
更多相关公告,见
「社交-留言」。
音乐
封面

音乐

暂未播放

0:000:00
暂无歌词
站点统计
文章
572
分类
29
标签
659
总字数
8,320,312
运行时长
0 天
最后活动
0 天前

文章目录