AI 芯片架构全景

从 NVIDIA、Google TPU、AMD 到 Cerebras、AWS Trainium 与 Groq LPU——六种主流 AI 芯片架构的哲学、微架构、扩展方式与软件栈全景拆解。

在 2018 年的国际计算机体系结构研讨会（ISCA）上，John Hennessy 和 David Patterson 发表了他们的图灵奖演讲：「计算机体系结构的新黄金时代」（A New Golden Age for Computer Architecture）。

1980 年代，Hennessy 和 Patterson 做那项斩获图灵奖的研究时，单线程 CPU 性能每年增长 52%。到 2018 年，随着摩尔定律和登纳德缩放（Dennard Scaling）走到尽头，这个数字只剩 3%。

于是，领域专用架构（DSA）成了必然。他们演讲里的范例是已经在生产环境中运行的 Google TPU v1：在神经网络推理上，它的吞吐量是 CPU 的 29 倍，能效高出 80 倍。演讲的结语是那句预言：「未来十年将迎来计算机体系结构的新一轮寒武纪大爆发。」

这个预言成真了。今天，认真在推进的架构已经有几十种：GPU、TPU、LPU、NPU、DPU、ASIC、晶圆级引擎、可重构数据流、神经形态、光子、模拟……其中绝大多数都聚焦于 AI 计算。

真正拿到大规模部署的架构是这些：GPU（NVIDIA、AMD）、脉动阵列加速器（TPU、Trainium）、Cerebras 晶圆级引擎（Wafer-Scale Engine），以及 Groq LPU。

NVIDIA 是毫无争议的领跑者；AMD 紧随其后，OpenAI 和 Meta 各给了它 6 GW 的订单。TPU 在训练 Gemini，并将为 Anthropic 提供最多一百万颗芯片；Anthropic 同时也在超过一百万颗 Trainium 芯片上运行 Claude。Cerebras 现在为 OpenAI 提供推理服务；Groq 的 LPU 则以一笔 200 亿美元的 acquihire 并入 NVIDIA。

这篇文章想做的，是对这些不同路线做一次全景扫描——它们的哲学、架构、扩展方式（scale-up 与 scale-out），以及软件栈（你怎么给这块芯片编程）。

问题

AI 计算的主宰是矩阵乘法。一个 transformer 就是一串 matmul：Q/K/V 投影、注意力、输出投影、FFN——中间穿插着逐元素运算：归一化、激活、残差相加。训练一个前沿模型要执行 10²⁵ 次乘加运算（matmul 就是一连串乘加）。

这些 matmul 的形状取决于工作负载。训练把一批序列逐层前推、反向传播损失、更新权重，同一时刻有成千上万个 token 流过同一份权重矩阵。Prefill 是推理中处理提示词的阶段：在产生第一个输出 token 之前，把完整输入序列一次性投影穿过整个模型。训练和 prefill 都是把大量 token 堆在同一份权重矩阵上，因此每一层的数学都是大型矩阵乘矩阵（GEMM），算术强度高（计算密集）。Decode 是自回归的：模型一次只吐出一个 token，每个 token 都依赖于它前面的所有 token，第 N+1 个 token 必须等第 N 个产出之后才能开始。每一步只投影一个 token，所以每个 matmul 都退化成矩阵乘向量（GEMV）。产出一个 token 需要完整扫过模型里的每一份权重，还要完整读一遍 KV Cache 做注意力。算术强度比 prefill 掉了好几个数量级。

推理系统靠批量（batching）找回一部分算术强度，把 GEMV 重新抬回 GEMM：连续批处理（continuous batching）把许多用户的 decode 步骤叠在一起，投机解码（speculative decoding）为每个请求多生成 K 个草稿 token 然后一次验证，多 token 预测则把同样的把戏塞进模型内部。这能提高 matmul 单元的利用率，把 Ops/B 推上去。但连续批处理下，每个用户的请求仍然要读自己的 KV Cache，所以长上下文 decode 会从权重带宽受限转向 KV 带宽受限。

这里真正的架构难题是：把数字以足够快的速度搬到 matmul 发生的地方。这就是所谓的内存墙（memory wall）：算力在指数增长，内存带宽没有。

每种架构都在数据搬运这场游戏里提出了不同的策略。理解一块芯片，可以归结为四个问题：数据住在哪里、它怎么移动到计算单元、计算单元长什么样、以及芯片之间在大规模下怎么互联。

NVIDIA GPU

NVIDIA GPU 是一台大规模并行处理器。它的哲学是：一块可编程的芯片，承载成千上万个线程，由宿主机 CPU 编排、通过 CUDA 暴露出来——这就是运行可并行工作负载的正确机器。每一代都在可编程的流式多处理器（SM）上叠加新的加速原语，而不改变编程模型。同一块芯片既能训练 transformer，又能跑推理，还能渲染图形、做科学模拟（加速计算）。

谱系

2006 — Tesla（G80）：第一块支持 CUDA 的 GPU；统一着色器（unified shaders）和 SIMT 执行模型。 2010 — Fermi（GF100）：第一代真正的计算架构：统一 L1/L2 缓存、双 warp 调度器、IEEE-754 FP64。 2012 — Kepler（K20、K40）：SMX、动态并行、Hyper-Q；GPU 能自己派发工作了。 2014 — Maxwell（M40）：重新设计的 SM，每瓦性能约为 Kepler 的 2 倍。 2016 — Pascal（P100）：NVLink 1.0、HBM2、原生 FP16 吞吐；第一块明确为深度学习设计的 GPU。 2017 — Volta（V100）：第一代 Tensor Core；独立线程调度。 2018 — Turing（T4）：第二代 Tensor Core，支持 INT8/INT4；第一代 RT Core。 2020 — Ampere（A100）：第三代 Tensor Core，支持 TF32 和结构化稀疏；多实例 GPU（MIG）分区。 2022 — Hopper（H100、H200、GH200）：第四代 Tensor Core、FP8、Transformer Engine；HBM3、TMA、线程块簇（thread block cluster）、异步 wgmma。 2024 — Blackwell（B100、B200、GB200）：第五代 Tensor Core，支持 FP4、张量内存（TMEM）、双 die 芯粒 GPU、NVLink 5。 2025 — Blackwell Ultra（B300、GB300）：中期刷新：FP4 吞吐约 1.5 倍，288 GB HBM3e。为长上下文推理调优。 2026 — Rubin（Rubin、VR200、Rubin CPX）：HBM4、第三代 Transformer Engine、Vera CPU 配对、通过 Rubin CPX 做解耦式 prefill。 2027 — Rubin Ultra：四 die GPU 封装，单封装 1 TB HBM4e。部署在 600 kW 的 NVL576 Kyber 机柜中，单 GPU 100 PetaFLOPS FP4。

架构

一块 NVIDIA GPU 是一组面向吞吐的核、一层深内存层级把它们喂饱，再加上刚好够用的调度硅，让成千上万个线程保持飞行。这些核就是流式多处理器（SM），每个封装里复制 100 多个：V100 有 80 个，A100 108 个，H100 132 个，B200 148 个，B300 160 个，Rubin 224 个。每个 SM 内部都是同一套配方：四个 SM 子分区（SM Sub-Partition），各自有 warp 调度器、派发单元、16k×32 位寄存器堆、标量 CUDA Core 通道、用于超越函数的专用功能单元（SFU），以及一条直通 SM 内 Tensor Core 的私有端口。四个分区共享一个 L1/共享内存块和 TMA。线程以 32 个为一组（warp），按 SIMT 锁步执行；每个分区驻留着几十个 warp，调度器在它们之间切换，掩盖内存/算术停顿。

#### 计算

CUDA Core 是最初的计算吞吐来源，在 AI 场景里它们至今仍负责所有不是 matmul 的活：激活、残差相加、归一化、地址运算。但一个 transformer 块约有 99% 的 FLOPs 是 matmul，所以压倒性的计算吞吐来自 Tensor Core。

这些核心在小矩阵分块上执行融合的矩阵乘加，D=A·B+C。完整的 matmul 被拆成输出分块：要产出一个输出分块，kernel 沿着共享的内维 K 推进，从左侧输入矩阵的行条带取 A、从右侧矩阵的列条带取 B，把每个部分积折进一个滚动累加器。C 持有到目前为止的部分和，D 是带入下一步的更新值。内层循环走完后，D 就是完整输出矩阵中一个完工的分块；整个 matmul 由许多这样的分块 MMA 拼成。

分块形状写作 M × N × K：M × N 是输出分块大小，K 是一条指令一次收缩的内维长度；matmul 剩下的 K 轴由 kernel 的内层循环走完。累加器在循环里是粘性的：每条 MMA 的输出 D 变成下一条 MMA 的输入 C，所以这个式子实际上是原地运算 C←A·B+C：连续指令把部分积折进同一份存储，直到 K 轴完全走完。

V100 的第一代单元（每 SM 8 个）跑一个 warp 级的 16×16×16 FP16 MMA。A100 的第三代单元加入 TF32、BF16、FP64 matmul 和 2:4 结构化稀疏。H100 的第四代单元加入原生 FP8，并把抽象从 warp 抬升到 warp 组：128 个协作线程发射一个 64×256×16 形状的异步 wgmma，在后台运行，同时发起 warp 装载下一块。B200 的第五代单元更进一步：双 SM 的 256×256×16 MMA，操作数横跨一对 SM，原生 FP4，每个 SM 配一块专用的 256 KB 张量内存（TMEM）暂存，累加器分块落在里面而不是流进寄存器堆。Rubin 的第六代单元继续扩展 FP4 吞吐，加入原生 FP6，并与第三代 Transformer Engine 配对——它在硬件里做自适应 NVFP4 微块缩放，把逐分块的量化元数据留在 Tensor Core 路径上，而不是经过 CUDA Core。

六代不变的，是 matmul 始终活在线程/warp 层级里；变的只是发射一个 matmul 所需的线程数在减少，且发射与执行已经解耦。Volta 的 mma.sync 是 warp 集体且同步的：warp 里全部 32 个线程一起执行它，每个 lane 持有 A、B 和累加器 D 的寄存器分片，warp 阻塞直到完成。Hopper 的 wgmma.mma_async 把发起者扩大到 128 线程的 warp 组，B 移进共享内存描述符（A 可选：寄存器或描述符，kernel 自选），并且立即返回：matmul 在后台跑，warp 组继续排队下一块，完成状态用 wgmma.commit_group / wgmma.wait_group 跟踪。

Blackwell 的 tcgen05.mma 完成了这次迁移：A 也进了共享内存描述符（或直接从 TMEM 来），累加器 D 落在 TMEM 而不是寄存器堆。所有操作数都离开了 lane，就没有逐线程状态需要协调发射了，所以单个线程发一条指令就立即返回，完成信号由消费者 warp 等待的 mbarrier 给出。warp 其余部分、甚至发起线程本尊，都可以在这期间去干别的。CTA-pair 变体把同样的模型扩展到两个 SM：配对簇里每个 SM 各出一个线程发射协调的 MMA，跨两个 SM 共享操作数，拼出 256×256×16 的双 SM 分块——同样的异步/mbarrier 完成机制，只是升级成簇级屏障，让配对保持同步。

matmul 变得越来越大，同时发射它的线程负担越来越轻：一条最初由 32 个 lane 锁步执行的指令，如今更接近一条由描述符驱动的命令——从 warp 模型内部派发，但不再由 warp 执行。

正是这种解耦，让 transformer 注意力 kernel 在 GPU 上变得高效。matmul 在飞的时候，warp 可以跑 softmax、施加 mask、或预载下一块；matmul 与周围逐元素工作的重叠，就是每个现代注意力 kernel（FlashAttention-3、FA4）的结构，而它依赖矩阵指令不阻塞 warp。

#### 内存

片上层级每一层都是硬件管理的缓存，软件提示叠在上面。片外是 HBM：V100 上 32 GB HBM2，H100 上 80 GB HBM3，B200 上 192 GB HBM3e，B300 上 288 GB，Rubin 上 288 GB HBM4。芯片级 L2 缓存坐在 HBM 和 SM 之间：V100 上 6 MB，A100 上 40 MB，H100 上 50 MB，B200 上 60 MB（在双 die 封装里分成两个 30 MB bank，带局部性感知的驻留控制，热分块可以钉在邻近 die 上）。每个 SM 内部，256 KB 统一的 L1/SMEM 在 kernel 启动时被划分成硬件管理的 L1 和程序员控制的暂存。寄存器堆每个 SM 又约 256 KB，被四等分到各分区。

Blackwell 加了第五层：TMEM，每 SM 256 KB，专供 MMA 累加器、只有 Tensor Core 能寻址，把操作数驻留压力从通用寄存器堆里挪了出去。

层级间的搬运在逐步与 warp 解耦。Ampere 之前，装载一块是同步的：每个线程自己发全局 load，warp 阻塞到每个分片都落进寄存器，再二次拷贝到共享内存；每一块都烧掉 warp 通道去做地址运算和等待。Ampere 引入 cp.async：逐线程异步拷贝 HBM→SMEM，完全绕过寄存器，warp 成组提交在途拷贝，只在消费者需要数据时才等待。Hopper 用 TMA 取代了它——一个专用 DMA 引擎：一个线程提交多维分块描述符（基址、leading dimension、swizzle），引擎处理全部地址运算并写入共享内存，完成由 mbarrier 通知。整个 warp 从 load 发射和地址数学中解放出来；kernel 只需要排队描述符。TMA 还支持簇级多播：一次 HBM 读扇出到线程块簇里的每个 SM，把原来 N 次独立 load 变成一次。Blackwell 再次扩展 TMA：直接 load 进 TMEM，累加器分块不用经 SMEM 中转。轨迹就是：每一代，warp 每块要操心的事都少一件。

#### Warp 特化

Hopper 时代的编程范式是 warp 特化（warp specialisation）：在一个块里，一些 warp 当生产者，连续发射 TMA load；另一些当消费者，对刚到达的分块发射 wgmma。它们之间的同步不再是老的 SM 级 __syncthreads() 屏障，而是 mbarrier（共享内存里的内存屏障）和挂在 TMA 完成上的异步事务屏障——允许在 warp 粒度而非块粒度做细粒度的生产者/消费者握手。那个已经成为每个现代注意力 kernel（FlashAttention-3、CUTLASS ping-pong GEMM、Blackwell FA4 kernel）参照的配方是同一套：TMA 驱动的生产者流水线，通过共享内存和 TMEM 喂给 wgmma 消费者流水线，用 mbarrier 握手，线程块簇（Hopper+）把多个 SM 绑成一个协作计算单元，Blackwell 的双 SM MMA 自然叠加其上。

#### 数值格式

FP32 是历史默认；Volta 带来 FP16 配 FP32 累加，以及让它可训练的 loss scaling 技巧；Ampere 加入 TF32（FP32 范围、FP16 尾数，FP32 matmul 的即插即用替代）、BF16 和 2:4 结构化稀疏（剪枝权重上有效吞吐翻倍）。Hopper 引入原生 FP8（E4M3 和 E5M2 都有），配上 Transformer Engine——逐层自动缩放激活，把数值保持进 FP8 动态范围。Blackwell 用 FP4 把精度再砍半，并推出微缩放 MX 格式（块级共享指数，找回 FP4 丢掉的大部分精度），连同第二代 Transformer Engine，把自动缩放流水线改挂到 FP4。Rubin 的第三代 Transformer Engine 加入 NVFP4（NVIDIA 收紧版的 FP4）和更激进稀疏支持下的原生 FP6。芯片布局本身现在也是数值叙事的一部分：B100/B200/B300 是两个受光罩限制的 die，由约 10 TB/s 的 NV-HBI 链路缝合，对软件呈现为一块逻辑 GPU，封装上有 8 组 HBM 堆栈；Rubin 把芯粒配方扩展到约 3360 亿晶体管的双 die，配 8 组 HBM4 堆栈。每一代大致用「位数减半 + 更细粒度的缩放方案把精度找回来」换来每瓦约 2 倍吞吐，并且越来越靠往封装里熔进更多硅来达成。

#### 赌注

• 赌注 1：可编程性。工作负载是移动靶（注意力变体、新模型架构层出不穷），所以让每个模块都可编程，把写 CUDA 的权利交给开发者。即使是专用单元，也是通过这个模型暴露的，而不是做成固定功能块。
• 赌注 2：用海量多线程掩盖延迟。延迟不可预测且依赖数据，所以不用静态调度去藏它，而是用大规模线程超订：每个 SM 最多 64 个驻留 warp，硬件 warp 调度器每个周期挑一个就绪的 warp。
• 赌注 3：把 matmul 包进 warp。矩阵单元是压倒性的计算吞吐来源，但它必须活在和其他一切相同的 warp/线程抽象后面，所以把它包成 mma.sync → wgmma → tcgen05.mma——而不是暴露成固定功能管道。这让单个 kernel 能一趟融合 matmul、softmax 和逐元素操作。
• 赌注 4：异步内存层级。把内存层级做得显式、由程序员管理，而不是隐式、由编译器调度。保留 L2 缓存，但把 SMEM 和 TMEM 暴露成具名暂存，在上面叠异步机制：TMA 做批量拷贝，TMEM 做 matmul 累加器，mbarrier 做生产者/消费者握手。层级在可编程 kernel 内部做软件流水，而不是编译器对着一个已知延迟的暂存做静态调度。
• 赌注 5：摊薄 SIMT 税。每一颗花在 warp 调度器、寄存器堆或一致性缓存上的晶体管，都是一颗没花在 MAC 上的晶体管；接受这笔税，然后用两种方式还：Tensor Core 现在大到让 SIMT 机制摊到多得多的 MAC 数量上，以及 TMEM 这类单元用一部分通用灵活性换 MAC 密度。

扩展

扩展有两个区间：scale-up 和 scale-out。

AI 基础设施两者都用：吃带宽的集合通信（张量并行、MoE 专家路由）留在 scale-up 域内；数据并行和流水线并行穿过 scale-out 网络。

#### Scale-up

scale-up 栈是 NVLink 加 NVSwitch。NVLink 在 GPU 之间实现缓存一致性网络，所以一块 GPU 上的 load/store 可以指向另一块 GPU 的 HBM，硬件负责地址翻译和一致性。但 NVLink 本身是点对点的：一条链路只连接两颗芯片。NVSwitch 是一颗专用 crossbar 芯片，每颗 GPU 都连上去，由它路由流量，让每颗 GPU 都能以完整 NVLink 带宽同时与其它每一颗通信——无阻塞、全对全。

它们一起定义了 HGX 8-GPU 基板：八颗 H100 SXM 模块通过 PCIe Gen 5 与 x86 主机（AMD EPYC 或 Intel Xeon）配对。Hopper 还推出了 Grace 配对形态：GH200 Grace Hopper Superchip 把一颗 Grace ARM CPU 和一颗 H100 通过 900 GB/s 的 NVLink-C2C 熔在一起，消掉了 PCIe 主机-设备一跳。模块再往上组成 GH200 NVL2 对和机柜级 GH200 NVL32。Blackwell 把配对做成默认形态。GB200 模块把一颗 Grace 和两颗 B200 通过 NVLink-C2C 融合，NVL72 把 36 个这样的模块缝进一个液冷 scale-up 域：72 颗 GPU、36 颗 Grace CPU、13.5 TB HBM 和 17 TB LPDDR5X，作为一个平坦、一致的地址空间。Rubin 分两步走。NVL144 在 2026 年出货，是 Oberon 级机柜内的 Rubin 世代刷新：72 个 Rubin 封装，按 NVIDIA 新的 die 计数惯例称 144 颗 GPU，配 HBM4 和翻倍的 NVLink 6 每封装带宽。真正的机柜级跃升是 2027 年的 Rubin Ultra：NVL576 把 144 个四 die 的 Rubin Ultra 封装塞进新的 Kyber 机箱，形成单个一致域里的 576 颗 GPU die。

这种密度靠无源铜线维系。NVL72 的 NVLink 网络跑在 5,184 根穿过背板盲插的线缆上（每机柜约 2 英里线缆，线内无重定时器，SerDes 住在 GPU 和交换 ASIC 里），在 72 颗 GPU 之间承载约 130 TB/s 全对全带宽。NVIDIA 估计，与每条链路都要可插拔收发器的光方案相比，选铜线每机柜省约 20 kW。铜线是「机柜即一块 GPU」在经济上可行的原因：2 米以内的短距，它在功率、成本和每美元信号完整性上仍然胜出；再远，比特就得走玻璃。

NVL144 留在 Oberon 里，铜线继续可用，因为封装数（72）与 NVL72 相同；线缆不用变长，只是用 Gen 6 SerDes 传得更快。Rubin Ultra 的 NVL576 靠重塑机柜守住铜线：新的 Kyber 形态大概是 Oberon 的两倍高，把所有 576 颗 GPU die 装进一个机箱，尺寸设计成即使 144 个四 die 封装、几万根线缆，每条 NVLink 路径仍在无源铜线可达范围内。

#### Scale-out

scale-out 栈来自他们对 Mellanox 的收购。与 NVLink 不同，scale-out 网络不保持一致：各节点地址空间独立，数据只能通过软件发起的显式 RDMA 跨越，通常包在 NCCL 集合通信里（如 all-reduce 或 all-to-all）。参考集群是 DGX SuperPOD：八个 NVL72 机柜通过 Quantum-X800 InfiniBand 缝在一起，得到单个调度器下的 576 颗 Blackwell GPU；训练集群再用 SuperPOD 平铺继续扩大。2026 年的 Rubin SuperPOD 保持同样的 8 机柜模式配 NVL144（每个 SuperPOD 得到 1,152 颗 GPU，而非 576）。2027 年的 Rubin Ultra 把配方放大一个数量级：每个 Kyber 机柜 576 颗 GPU die，通过 Quantum-X Photonics CPO 缝在一起，让几千颗 GPU 处于一个调度器之下。

每颗 GPU 都有一块自己的 ConnectX NIC 接入网络。Blackwell 节点用 800 Gbps 的 ConnectX-8（每 GPU），带宽比每 GPU NVLink 低一个数量级，延迟从纳秒级爬到微秒级。Rubin 换 1.6 Tbps 的 ConnectX-9（每 GPU），在每机柜 scale-up 域从 72 涨到 576 颗 GPU 的同时，把每 GPU scale-out 带宽翻倍。每块 NIC 旁边还有一颗 BlueField DPU，加进 ARM 核和加速器，把存储、网络和安全从宿主机 CPU 上卸载下来。喜欢以太网胜过 InfiniBand 的客户，可以用 Spectrum-X——为 AI 流量调优的无损以太网方案。

铜线到玻璃的切换发生在机柜边界。NVL72 内部的主干是铜；链路一旦要以 800 Gbps 跨机柜，就是光。无源铜 DAC 在 200 G/lane 下大约到 1.5–2 米就到顶，远够不到跨机柜距离，所以今天的 SuperPOD 主干骑在 OSFP-RHS 可插拔收发器上——每个模块自带激光器、调制器、光电探测器和 DSP。一个扇出到几千颗 GPU 的 SuperPOD 主干，在光学意义上就是几万个可插拔模块，光靠收发器激光就吃掉几十千瓦。

到了 Rubin，这层光沉进交换 ASIC 里。Quantum-X Photonics（InfiniBand）和 Spectrum-X Photonics（以太网）用共封装光学取代可插拔模块：激光器、调制器、光电探测器通过 TSMC COUPE 键合到交换封装上。NVIDIA 声称激光器少约 4 倍、链路功耗低约 3.5 倍。那块把 GPU 变成双 die 封装、把 HBM 叠到旁边的芯粒逻辑，现在出现在网络层：计算、内存和光子学在同一基板上垂直整合。

NVLink Fusion 最近把 scale-up 网络本身打开了：第三方 CPU 和 XPU 现在可以加入 NVLink 域，让超大规模厂商围绕 NVIDIA 的互连做半定制机柜，而不用自己从头设计一致网络。

#### 软件

CUDA 是大规模并行处理器天然而成的编程模型。你写一个 kernel（一段每线程执行一次的代码），然后把它发射到按块和 warp 组织的成千上万个线程上；共享什么、何时同步、每段线程处理哪块问题，都由程序员决定。这就是为什么这个抽象十八年几乎没变，也是为什么 2007 年以来写的每个 CUDA kernel 今天在 Blackwell 上仍然能编译能跑。

这种延续性既是护城河也是约束。每一代新硬件（Tensor Core、TMA、TMEM）都落进同一个 kernel-and-warp 模型，以 PTX 和 SASS 里的内建函数形式暴露：mma.sync、wgmma.mma_async 等等。NVIDIA 不能对 SM 做根本性重想，因为依赖它的代码太多了；作为回报，每一笔对 CUDA 的投资都跨代复利。

PTX 之上是二十年堆起来的栈。cuBLAS 和 cuDNN 管数学和 DNN 原语；CUTLASS 把几十年的 GEMM 经验编码进模板 C++；TensorRT-LLM 做分页注意力、在途批处理和投机解码；PyTorch、Triton、JAX 提供框架绑定。

FlashAttention 是现代 AI 最重要的算法重写之一，它把注意力分块，避免物化 O(N²) 矩阵。它的四代（FA1 到 FA4）每一代都为最新的 NVIDIA 硅手工优化（FA3 吃 Hopper 的异步流水线，FA4 吃 Blackwell），移植到其它硬件要晚几个月甚至几年。

这套栈大部分是 NVIDIA 不付钱的人写的。护城河不是 CUDA 本身；是二十年积累的第三方 kernel、库和工具链，以及数百万一路学会了这套 API 的开发者。

NVIDIA 还随硅一起输出人力专长。他们把几十名自家工程师嵌进前沿实验室和超大规模团队，为每个新模型架构写 kernel，并针对每代新硅调优。一个实验室下个月想训的东西，往往在 NVIDIA 上跑得比其他平台快得多。因此，离开 NVIDIA 不只是重写 kernel 和库——是重训一整支工程团队的思维模型，还要失去今天坐在你楼里的那些 NVIDIA 工程师。

Google TPU

TPU 是一台矩阵乘法机器。它的哲学是：与其做一块能跑任何大规模并行工作负载的可编程芯片，不如聚焦单一原语（在大型脉动阵列上做稠密矩阵乘法），然后让 XLA 编译器把所有周期和每一字节内存都提前规划好。没有硬件调度器、没有缓存、没有线程/warp。每一代都在扩大 pod：几千颗芯片通过 ICI 互连织成一台一致的机器。TPU 毫无渲染图形或跑科学模拟的野心；它存在的意义，是比任何通用替代方案都更省每瓦地训练和跑 Google 的工作负载（搜索、翻译、推荐、Gemini）。

谱系

2015 — TPU v1：第一代，仅推理，INT8 脉动阵列，部署进搜索与翻译生产链路。 2017 — TPU v2：第一代可训练 TPU；BF16 与 FP32 累加；128×128 MXU；ICI 2D torus。 2018 — TPU v3：液冷；训练性能约 2 倍于 v2。 2020 — TPU v4：3D torus、SparseCore、CMEM；第一个部署 4,096 芯片超级 pod。 2023 — TPU v5e / v5p：能效芯片 v5e（单 TensorCore）与旗舰 v5p（8,960 芯片 pod）分道扬镳。 2024 — Trillium（v6e）：256×256 MXU 回归；OpenXLA 时代。 2025 — Ironwood（v7）：原生 FP8；9,216 芯片 pod，1.77 PB HBM。 2026 — TPU 8t（Sunfish）/ 8i（Zebrafish）：FP4；8t 用 Virgo scale-out，8i 用 Boardfly 拓扑专攻 MoE 推理。

架构

一颗 TPU 芯片就是一个 matmul 引擎，外面包着刚好够用的硅把它喂饱。计算单元是 TensorCore：v2 起旗舰芯片每封装两颗；能效调优芯片（v4i、v5e、v6e）带一颗。每个 TensorCore 内部都是同一个五部件配方：一个或多个 MXU 做矩阵数学，一个 VPU 做逐元素数学，一个 Scalar Unit 唱主角，一个 XLU 做跨 lane 归约，外加一个转置/置换单元，以及喂给和排空 MXU 的累加器队列。从 v4 起，每颗芯片在 TensorCore 之外还带专用 SparseCore 数据流引擎（v4、v5p 和 Ironwood 每芯片 4 个；Trillium 每芯片 2 个），专门吸收脉动阵列形状不对的嵌入查找负载。每个模块都坐在单一 VLIW 发射平面上，由 Core Sequencer 驱动，每个周期填满 322 位指令束的全部八个功能槽。没有指令缓存未命中、没有 warp 调度器、没有乱序引擎、没有分支预测器：编译器就是调度器，省下的硅面积全花在更多 MAC 上。

#### TensorCore

MXU 就是脉动阵列。v1 出货一块 256×256 INT8 推理阵列；v2 是第一代可训练 TPU，引入 128×128 单元做 BF16 乘 FP32 累加（INT8 从 v4 起以同等吞吐回到 MXU）。每颗 TensorCore 的单元数从那时起增长：v2 上 1 个 MXU → v3 上 2 个 → v4/v5e/v5p 上 4 个。Trillium 回到 256×256（每阵列每周期 65,536 个乘加单元），Ironwood、8t、8i 都保持 256×256 形状。

要算 C=A×B，矩阵 B 的值预先按每单元一个权重载入：这是权重驻留（weight-stationary）数据流，也是 TPU 区别于别处输出驻留（output-stationary）阵列的选择。激活从左边进入，每周期推进一列，在每个单元里与驻留权重相乘，部分和向下流进底部的累加器队列。数据一进阵列就不再发生内存访问：每个权重对每个流经的激活都复用一次，每个激活在行上被复用 128（或 256）次。数据复用被焊进硅里，而不是由缓存仲裁。计算的主导成本不是乘法本身（几皮焦），而是以 100–1000 倍的能量读写内存；脉动阵列在构造上就删掉了这笔成本。代价是欠填充（underfill）：在 256×256 阵列上跑 128×128 的 matmul 浪费 75% 的硅，所以 XLA 把维度分块、填充、调度到 128（v6e+ 为 256）的倍数，模型代码写的时候就要心里有这些量子。

VPU 是第二小提琴的计算引擎，但在很多方面是更有意思的微架构对象：每颗 TPU 都是一台 2D 向量机，不是 1D SIMD 机。VPU 的寄存器堆持有 2D VREG。v4/v5p 上形状是 (8, 128)：128 lane 宽、8 sublane 深，每核 32（v4）或 64（v5p）个寄存器，每个 (lane, sublane) 有 4 个独立浮点 ALU。lane 轴与脉动阵列的输入宽度匹配，所以 Trillium 和 Ironwood 上 MXU 加宽时 lane 数大概也加宽到 256；Google 没有公布 v5p 之后的 VPU 尺寸。sublane 轴让 VPU 以每 X 个时钟一个 matmul 的速度把分块流进 MXU（X 即 sublane 维度）。现代 TPU 程序的大部分加速来自 VPU/MXU 重叠：量化、layernorm、softmax、激活、加偏置都在 MXU 于身后跑 matmul 的同一批周期里跑在 VPU 上。跨 lane 归约（任何 2D 向量 ISA 都别扭的情形）由 XLU 处理：慢、贵，是出了名的编译器热点。与 2D 形状对不齐的布局变换由专用转置/置换单元吸收，省掉一趟内存往返。

Scalar Unit 是最小的块，也可能是最要紧的：一个单线程、双发射整数 ALU，32 个 32 位寄存器、4 KiB SMEM 存控制状态，配一块装程序的 Imem。它是唯一做指令取指的块；每个周期它拉一条 322 位 VLIW 指令束，本地执行自己的两个标量槽（地址运算、循环计数、分支、同步寄存器检查），把其余六个槽派发给芯片其它部分：2 个向量 ALU（VPU）、2 个向量 load/store（HBM↔VMEM DMA）、2 个矩阵（推/弹 MXU 队列）。块间同步是显式的：sync 标志跟踪 MXU 和 VPU 流水线是否忙碌，编译器插入屏障检查，而不是硬件跟踪依赖。Scalar Unit 就是让 TensorCore 其余部分看起来像固定功能数据流的原因：每个周期，一个地方决定八件事同时发生，而且没有动态重排缓冲来撤销一个坏决定。

#### 内存

片上内存层级与计算侧是同一个想法：没有缓存，每一层都软件管理。片外是 HBM（v2/v5e 上 16 GB，v3/v4/v6e 上 32 GB，v5p 上 95 GB，Ironwood 上 192 GB，v8 代上 216–288 GB），片上是一层手工堆叠的显式可寻址暂存。离计算最近的是 VMEM，喂给 VPU 和 MXU 输入队列的向量暂存：v4 上 32 MiB，v5e 上 128 MiB，推理调优的 v8i 上拉到 384 MiB——目的就是让整个 KV cache 待在片上。它上面是 CMEM，v4 引入的 128 MiB：一块更慢、更大的 SRAM 中转区，坐在 HBM 和 VMEM 之间，吸收融合算子的中间结果。Scalar Unit 有自己的 SMEM（v4 上约 10 MiB 控制状态）和一小块标量寄存器堆。程序里每个张量在编译期被钉在某一层；XLA 的 buffer-assignment pass 调度各层间的 DMA，让数据恰好在消费它的周期之前到达。硬件不做预取、不做驱逐、不做一致性；编译器排对了，阵列永不停顿；排错了，没有任何兜底路径。

#### SparseCore

TensorCore 之外打破脉动模子的那块，是 v4 引入的 SparseCore。推荐和排序模型活在嵌入查找上（数十亿个索引指向巨大表格），访问模式与稠密 matmul 正好相反：不规则、间接、全对全。256×256 脉动阵列恰好是错得最离谱的形状。SparseCore 是一台带 16 个计算分块和专用 SPMEM 暂存的数据流处理器，坐在 TensorCore 旁边，吸收 scatter、gather、分段归约原语，以及分片嵌入表产生的依赖数据的全对全流量。这以约 5% 的 die 面积和功耗换来嵌入密集模型 5–7 倍加速。v4 每芯片出货 4 个 SparseCore，v5p 保持，Trillium 降到 2，Ironwood 回到 4（双 die 布局上每芯粒 2 个）。v8i（Zebrafish）推理芯片把 SparseCore 整个去掉，换成 I/O 芯粒上的 CAE（集合加速引擎）：不同的问题（自回归 decode 期间的集合归约），同样的思路（从主核旁切出一小块加速器，吸收脉动阵列形状不对的负载）。

#### 数值格式

TPU v1 只做 INT8 推理；v2 换成 BF16 作为标准训练格式：与 FP32 相同的动态范围、一半内存、不需要 loss scaling 技巧。v4 重新引入原生 INT8。Ironwood 加入原生 FP8（E4M3 和 E5M2 都有），同样面积下约为 BF16 吞吐的 2 倍。v8 加入原生 FP4 和 MXU 内部的块缩放乘法，删掉了 Ironwood 还要付的 VPU 反量化开销。随机舍入（stochastic rounding）在每一代现代 TensorCore 上都有硬件支持：由低位尾数当概率做舍入决定，在长训练运行中保住低精度累加的期望值，也是让 BF16/FP8 追平 FP32 精度的细节之一。

芯片边界上就是 ICI 端口本身（2D torus 芯片 v2/v3/v5e/v6e 上 4 个端口，3D torus 旗舰 v4/v5p/v7/8t 上 6 个），以及用于 scale-out 的 DCN NIC。从芯片级看，ICI 端口只是 Core Sequencer 能在 VLIW 束里瞄准的又一组 DMA 引擎：远程张量发送与 VMEM→HBM 搬运是同一指令类，编译器把集合通信当成它为计算和本地内存构建的同一张调度表的一部分。

#### 赌注

• 赌注 1：脉动阵列。matmul 主宰工作负载，所以把硅都花在脉动阵列上。
• 赌注 2：软件暂存。算力便宜、内存昂贵，所以在阵列的线路上复用数据，用软件管理的暂存取代缓存。
• 赌注 3：编译器调度。工作负载静态可预测，所以把调度搬进编译器：VLIW 发射、无投机、无乱序、无动态调度器。
• 赌注 4：纯 MAC 硅。功耗比峰值重要，所以删掉每一颗不做乘加的晶体管：每一条缓存 tag、每一个分支预测器、每一个重排缓冲。
• 赌注 5：阵列外的专用引擎。稠密 matmul 阵列对一些真实工作负载（嵌入、集合通信）形状不对，所以切出小型专用引擎（SparseCore、CAE），而不是把主核扭成能塞下它们的形状。

扩展

TPU 的 scale-up 故事与 NVIDIA 正好相反。NVLink + NVSwitch 让每一颗别的 GPU 的 HBM 看起来像本地内存（一个硬件管理的一致地址空间），而 Google 的 ICI 是消息传递：没有远程 load 语义、没有缓存一致性、没有 crossbar。每个多芯片操作都是 XLA 编译出来的显式集合通信。scale-up 域不是靠交换网络绑在一起，而是靠 torus（芯片直连邻居、边缘回绕），并在机柜边界用光路交换机缝合。

#### Scale-up

ICI 链路直接从 TPU die 里伸出来：高速串行 lane，64 芯片立方体（4×4×4 排列，住在一个液冷机柜里）内部用直连铜线，立方体之间用光。每芯片聚合 ICI 带宽从 v2 的约 250 GB/s 涨到 Ironwood 的 1.2 TB/s 双向，v8t 再翻一倍。拓扑按代交替：能效芯片（v2、v3、v5e、v6e）用 2D torus，旗舰（v4、v5p、v7、v8t）用 3D torus。

NVIDIA 没有对应物的那块是 Palomar OCS：一台坐在立方体之间的 3D-MEMS 光路交换机。微小镜片物理旋转，把任意输入光纤映射到任意输出。一个 v4 超级 pod 用 48 台 Palomar 交换机把 64 个立方体（4,096 颗芯片）织成一个 3D torus；v5p 和 Ironwood 把同样的方案放大。重配置是毫秒级而非纳秒级，但没关系，因为 OCS 是电路交换：任务开始时挑一种拓扑，跑一个星期，再为下一个工作负载重配。三个问题塌缩进一个组件：按工作负载重配拓扑（扭曲 torus 能把对分带宽最多提升 70%）、按需切分子 pod、以及容错（一颗芯片挂了，OCS 光学换入一个备用立方体，运行继续，不丢 ICI 域）。

这让超级 pod 成为 scale-up 的单位：角色上相当于 NVIDIA 的 NVL72，但大两个数量级。v4 是 4,096 颗芯片；v5p 是 8,960；Ironwood（TPU v7）是 9,216 颗，排成 144 个 64 芯片立方体，以一个一致 ICI 域的形式呈现 1.77 PB HBM（约 68 PB/s）和 42.5 ExaFLOPS FP8。

TPU 8t（Sunfish）把它拉到 9,600 颗芯片、2 PB HBM（约 62 PB/s）、121 ExaFLOPS FP4。TPU 8i（Zebrafish）有 1,024 颗芯片、约 295 TB HBM（8.8 PB/s）、约 10 ExaFLOPS FP4。8i 用新的分层高基数拓扑 Boardfly（4 芯片环 → 8 板组 → 最多 36 组由 OCS 相连）取代 torus，全对全延迟减半。这是为 MoE 推理设计的。3D torus 在集合通信是最近邻时大放异彩（环形 all-reduce 每个周期用满每条链路），但 MoE 专家路由是相反的模式——全对全：每颗芯片给其它每一颗都发独特的分片，往返延迟由最长跳的那对决定。1,024 芯片 3D torus 的直径为 16 跳；Boardfly 的环 → 组 → OCS 层级把它压到 7。

#### Scale-out

到 TPU v7 为止，scale-out 跑在单一网络上：Jupiter，自 2022 年起主干全光（Apollo OCS，与 Palomar 同属 3D-MEMS 家族），横跨整栋楼。Google 在从机柜到数据中心主干的每一层都用同一个原语（光路交换）；这是别人没有的架构签名。今天的 Jupiter 每栋楼承载 13 Pb/s 对分带宽。

TPU 8t 起，scale-out 拆成两个网络。东西向 TPU 到 TPU 流量迁到 Virgo——一张专用加速器网络；Jupiter 保留南北向角色：存储访问、通用计算、跨站点扩展。Virgo 是建立在高端口数交换机上的平坦两层无阻塞拓扑：任何 TPU 到任何其它 TPU 最多隔两台交换机。一个 Virgo 集群以 47 Pb/s 对分带宽连接 134,000+ 颗 TPU 8t（每芯片带宽 4 倍、空载延迟比上一代 DCN 低 40%），带多平面故障隔离和亚毫秒遥测，让调度器在掉队者毁掉一个 step 之前就把它干掉。架构上的回报是每一层现在都能独立演进：scale-up、东西向 scale-out 和前端可以按不同节奏迭代，不用重拉其它部分的线。

每芯片 scale-out 带宽在 Ironwood 上约 100 Gbps，v8t 上翻 4 倍，但仍比每芯片 ICI 低两个数量级。这个带宽差距决定了划分方式：张量并行和 MoE 专家路由留在 ICI 内；数据并行和流水线并行穿过 scale-out 网络。

Google 的 Multislice 框架接进 XLA，让单个 SPMD 程序跨不同 pod 的多个 slice；编译器发出分层集合通信（每个 slice 内做环形 all-reduce，上层再做更高级别的归约）。这个结构正是掩盖 ICI/DCN 带宽差距的把戏：尽可能多的工作留在 slice 内的快 ICI 上，只有跨 slice 的残余才付慢网络的成本。

再上面是 Pathways。NCCL + Slurm + Megatron 式调度器从许多控制器驱动 SPMD，而 Pathways 从单一客户端驱动整个任务，把多个「岛」（各自拥有 ICI 域的 pod）通过 DCN 虚拟化连接起来。它做 gang 调度、弹性训练（一个 slice 挂了，OCS 重塑拓扑，Pathways 在新形状上从最后一个检查点继续）、跨区域编排。Gemini Ultra 是第一个跨多个数据中心训练的前沿模型；Pathways 把它们缝成一个同步 SPMD 任务。

哲学是：编译器是调度器，torus 是拓扑，光路交换机是通用的可重配衬底——从机柜到数据中心每一层都是。

#### 软件

TPU 的栈是编译器驱动，CUDA 是 kernel 驱动。在 GPU 上，开发者写 kernel，框架把 kernel 串起来；编译器的工作大多是局部的。在 TPU 上，开发者在 JAX 里写数值程序，XLA 负责它下面的一切：哪些操作融合、每个张量住在哪、它在 2D 向量寄存器上怎么布局、HBM 到 VMEM 的 DMA 何时发射、322 位 VLIW 指令束怎么调度、程序怎么跨几千颗芯片分片。没有硬件兜底：没有 warp 调度器、没有缓存、没有乱序引擎来遮盖坏调度。编译器就是系统。这是架构最核心的那个权衡：XLA 不靠手工调优就能逼近理论上限，但要补齐剩下的差距更难。

编译路径是 JAX → JAXpr → StableHLO → HLO → LLO → VLIW 指令束。JAX 在 jit 下把 Python 函数跟踪成带类型的函数式 IR（JAXpr），下到 StableHLO（OpenXLA 标准化的、带版本的算子集，约 100 个静态形状原语，所有前端现在都发射它），XLA 把它当 HLO 吸收并跑过 pass 流水线：算子融合（把逐点 + 归约 + matmul 塌缩进一个 kernel，中间结果永不落 HBM）、布局分配（决定每个张量的 2D 分块，让它不用转置就能流进 MXU：在 1D SIMD 机器上难得多，因为寄存器和脉动输入都是 2D）、buffer 分配（每个张量钉在 VMEM、CMEM 或 HBM 上，重叠窗口预计算）、SPMD 划分，最后是填满每条指令束全部八个槽的 VLIW 调度器。HLO 下到 LLO（Low-Level Optimizer，TPU 专用 IR），LLO 发出最终 VLIW 流。编译得好的程序，每个周期在同一条指令束里重叠 MXU 脉动执行、VPU 逐元素数学和 HBM↔VMEM DMA。

多芯片执行是 SPMD：一个程序、分片数据、分层集合通信，由 GSPMD 发出（现在正被 Shardy 取代——一个 MLIR 原生的继任者，2026 年初成为默认）。用户用 Mesh + PartitionSpec 注解几个关键张量来声明式地表达分片；编译器把分片传播过整个图，在布局变化处插入 all-reduce、all-gather 和 reduce-scatter。编译器挑错集合通信时，shard_map 把用户扔进手动 SPMD（带显式局部形状和显式集合通信的逐设备代码），在 jit 内部可组合，所以单个 kernel 可以手工划分而不放弃其它地方的自动划分。这与 PyTorch 的习惯相反：FSDP 和 DeepSpeed 用运行时包住模型，在模块边界发集合通信；GSPMD/Shardy 把整张图当编译器问题来划分。

Pallas 是逃生门：JAX 的 kernel 写作语言，大致相当于 GPU 上的 Triton。Pallas kernel 用 JAX 风味的 Python 写，通过 Mosaic（基于 MLIR 的 TPU 后端）下到 LLO，再以自定义算子嵌回 HLO。它存在的理由是 XLA 并不总能对新颖注意力变体、融合 MoE 派发、或任何要求手动 VMEM 分块和 DMA 调度的东西合成出最优解：那是 FlashAttention 一级的优化，赢在调度而非代数。Pallas:Mosaic-GPU 用同一个前端瞄准 H100/Blackwell，所以 kernel 作者可以写一次、降到任一衬底。它上面的库层清一色 JAX 原生：Flax NNX 管模块、Optax 管优化器、Orbax 管异步分布式检查点、Grain 管输入流水线、Tunix 管后训练/RL、Qwix 管量化。Google 的参考训练栈（MaxText 训 LLM，包括 DeepSeek-V3 级 MoE；MaxDiffusion 训 Flux、Wan 2.1）坐在最顶层，纯 JAX；Pathways 垫在下面，以 pathwaysutils 暴露给用户，所以单个 Python 客户端能驱动跨几千颗芯片、好几个 pod 岛的任务，而不放弃 JAX 编程模型。

PyTorch 路径是真的，但是二等公民。torch_xla 用 LazyTensor 机制：每个 PyTorch 算子记录进一张 HLO 图，在下一个 barrier 时编译，编译产物按图形状哈希缓存。PyTorch/XLA 2.x 加了 GSPMD 式分片注解、通过 XLA 后端的 torch.compile 集成、一个 JAX 桥，以及（PyTorch/XLA 2.7）C++11-ABI 构建，跟踪大幅提速。与 JAX 的差距是真实的（JAX 的原语到 StableHLO 映射更干净，复杂并行策略覆盖更好），这正是 vLLM TPU（由 Cloud Next 2025 上公布的 tpu-inference 插件驱动）把所有模型——无论 JAX 定义还是 PyTorch 定义——都统一降到 JAX→XLA 路径的原因。TorchTPU 于 2026 年 4 月公布，是 Google 的回应：在 XLA 之上的原生 PyTorch 体验，带 eager 模式、torch.distributed 和 torch.compile，有望取代 torch_xla。

与 CUDA 相比，TPU 生态是中心化的，不是蔓延的。框架以下几乎一切（XLA、JAX、Flax、Optax、Pallas、MaxText、Pathways、Shardy、Mosaic）都是 Google 自己开源的，与硅同步演进。第三方 kernel 远没有 CUDA 几十年积累的那么多；工作负载长得奇怪的地方护城河更薄，长得像 Gemini 的地方护城河更深。最近 Ironwood（v7）「协同设计 AI 栈」的说法是明确的框架：芯片、ICI 网络、OCS、XLA、Pathways、Pallas、MaxText、vLLM 作为一个产品协同发布，v8t/v8i 在单一 tpu-inference 降级路径下延续同一模式。Triton 和 torch.compile 在 NVIDIA 那边收窄差距（kernel 驱动和编译器驱动在趋同），但哲学的两极仍然真实：在 TPU 上编译器是唯一重要的接口；在 GPU 上编译器只是几个之一。

AMD GPU

AMD Instinct GPU 押的是与 NVIDIA 不同的赌注：NVIDIA 每一代都在扩展每个 SM 的能力，而 AMD 自 GCN（2012）以来一直把计算单元（CU）保持在保守状态，把投入转向封装：自 2021 年起每一代都在 HBM 容量上追平或超过当代 NVIDIA 旗舰；第一块 3D 堆叠数据中心 GPU（CDNA 3）；第一块一致性 CPU+GPU APU（MI300A）；以及一个开放生态（ROCm、HIP、OCP MX、UALink）。

谱系

2018 — Vega 20（MI50、MI60）：第一块 7 nm GPU；1:2 FP64 向量吞吐。CDNA/RDNA 分家前最后一代 GCN 家族的 Instinct。 2020 — CDNA（MI100）：第一代 MFMA 矩阵核；图形固定功能硅整个丢掉。原生 BF16。 2021 — CDNA 2（MI210、MI250、MI250X）：第一代 MCM Instinct，双 GCD 封装；全速率 FP64 矩阵。 2023 — CDNA 3（MI300A、MI300X）：第一块 3D 堆叠芯粒 GPU：XCD 通过 TSV 混合键合到 IOD 上；FP8；Infinity Cache；MI300A 上的一致性 CPU+GPU APU；驱动 El Capitan。 2024 — CDNA 3 刷新（MI325X）：计算不变，HBM3E 刷新：256 GB @ 6.0 TB/s。 2025 — CDNA 4（MI350X、MI355X）：原生 FP4 / FP6 配 OCP MX 微缩放；每 CU FP64 大约砍半；第一代向 AI 密度倾斜而非 HPC 的芯片。 2026 — CDNA Next（MI430X、MI440X、MI455X）：HBM4；Helios 机柜（72 颗 GPU 的 MI455X 旗舰，发布时用 UALoE，2027 年起原生 UALink）：AMD 对 NVL72 的第一个回答。

架构

NVIDIA 的架构野心住在每个 SM 内部（每代新的张量原语、新的异步机制、新的操作数存储），AMD 的野心住在 CU 之间——有多少个 CU 能被熔进一个一致封装。CU 本身很保守：四个 16 lane SIMD、一个共享标量单元、64 KB Local Data Share、一个 L1 向量缓存、每 SIMD 一份 VGPR 文件配 CU 共享的 SGPR 池，以及（自 CDNA 1 起）一个跑 MFMA 的 Matrix Core。这个形状自 2012 年 GCN 以来没有实质变化；变的是数量（MI100 上 120 个 CU、MI250X 上 220 个、MI300X 上 304 个、MI355X 上 256 个）和把它们绑起来的封装。一个 64 线程的 wavefront 在 4 个周期里流过 16 条 SIMD lane，每个 SIMD 驻留许多 wavefront，由调度器切换以掩盖停顿。这里没什么离奇的东西；CDNA 有趣之处全在 CU 之外。

#### 计算

CU 内部，SIMD 和 Matrix Core 并排运行。四个 SIMD 处理所有逐元素的事：激活、归一化、残差、地址运算。Matrix Core 处理 matmul。这个分工与 NVIDIA 的 CUDA Core / Tensor Core 分工相同，但矩阵抽象沿着一条非常不同的曲线演进。

NVIDIA 的 Tensor Core 沿着线程层级往上爬：Volta 上是 32 线程 warp，Hopper 上是 128 线程 warp 组，Blackwell 上是单线程加可选双 SM 簇。AMD 的 Matrix Core 原地不动。每一代 MFMA（从 2020 年 MI100 到 2025 年 MI355X）都是 wavefront 作用域：一个 wave64 发射一条矩阵指令（V_MFMA_*），四个 SIMD 协作驱动它，操作数来自 wavefront 的寄存器堆：A 和 B 来自 VGPR，C 和 D 通常来自专用 AGPR 文件。指令变快了，格式集变宽了，但发射者和作用域没有变。唯一一次喂料侧的让步出现在 CDNA 4：一个从 LDS 的专用 MFMA 转置 load，把操作数按 Matrix Core 想要的布局交给它，精神上类似 NVIDIA 的 TMA，但矩阵指令本身仍是 wave 发射。

吞吐数字直接讲出了格式故事。CDNA 1 于 2020 年发布，FP32 / FP16 / BF16 / INT8 为每 CU 每周期 256 / 1024 / 512 / 1024 FLOPs，与 A100 同时提供原生 BF16。CDNA 2 把 FP64 路径翻倍成全速率矩阵，每 CU 每周期 256 FLOPs：这是 AMD 独有的赌注，也是让 MI250X 进 Frontier 的那一注。CDNA 3 在 FP8 上与 H100 打平（4,096 FLOPs，E4M3 + E5M2），加入 2:4 结构化稀疏，并加了一条 TF32 等价路径——截断尾数，以 FP64 矩阵速率跑 FP32 matmul。CDNA 4 再次翻倍：FP4 到 16,384 FLOPs、FP6 配 OCP MX 块缩放，并加入单条 MFMA 内 A/B 精度可混搭：例如 FP8 × FP4。同一代把每 CU FP64 吞吐砍半——AMD 第一次用 HPC 密度换 AI 密度，而不是两者都上。

wavefront 作用域的决定体现在两笔成本上。

发散（Divergence）。 半空的 wave64 浪费 32 条 lane，半空的 warp32 只浪费 16 条。对控制流大体均匀的工作负载，这是小代价；对不规则负载就疼了。

重叠（Overlap）。 NVIDIA 的异步、描述符驱动 matmul 把发射与执行解耦：发射线程发完指令就走；Tensor Core 在后台跑；前一个 matmul 还在飞时，warp 可以跑 softmax、施加 mask 或预载下一块。AMD 的 wavefront 集体 MFMA 没有给 wave 对等物：发射了 matmul 的同一个 wave，在它挂起期间无法同时做有意义的向量工作。跨 wavefront 的重叠是可能的，但必须在软件里用显式 wavefront 屏障编排，更脆弱，也更吃 wave 槽和寄存器。

这有多要紧取决于工作负载。纯稠密 GEMM（DGEMM，大批量训练的内层循环）在 matmul 期间没有有用的事可做；两种引擎都能饱和；异步几乎不买什么。这恰恰是 AMD 在超算 HPC 上历史性领先的工作负载（MI250X 的 Frontier、MI300A 的 El Capitan）。Transformer 注意力（FlashAttention-3、FA4）把 matmul 与 softmax、mask、KV-cache 读取交织，异步重叠正是那些 kernel 的整个结构。AMD 必须手工重建流水线，落后于 NVIDIA 的硬件级支持。MoE 派发、分页注意力、投机解码也属于同一阵营：地址不规则的工作，想和 matmul 并行跑。

NVIDIA 的矩阵指令抽象几代间走得很远（warp → warp 组 → 单线程异步 + 簇），AMD 没有跟上。

#### 内存

AMD 的内存层级比 NVIDIA 少几层通用层，但有一颗 NVIDIA 完全没有的巨型缓存。从 CU 向外：64 KB LDS 暂存（软件管理、32 bank，AMD 版 SMEM）、一个向量 L1（早期 CDNA 16 KB，MI300X 起 32 KB）、每 XCD 几 MB 的 L2。L2 在 XCD 之间不一致；一致性发生在 L2 之上的一层。

那一层是 Infinity Cache：MI300X 上 256 MB，分布在四颗 IOD 上，16 路组相联，实测约 12 TB/s——是 MI300X 5.3 TB/s HBM3 的两倍多。它起源于 RDNA 游戏 GPU，用来补偿窄 GDDR 总线；AMD 在 CDNA 3 上把这块 IP 复用到 AI——注意力 KV 复用和权重复用恰好特别适合一个大 LLC。NVIDIA 押更大的 HBM 带宽（B200 上 8 TB/s，Rubin 上随 HBM4 继续涨），AMD 押缓存。

片外，HBM 容量激进增长：MI100 / MI210 / MI250X / MI300X / MI325X / MI350X 一路 32 → 64 → 128 → 192 → 256 → 288 GB，从 2021 年起每一代都追平或超过当代 NVIDIA 旗舰。赌注是：推理工作负载越来越容量受限，内存更大的芯片赢。

#### 数值格式

格式轨迹与 AI 硅圈共享的精度减半模式一致：FP32 → FP16 → FP8 → FP4，每一步用更细粒度的缩放把精度找回来。AMD 特有的轴是开放性。CDNA 4 的 FP4 和 FP6 用 OCP MX 块缩放乘法：与 Blackwell 的 MXFP4 和 TPU v8 的 MXU 相同的数值格式，但由一个开放联盟（AMD、NVIDIA、Intel、Meta、Microsoft、Qualcomm、ARM——AMD 是共同发起方）规定，而不是任何单一厂商。MI355X 里出货的格式与 B200 和 TPU v8 里出货的完全相同。

CDNA 4 的拐点值得单独一行：每 CU FP64 吞吐减半。MI300X 同时服务训练、HPC 和推理；MI355X 首先是 AI 芯片。那个把 Frontier 抬起来的全速率 FP64 矩阵赌注没有被杀，但不再扛重担了。

#### 芯粒

封装是 CDNA 看起来不再像 NVIDIA、开始变成别的东西的地方。

CDNA 1 的 MI100 是单芯片 7 nm。CDNA 2 的 MI250X 是 AMD 第一块多芯片 GPU：两颗 Aldebaran GCD 并排坐在 2.5D EFB 有机基板上，由 4 条封装内 Infinity Fabric 链路以 400 GB/s 聚合带宽相连，但对软件呈现为两颗独立 GPU。

CDNA 3 是改变一切的一步。八颗 XCD（TSMC N5，各约 115 mm²）通过 TSMC SoIC 混合键合（亚微米间距 TSV，无微凸块）3D 堆叠到下方的四颗 I/O die（TSMC N6）上。IOD 承载 Infinity Cache、HBM3 PHY、Infinity Fabric 链路和 PCIe Gen 5；每颗 IOD 上方托管两颗 XCD，旁边两组 HBM 堆栈。四颗 IOD 由 Infinity Fabric AP 以 4.8 TB/s 对分带宽缝合，所以这个 1530 亿晶体管的封装对 kernel 呈现为一块 GPU：缓存和地址空间在 IOD 层统一。NVIDIA 到 H100 仍是单芯片，只在 B200 上通过 2.5D CoWoS-L 走到两颗受光罩限制的 die。AMD 提前一代、以更小的单 die 面积到达 3D 堆叠：在同一个封装前沿押了不同的注。

MI300A APU 把赌注推得更远。把 8 颗 XCD 中的 2 颗换成三颗 Zen 4 CCD，HBM、Infinity Cache 和 IOD 保持原样，让 CPU 和 GPU 共享一个由 HBM3 支撑、硬件一致的物理地址空间。没有主机-设备拷贝。没有固定内存。路径上没有 PCIe。Zen 4 核和 CDNA 3 XCD 读同一个页面。NVIDIA 的 Grace-Hopper 用 NVLink-C2C 桥接两个封装；MI300A 是一个。El Capitan（11,039 个节点，每节点 4× MI300A）就是证明它的部署。

CDNA 4 的 MI355X 上，八颗 XCD 仍通过 SoIC 3D 堆叠到下方基 die 上，但 XCD 迁到 TSMC N3P，各带 32 个活跃 CU（共 256 个，对比 MI300X 的 304；每 XCD 数量下调，把面积让给更大的 Matrix Core 和 160 KB LDS）。MI300X 的四颗 IOD 塌缩成两颗，各在 TSMC N6 上加倍宽，上方托管四颗 XCD、旁边四组 HBM3E 堆栈。每颗 IOD 现在自带 256 MB Infinity Cache 的 128 MB 切片、一半 HBM PHY、自己那份 Infinity Fabric 链路和 PCIe Gen 5。两颗 IOD 间的 Infinity Fabric AP 以 5.5 TB/s 对分带宽运行（比 CDNA 3 高约 15%），八组堆栈换 12-Hi HBM3E，同样引脚数下 288 GB @ 8 TB/s，容量比 MI300X 多 50%。封装总计 1850 亿晶体管，对 kernel 仍呈现为一块 GPU。

#### 赌注

• 赌注 1：先 HPC 后 AI。HPC 和 AI 在分道扬镳前是同一个赌注：CDNA 2 到 CDNA 3 全速率 FP64 矩阵，CDNA 4 上等推理经济学明确偏向低精度再分叉。
• 赌注 2：内存容量。自 2021 年起每一代都在 HBM 容量上追平或超过当代 NVIDIA 旗舰，再加一块 256 MB 末级 Infinity Cache，吸收 H100 必须去 HBM 才能拿到的复用。
• 赌注 3：抢先 3D 堆叠。在 NVIDIA 之前把计算 3D 堆叠到缓存和 I/O 上：2023 年 TSMC SoIC 混合键合 XCD-on-IOD，而 NVIDIA 到 2025 年仍保持单芯片。
• 赌注 4：一致性 CPU+GPU。MI300A APU 是史上最激进的芯粒产品，El Capitan 部署就是证明。
• 赌注 5：开放的 scale-up 网络。用 UALink 和 OCP MX 对阵 NVLink 和私有 FP4。

扩展

内存赌注有个扩展后果：8 颗 MI300X 装 1.5 TB HBM、8 颗 MI350X 装 2.3 TB 时，一个 405B 参数模型可以 FP8 塞进单台 8-GPU 机器（权重、KV cache，还有长上下文和大批量的余量），而同样的模型在 8× H100（640 GB）上需要小心翼翼分片。对 2024–2025 年的推理负载，AMD 的 scale-up 不必在机柜级匹配 NVL72 就能在单机级有竞争力。对前沿训练，它必须——而 AMD 直到 2026 年才有答案。

#### Scale-up

到 MI355X 为止，AMD 的 scale-up 是 8-GPU OAM 平台跑在 Infinity Fabric 上。每颗 MI300X 有 7 条 IF 链路（一条到机箱内每个对端）@ 128 GB/s 双向，在完全连接的全对全拓扑里给出每 GPU 896 GB/s 的网状带宽。MI350X 把每条链路提到 153.6 GB/s（每 GPU 约 1,075 GB/s），但保持 8-GPU 形状。平台符合 OCP UBB 2.0：与 NVIDIA HGX 基板相同的机械插座，服务器厂商能在同一机箱里装 AMD 或 NVIDIA，不用重新设计系统。

AMD 到 MI355X 都没有出货 NVL72 那样的机柜级产品。在 MI300X 集群上跑更大模型的客户，靠以太网跨多台 8-GPU 机器扩展，为 NVIDIA 用户可以留在 scale-up 内的东西付 scale-out 延迟。这是训练要紧的缺口，也是 Helios 要补的缺口。

Helios 是 AMD 第一个机柜级 scale-up 域，2026 下半年随 MI455X 出货。每机柜 72 颗 GPU、约 31 TB HBM4、1.4 PB/s 聚合 HBM 带宽、2.9 ExaFLOPS FP4 / 1.4 ExaFLOPS FP8、260 TB/s scale-up 带宽、43 TB/s scale-out。形态是 Open Rack Wide（ORW）（Meta 2025 年的 OCP 提交，双宽、液冷），不是 AMD 私有机箱。在 Meta 参考设计之上构建而不是从零设计机柜，是 AMD 故意的赌注：任何在 ORW 上标准化的超大规模厂商都能部署 Helios，不需要定制数据中心设施工程。

网络是 UALink：Ultra Accelerator Link，AMD 与 Apple、AWS、Cisco、Google、HPE、Intel、Meta、Microsoft、Synopsys 共同发起的开放联盟标准。UALink 200G 1.0（2025 年 4 月）定义 200 GT/s lane 和每方向 800 Gbps，交换拓扑可扩展到每个 pod 1,024 个加速器。承诺是一种堪比 NVLink 但无人拥有的缓存一致互连：任何厂商都能造 UALink 交换机，任何加速器都能讲 UALink，标准属于联盟而不是最强的卖家。

代价：原生 UALink 交换硅要到 2027 年才量产。Astera Labs 的 Scorpio，加上 Auradine、Enfabrica、Xconn 的竞品，都瞄准 2026 年底 / 2027 年部署。Helios 发布时用 UALoE（Infinity Fabric 隧穿标准以太网）过渡，在等原生 UALink 网络的同时保住编程模型。原生 UALink 交换随 MI500 于 2027 年到来。发布时的 Helios，更接近一个快速的以太网隧穿一致集群，而非 NVL72 那种真正的缓存一致 NVLink 域：时间线上实实在在的让步，换来 2026 下半年拿出一个有竞争力的产品。

#### Scale-out

AMD 不出货 InfiniBand。整个 scale-out 栈是以太网，锚定在另一个开放标准上：超以太网联盟（UEC）。

UEC 1.0（2025 年 6 月发布）定义了 Ultra Ethernet Transport（UET）：标准以太网之上一种新的 RDMA 传输，带包喷洒、基于 SACK 的选择性重传和现代拥塞控制。UET 不是 RoCEv2（把 InfiniBand 传输封装进以太网帧）；是为 scale-out AI 网络对 RDMA 语义做的一次干净重设计。AMD 与 Broadcom、Cisco、Meta、Microsoft 同为创始成员。与 UALink 同一套打法：拥有标准，而不是实现。

NIC 是 Pensando——AMD 2022 年收购的网络初创公司。Pollara 400 是当前 AI NIC：400 GbE、P4 可编程、UEC 就绪、PCIe Gen 5，配 MI300X / MI355X。Vulcano 800 于 2026 年随 MI455X 出货：UEC 1.0 合规、PCIe Gen 6、原生 UALink 接口，每 GPU scale-out 带宽是 Pollara 的 8 倍。Salina 400 是前端 DPU（16× Arm Neoverse-N1、双 400 GbE），管存储 / SDN / 防火墙，相当于 NVIDIA 的 BlueField，与 AI 后端 NIC 区分开。

但交换硅不是 AMD 的。Helios 43 TB/s 的 scale-out 网络穿过 Broadcom Tomahawk 6：一颗 102.4 Tbps 以太网交换 ASIC，带共封装光学（「Davisson」）。AMD 没有自研 CPO、没有自研交换 ASIC；光学层是伙伴硅。NVIDIA 拥有整条栈：InfiniBand、Spectrum-X 以太网、ConnectX、BlueField、Quantum-X Photonics CPO，全部自研。AMD 只拥有一个层级（通过 Pensando 的 NIC + DPU），赌的是开放标准加上同类最佳的伙伴硅能跑赢垂直整合。

行业已经在朝 AMD 的方向走。Dell'Oro 报告 2025 年以太网处理的 AI scale-out 网络流量是 InfiniBand 的两倍多；AWS、Microsoft、Meta、Oracle、xAI 都为基于 AMD 的 AI 集群标准化了以太网。剩下的问题不是以太网能否在 RDMA 语义上匹配 InfiniBand（UEC 补上了这个差距），而是 Helios 能否尽快补上与 NVL72 的机柜级差距，去赢那些今天默认 NVIDIA 的前沿训练负载。

#### 软件

ROCm 是 CUDA 的开源对应物。NVIDIA 的栈是私有且垂直整合的（cuBLAS、cuDNN、TensorRT-LLM 以二进制 blob 形态出货，只由 NVIDIA 维护），ROCm 则是 GitHub 原生，押开放标准（PyTorch、Triton、vLLM、OCP MX）而不是围墙花园式库集。与 NVIDIA 的软件差距是真实的，但 AMD 的策略是通过开源社区去补，而不是从零再造一套平行的 CUDA 栈。

栈底是 HIP，AMD 的 CUDA 兼容 C++ 运行时。hipify 自动把 CUDA 源码翻译成 HIP。批量 HPC 代码（HACC、Laghos、QMCPack）开箱即用移植率 80–95%：CORAL-2 的数字。现代 AI kernel 移植得差：任何够到 Hopper 或 Blackwell 专用原语（TMA 描述符、wgmma、tcgen05.mma）的东西在 ROCm 里都没有干净的对等物，必须手工重写。

HIP 之上是一层按名字一一镜像 NVIDIA 的库：rocBLAS 对应 cuBLAS；hipBLASLt 对应 cuBLASLt；MIOpen 对应 cuDNN；RCCL 对应 NCCL；Composable Kernel（及其现代 ck-tile DSL）对应 CUTLASS；rocprofv3 / rocprof-sys / rocprof-compute 对应 Nsight 家族。不过没有 TensorRT-LLM 的第一方对等物。AMD 的答案是支持 vLLM 作为开源服务引擎，并出货插进它的 AMD 专用算子（AITER）；为 vLLM 专门建的 ROCm CI 在 2026 年初把测试通过率从 37% 提到 93%。

PyTorch 路径是一等公民。Eager 模式 PyTorch 自 2018 年起跑在 ROCm 上；torch.compile 经 Triton 降级，Triton 的 ROCm 后端（AOTriton 做预编译数学 kernel）已上游。没有 XLA 式中间 IR；ROCm 直接编译到 HIP / Triton / CK。随着 Triton 成为 PyTorch 的默认 kernel 路径，大量移植成本蒸发：一个走 torch.compile 的 kernel 在 CUDA 和 ROCm 上无需改源码就能跑。这是 AMD 开放策略底下的架构赌注：Triton 的 Python DSL 成为跨厂商通用语，绕过对 CUDA 等价 kernel 生态的需求。

FlashAttention 是承重墙案例。FA2 通过 Composable Kernel 在 MI300X 上生产可用；PyTorch 在 ROCm 上默认用 CK 或 AOTriton。FA3（Hopper 调优）通过 AITER + CK 部分支持，但 Dao-AILab 的权威实现仍只支持 CUDA。FA4（Blackwell，2026 年 3 月）在 ROCm 上完全没有移植。HipKittens——Hazy Research 对 ThunderKittens 的 MI355X 移植（2025 年 11 月）——声称约 500 行就达到手工调优 AITER 的前向对等。模式是：开源学术 kernel 在 NVIDIA 之后几个月——而不是几年——补上 AMD 的尾巴。

生产部署验证了这个策略。Microsoft Azure 的 ND MI300X v5 实例 2024 年 5 月 GA；OpenAI 在上面跑 GPT 推理。Meta 通过 Grand Teton 平台在 MI300X 上出货 Llama 3 / Llama 4 推理。Oracle OCI 的 BM.GPU.MI300X.8 2024 年 9 月 GA，MI355X 2026 年跟进。这些是超大规模级别的真实服务集群，不是试点。

诚实的差距仍然真实。独立基准（Phoronix，2026 年 3 月）把 ROCm 7.2 放在标准 PyTorch / vLLM / SGLang 负载上比等价 CUDA 慢 10–25%，同精度同硅。ROCm 7 达到特性对等，但没有性能对等。FlashAttention-4 的尾巴（利用 Blackwell 最新原语的研究代码）是 NVIDIA 护城河最持久的地方；它在 ROCm 里没有干净对等物，要等手写 AITER kernel 或 HipKittens 级社区移植。NVIDIA 把工程师嵌进前沿实验室；AMD 通过 GitHub 出货 kernel。两种策略在常见负载上收敛（Llama 推理、注意力、稠密 transformer 训练），但新颖研究代码的长尾仍然让 MI300X / MI355X 部署付出 NVIDIA 用户不用付的工程时间。

Cerebras WSE

Cerebras 造的是史上最大的芯片。它的哲学：内存墙是切晶圆造成的。晶圆厂在一张 300 mm 的硅上印出几十颗 die，然后锯开；行业随后用最离奇的工程（HBM、NVLink、CoWoS、每机柜 5,184 根铜缆）以片上带宽的一个零头把碎片重新接起来。Cerebras 跳过了锯。晶圆级引擎（Wafer-Scale Engine）是一整块硅：84 个光罩场、46,225 mm²、900,000 个数据流核心，片上每一字节内存都是 SRAM，离计算单元一个周期。

谱系

2019 — WSE-1（CS-1）：第一块出货的晶圆级处理器：1.2 万亿晶体管、400,000 核心、18 GB 片上 SRAM。 2021 — WSE-2（CS-2）：7 nm：850,000 核心、40 GB SRAM。权重流式（weight streaming）把权重移出晶圆，放进 MemoryX。 2023 — Condor Galaxy（CG-1）：与 G42 共建的 64 系统集群；训练了 Jais 阿拉伯语 LLM 家族。 2024 — WSE-3（CS-3）：5 nm：4 万亿晶体管、900,000 核心、44 GB SRAM；每核 FP16 SIMD 翻倍到 8 宽；集群规格到 2,048 个系统。 2024 — 推理：权重驻留在 SRAM 而不是流式传输：业界最快的独立实测 decode，也是如今定义这家公司的转向。

架构

GPU 是一个层级：线程在 warp 里、warp 在 SM 里、die 在封装里、封装在机柜里，每层边界都有自己的带宽、延迟和编程构造；任何由 die 拼起来的加速器都继承了某个版本的它。WSE 是一个平面：900,000 颗完全相同的核心在 2D 网格里边对边平铺，没有共享缓存、没有全局内存、一颗核心与其它 899,999 颗之间没有任何边界。每颗核心都很小，WSE-2 上约 38,000 µm²，大约一半 SRAM 一半逻辑，峰值 30 mW：48 kB 本地 SRAM、十六个通用寄存器、六级流水线、一个 4 宽 FP16 FMAC SIMD（WSE-3 上 8 宽）、一个五端口路由器进网络。执行是数据流：核心闲着直到一个小波（wavelet）到达，小波里的控制位选择触发哪个 handler 任务，八个硬件微线程随着张量操作数到达和排空逐周期切换。没有 warp、没有 warp 调度器、没有可未命中的缓存、没有重排缓冲：数据到达就是调度。

#### 晶圆

步进光刻机一次曝光一个光罩场，每发约 850 mm²，这就是为什么每颗传统芯片都活在那个天花板下（也是为什么 B200 一碰到它就变成两颗 die）。Cerebras 像 TSMC 的任何其它客户一样，把同一颗约 550 mm² 的 die 印 84 次，排成 12×7 网格，然后——用与 TSMC 共同开发的工艺——在锯条通常要走的小于 1 mm 划片线上铺额外的高层金属。网格以源同步并行接口（WSE-3 上每 die 2,880 GB/s）跨过每条接缝，整层 die 间互连只花约 97 W。对软件而言接缝不存在：一个统一网格、一颗芯片。

晶圆级以前试过，死在良率上：单芯片晶圆计算机里一个缺陷毁掉整张晶圆，这正是 1980 年代埋葬这个想法的原因。Cerebras 的答案是粒度。H100 上一个缺陷废掉整颗约 6 mm² 的 SM；WSE 上同样的缺陷只废掉一颗 0.05 mm² 的核心。WSE-3 制造约 970,000 颗核心，出货 900,000：约 7% 的备件池，加上冗余网络链路，让硬件能绕过每个缺陷重映射，恢复完整逻辑网格。

#### 核心

这颗核心不寻常的地方不是数据通路；是一条指令是什么。十六个通用寄存器旁边坐着 44 个数据结构寄存器（DSR），每个持有张量描述符：基址、范围、步长，最多四维。指令用 DSR 命名操作数，所以一条 FMAC 指令说「把到达的流乘上这个驻留张量，累加进那个」，硬件就按张量持续的长度流式搬元素。乘法周围没有软件循环，没有逐元素取指；循环住在描述符里。NVIDIA 花了五代 Tensor Core 把 matmul 走成一条描述符驱动命令；在 WSE 核心上，张量指令没有别的形态。

定序是网络的工作。色（color）是一条静态路由的虚拟通道，编译期绑定一个 handler 任务，所以在一条色上发一个小波就是在调用目标核心上的代码：16 位控制位是调用，16 位数据位是参数。任务调度器把在途张量操作放在核心的八个微线程上，按操作数可用性每周期切换。这与 warp 调度器用 64 个驻留 warp 干的藏停顿是同一份工作，用八个上下文做完——因为要藏的延迟是忙碌的 SRAM bank 或邻居一跳，不是一次 HBM 往返。

48 kB 本地 SRAM 是为数据通路而不是局部性组织的：八个单端口 6 kB bank 每周期提供两次 64 位读和一次 64 位写——正好两个 4 元素 FP16 操作数进、一个结果出，即 WSE-2 FMAC 的宽度。一块 256 字节软件管理缓存（WSE-3 上 512 B）把最热的值留在流水线旁。这就是这台机器论点的微缩版：每颗核心，内存带宽与计算精确匹配，晶圆把这份平衡复制 900,000 次。

#### 计算

晶圆上没有矩阵单元。NVIDIA、Google、AMD 都把 FLOPs 集中在一颗专用 matmul 引擎里（Tensor Core、MXU、Matrix Core），区别主要在怎么喂它；Cerebras 用网络拼出 matmul。一个 GEMM 跑成一场晶圆级编舞：每个到达的权重沿着一行持有激活的核心广播，每颗核心对它的驻留切片做一次乘加（每个权重一次 AXPY），部分和穿过网格归约。Tensor Core 从寄存器分块得到的、MXU 从布线得到的数据复用，WSE 从几何得到：激活从不移动，所以唯一在飞的 operand 就是正在被乘的那个。

FLOPs 账本要小心，因为 Cerebras 印的那个数不是该拿来比的数。WSE-3 头版头条的 125 PFLOPS 是稀疏 FP16：它假设硬件约 8 倍的跳零收益作用在理想稀疏张量上。稠密约 15.8 PFLOPS FP16（推算：900,000 核心 × 8 宽 FMAC × 1.1 GHz；Cerebras 没有公布官方稠密数字）。这是真实算力，但不是重点：每瓦稠密 FLOPs 上，晶圆输给每一块当代 GPU。晶圆从来不是 FLOPs 机器。它是带宽机器，FLOPs 只是跟上 SRAM 的手段。

跳零是数据流挣饭钱的地方。因为计算由到达的数据触发，零永远不会触发任何东西：零在发送端就被滤掉，接收核心永远看不到它，也永远不花那个周期。这是非结构化、元素级粒度的稀疏——NVIDIA 的 2:4 结构化稀疏只是它的采样。它也是迄今为止一个没被行使的选项。Cerebras 自己的稀疏预训练结果（SPDF：1.3B 参数 75% 稀疏；6.7B 的后续）是厂商自己写的、低于 7B，而且没有披露任何旗舰客户模型做过稀疏训练：Jais 2——这台机器上跑过最大的模型——是稠密的。唯一能收割非结构化稀疏的硅，还没有出货一个用它的大模型。

#### 内存

层级只有一层：44 GB SRAM 切成 48 kB 的片，住在核心里面，晶圆上别无他物。没有 HBM、没有 L2、没有驱逐策略；每个字节离 FMAC 一个周期。引用的带宽是 21 PB/s，这个数字值得它的旗帜：它是 900,000 个本地 SRAM 端口之和，一个片上聚合数，不是点对点链路，不能与 HBM 数字相比。诚实的比较是每 FLOP 字节数：晶圆能喂约每稠密 FP16 FLOP 1.3 字节，而 B200 从 HBM 只能拿约 0.002。在这个轴上每一块 GPU 和 TPU 都饿着；WSE 是唯一一台平衡的机器。Decode——那个纯带宽问题的阶段（每 token 完整读一遍权重）——正是晶圆为之而生的阶段。

层级另一面是它的边缘。晶圆与外界的一切连接是 12×100 GbE：1.2 Tb/s，比一块 Blackwell GPU 上那颗单独的 ConnectX-8 NIC 大不了多少。片上 SRAM 与片外以太网之间隔着五个数量级。NVIDIA 的层级逐级下降，每一层比上一层慢几倍；WSE 有两层，中间是一道悬崖。晶圆是一座岛，而岛的超能力和它的牢笼是同一个事实。

而且这座岛不再长大。SRAM 密度在先进节点上实际上停止缩放：WSE-3 比 WSE-2 只多带 10% 的 SRAM，尽管整整缩了一个节点、晶体管数涨了 54%。逻辑继续缩小；六晶体管 SRAM 单元不缩。这个架构最稀缺的资源，恰恰是下一个工艺节点不再能买到的东西。

#### 权重流式

在晶圆上训练把每个人都习以为常的流向倒过来：GPU 或 TPU 上权重驻留、激活流过；WSE 上激活驻留、权重流过。主权重住在 MemoryX——集群旁边一台 DRAM 加闪存设备里。逐层地，权重流过晶圆，对着钉在 SRAM 里的激活触发乘加，然后离开；梯度在反向传播时流回来，优化器 step 在 MemoryX 里的 CPU 上跑（一次权重更新是 O(参数) 的逐元素工作、没有复用，所以 CPU 级计算跟得上）。晶圆从不存权重，「一刻也不存」（Cerebras 的原话）。模型大小由 MemoryX 限定，而不是 44 GB；44 GB 限定的是激活和批量。

这买来的是编程模型。一张晶圆装得下一整层的激活，所以没有张量并行、没有流水线并行、没有 FSDP 分片：70B 模型写成单设备程序，多系统扩展就是通过 SwarmX 的纯数据并行——一棵广播/归约树，把一份权重流扇出到 N 张晶圆，返回路上求和它们的梯度。统治 GPU 训练的并行策略电子表格，在 Cerebras 这里根本没有那一页。

代价是规模，按市场自己显露的偏好。规格书写着 2,048 台 CS-3；史上披露过最大的集群是 64 台（Condor Galaxy 3）。该平台上披露过最大的从零训练模型是 Jais 2，70B 参数、2.6 万亿 token，由锚定客户 G42 在 Cerebras 工程师嵌入下训练。CS-1 问世七年，没有任何人做出 70B 以上的东西。而且利用率（MFU）——GPU 实验室随手就公布 35–45% 的那个数字——Cerebras 从未为任何一次运行披露过。

#### 数值格式

数值格式一句话讲完：FP16 和 BF16 配 FP32 累加，外加（从 WSE-3 起）一条 16 宽 8 位整数路径，Hot Chips 披露里称其为定点。没有 FP8、没有 FP4、没有微缩放。别的厂商每一代都把精度减半、再用块缩放把精度买回来的时候，Cerebras 仍用 16 位计算，并把它当质量差异点来营销（「最初的 16 位权重」）。张力显而易见：SRAM 容量是这个架构最稀缺的资源，8 位权重会让一个模型需要的晶圆数减半。16 位到底是一份数值信念还是数据通路路线图的缺口，是个开放问题；没有任何 Cerebras 一手资料显示晶圆上有浮点 8 位。

#### 赌注

• 赌注 1：不切晶圆。die 边界是行业其余人交的税：SerDes、中介层、HBM 堆栈、线缆、交换机。用金属缝起 84 个光罩场，对手系统里最高带宽的那道边界就根本不存在。
• 赌注 2：SRAM 是唯一的内存。以行业里最陡的比率拿容量换带宽：44 GB、片上聚合 21 PB/s。平衡整台机器，而不是用层级把不平衡藏起来。
• 赌注 3：数据流核心，没有矩阵单元。900,000 颗由到达小波触发的小核心，matmul 由广播、FMAC 和网格归约拼成：跳过零是免费的，而不是一种特殊模式。
• 赌注 4：权重动，激活不动。权重流式把模型大小（MemoryX）与晶圆内存（44 GB）解耦，把集群扩展塌缩成纯数据并行。
• 赌注 5：卖延迟，不卖吞吐。晶圆每 token 重读整个模型的速度快过任何基于 HBM 的东西；把这种速度当作溢价产品定价，而不是按每 token 成本去竞争。

扩展

Scale-up 和 scale-out 在这里含义不同。NVIDIA 的 scale-up 问题（让 72 个封装表现得像一台设备）在 WSE 上由光刻解决：一致域从晶圆厂出厂时就是一整块。剩下的是一切越过晶圆边缘的东西，而没有任何机器比它更早、更狠地撞上自己的边缘。

#### Scale-up

晶圆的内部网络没有 SerDes、没有线缆、没有收发器，每条链路边际成本为零：路由是编译出来的，每一跳一个周期，广播是网络的原生原语而不是交换机特性。NVL72 花 5,184 根铜缆和一托盘 NVSwitch ASIC 给 72 颗 GPU 130 TB/s 全对全，WSE 的等价域是一个单一光刻对象。代价是域大小是个常数。NVIDIA 的 scale-up 域每代都在长大（三年间 NVL72 到 NVL576）；晶圆自 2019 年起一直是 46,225 mm²，以后也是。300 mm 是行业跑的最大晶圆（450 mm 过渡十年前就死了），所以 Cerebras 的 scale-up 路线图就是下一个节点在密度上能挤出什么：面积上没有更多可拿的了。

#### Scale-out

训练 scale-out 是 SwarmX，它只做一件事：复制。把权重流广播到 N 张晶圆，返回路径归约它们的梯度；批量随系统数增长，模型大小不增长。宣称的 2,048 系统上限（「256 exaFLOPS」，稀疏）从没建起来过；64 建过。

推理彻底放弃权重流式；算术是致命的。从 MemoryX 为每个解码 token 流式搬一个 70B 模型的 140 GB——走约 150 GB/s 的管道——每 token 大概要花一秒。所以推理把权重驻留在 SRAM，把模型按层边界分片到多张晶圆：Llama 70B 在「最少四台」CS-3 上，经以太网做流水线并行，每加一张晶圆多出 44 GB 的权重加 KV 容量和 23 kW 负载。

速度是真的，而且是独立验证的。Artificial Analysis 在 2024 年 8 月发布时实测 Llama 3.1 8B 1,850 token/s、70B 446 token/s，Llama 405B 969 token/s（240 ms 到首 token），2025 年 Llama 4 Maverick 2,522 token/s——当时最佳已公布 Blackwell 数字的约 2.4 倍。厂商引用的峰值更高（70B 投机解码 2,100；GPT-OSS-120B 3,000，而实时独立实测更接近 2,000）。按单用户 decode 速度，没有 GPU 供应商能接近。

经济账是刀刃。每张晶圆 44 GB 意味着前沿规模模型要吃掉整个机群：SemiAnalysis 估计一个 1.6T 参数级模型要约 24 台 CS-3——同样规模在 GPU 机柜里几柜就装下——每台系统分析师估计物料成本约 45 万美元，标价约 2–3 百万美元（从未官方披露）。decode 期间晶圆巨大的 FLOPs 大多闲置；Cerebras 拒绝披露批量大小，也从未公布每系统吞吐。同一批开源模型的每 token API 定价大约是 GPU 提供商的 3–5 倍，Llama 405B 悄悄从 API 下架，SemiAnalysis 读作服务经济账没算平。固定 SRAM 还给上下文定了价：KV cache 与权重挤在同一个 44 GB 里，长上下文偷走容量、逼每个副本用更多系统；API 上限 131K token，而前沿提供商服务 256K–1M。MoE 被服务着（Qwen3-235B 约 1,500 token/s，厂商引用），但它是这种格式的最坏情况：巨大的参数足迹、一次只碰几个专家，却放在最贵的内存里。

市场已经诚实地定价了这一切。Mistral 的 Le Chat（约 1,100 token/s）、Perplexity Sonar 和 Meta 的 Llama API 都为这份延迟付钱；2026 年 1 月 OpenAI 签下 2028 年前 750 MW 的 CS-3 容量，签约时报道超过 100 亿美元、此后涨过 200 亿——晶圆级收到过的最大背书。这份容量上出货的第一个旗舰是 GPT-5.6 Sol，2026 年 7 月发布，引用速度 750 token/s。

#### 软件

栈和 TPU 一样编译器驱动，但通过一个窄得多的孔径：Cerebras 编译器是一个 kernel 匹配器，不是通用代码生成器。cerebras.pytorch 通过惰性张量把训练 step 跟踪进 Torch-MLIR 和图 IR，然后把子图对手写 kernel 库做匹配，没有匹配的算子回退到更慢的自动生成 kernel。文档化的约束按 GPU 标准看是刺眼的：只支持静态图、无动态形状、无依赖数据的控制流、step 中途无 eager 张量访问，PyTorch 版本钉在上游后面。最好的独立实践者报告（SURF，荷兰国家计算中心）提到不支持的层类型，标准 PyTorch 代码没有 1:1 移植路径。

而且没有 kernel 逃生门。CUDA 对新注意力变体的回答是写个 kernel；TPU 的回答是 Pallas；ROCm 是 Triton。Cerebras 的 ML 栈根本没有用户 kernel 路径：匹配器严重失配时，修复方案是一位 Cerebras 工程师。一个独立的 SDK 语言 CSL 暴露原始机器（任务、小波、色），产出过惊人的 HPC 结果（TotalEnergies 一个 stencil 代码约 A100 的 228 倍，48 台 CS-2 上的 Gordon Bell 决赛入围），但那是另一个世界，与 PyTorch 流程不相连。平台上的每个旗舰模型（Jais、BTLM、Med42）都是与嵌入的 Cerebras 员工共同开发的。

这里面有一种奇怪的免疫力。FlashAttention——GPU 时代定义性的 kernel 谱系——是一种把注意力分块穿过内存层级的方案，而 WSE 没有可供分块的层级：让 AMD 付出多年移植滞后的那一整类优化，在这里根本不适用。但免疫力与贫瘠是同一个事实。在 CUDA 上复利的第三方 kernel 生态，在这里没有可附着的表面；这个平台历史上每一次 kernel 改进都只有一个作者。

那晶圆剩下什么位置？守住一个真实的利基，赢得堂堂正正：batch-1 decode 速度，独立验证，由把延迟看得比成本重的客户买单。利基周围是高墙：每 token 3–5 倍定价、七年 70B 训练天花板、2025 年收入仍约 86% 集中在两个阿布扎比关联客户（据其 2026 年 5 月 IPO 的 S-1 文件），以及最稀缺的资源——SRAM 密度——在模型持续长大的同时停止缩放。Hennessy 和 Patterson 预言了寒武纪爆发；WSE 是其中最极端的身体方案，那个认定内存墙是一个封装选择、并花 46,225 mm² 硅拒绝承认它的方案。

AWS Trainium

Annapurna Labs——AWS Nitro 网卡和 Graviton CPU 背后的团队——把 Trainium 做成一个快速追随者。计算核心直接采用 TPU 验证过的剧本（128×128 权重驻留脉动阵列、软件管理暂存、全程序编译），甚至直接共享 Google 的 XLA 编译器。scale-out 网络是已经承载 AWS 其余一切的 Nitro 卸载网络。真正属于亚马逊自己的东西又窄又刻意：焊在借来的核心上的专用集合通信硅，以及那种只有必须击败 AWS 内部的 NVIDIA、才能给芯片定价的垂直整合。

谱系

2015 — Annapurna Labs：亚马逊以约 3.5 亿美元收购这家以色列芯片初创公司；它成为 AWS 的自研硅团队。 2018 — Graviton + Nitro：Arm 服务器 CPU 和 DPU 卸载网络。 2019 — Inferentia（NeuronCore-v1）：AWS 第一颗 ML 芯片，仅推理：4 个 NeuronCore、8 GB DRAM、三个固定引擎。 2022 — Trainium1（Trn1、v2）：第一颗训练芯片：2 个 NeuronCore-v2、一个可编程 GPSIMD 引擎、32 GB HBM、NeuronLink 2D torus。 2023 — Inferentia2（v2）：与 Trn1 共享 NeuronCore-v2：推理与训练谱系在一个微架构上汇合。 2024 — Trainium2（Trn2、v3）：8 个 NeuronCore-v3、第一代真正的 FP8 加速、96 GB HBM3；64 芯片 UltraServer。驱动 Project Rainier。 2025 — Trainium3（Trn3、v4）：AWS 第一颗 3 nm 芯片（TSMC N3P）；OCP MXFP8/MXFP4；NeuronSwitch 全对全网络取代 torus。144 芯片 UltraServer。

架构

另一个俘虏硅故事属于 Google，而 Trainium 最好读作把 TPU 的论点在另一个云里重建。底下的赌注相同（由软件管理 SRAM 喂食的脉动阵列、编译器提前调度、没有缓存也没有线程调度器），但单元组装方式不同。一颗 Trainium 芯片带少量 NeuronCore（Trn1 上 2 个、Trn2 和 Trn3 上 8 个），每个 NeuronCore 不是一个单体 matmul 引擎，而是一簇解耦的专用引擎：一个 Tensor Engine（128×128 脉动阵列）、一个管归约的 Vector Engine、一个管逐点数学的 Scalar Engine，以及一个由八个 512 位向量处理器组成的可编程 GPSIMD Engine，装下其它三个都装不下的东西。围着它们的是搬运工：128 个 DMA 引擎、一个定序传输的 Sync Engine，以及（从 Trn2 起）专管集合通信的 CC-Core。没有 warp、没有 wavefront；引擎作为静态调度的数据流流水线运行，承重的设计决策全在脉动阵列周围，而不是阵列本身。

#### 计算

Tensor Engine 独占 matmul FLOPs；其它三个引擎独占其余一切。它是 128×128 的处理单元网格（16,384 个 MAC），权重驻留运行：一块操作数分块载入阵列并保持不动（LoadStationary），另一块流过它（MultiplyMoving），部分和落进 PSUM——一块引擎能读加写的小累加器 SRAM，所以比 128 更长的收缩沿 K 轴就地折叠。这就是每个 matmul 加速器心脏里那个分块 MMA，D = A·B + C；但 NVIDIA 把它包进 warp 层级、Google 从 VLIW 指令束发射，Trainium 把它暴露成一对对着具名暂存的显式指令。

阵列在三代里物理上固定为 128×128；变的是每个单元塞多少乘积。Trn1 的 NeuronCore-v2 跑 BF16/FP16 配 FP32 累加，FP8 只有 BF16 的速率（无加速）。Trn2 的 v3 双泵 FP8，呈现有效的 256×128 阵列——Trainium 第一代在 8 位上真正 2 倍。Trn3 的 v4 塞进微缩放操作数，呈现有效的 512×128，BF16 速率的 4 倍。物理乘加单元数从不动；数据通路只是喂给它们更窄的数。

另外三个引擎是让阵列保持忙碌的东西。Vector Engine 处理跨元素归约（layernorm、softmax、pooling）；Scalar Engine 处理一对一逐点操作（激活、GELU）；GPSIMD Engine——八个完全可编程、用 C 写的向量处理器——吸收其它引擎都映射不上的任何东西。编译得好的 step 会重叠全部四个：Tensor Engine 磨一个 matmul 的同时 Vector Engine 跑上一块的 softmax、DMA 引擎搬运下一块——与让 TPU 和 GPU 注意力 kernel 高效的同一套生产者/消费者重叠，在这里表达为独立的物理引擎，而不是独立的 warp 或 VLIW 槽。这个设计在一层能干净分解到四种引擎类型时兑现，transformer 大体如此。它在边缘付税：一个哪个专用引擎都装不下的算子掉到可编程 GPSIMD 路径，更慢，是机器上最可能卡住新架构的部分。这是每块非 GPU 加速器都背的长尾成本，Trainium 版本而已。

#### 内存

内存层级就是把计算哲学用到存储上：三层、全部软件管理、任何地方都没有硬件缓存。AWS 自己的文档画出这个对比，指出与 CPU 或 GPU 不同，NeuronCore 没有缓存，「所有内存移动在程序里都是显式的」。片外是 HBM（Trn1 上 32 GB、Trn2 上 96 GB HBM3、Trn3 上 144 GB HBM3e）。片上、离引擎最近的是 State Buffer（SBUF）：主暂存，带宽约为 HBM 的 20 倍，组织成 128 个分区，按 NeuronCore 大小 24 MiB（v2）、28 MiB（v3）、32 MiB（v4）。阵列和 SBUF 之间是 PSUM，一块 2 MiB 累加器，专供 matmul 输出。数据移动是 HBM → SBUF → Tensor Engine → PSUM → SBUF，每一跳都由编译器发出；硬件不做预取也不做驱逐。

这正是 Google 的 VMEM 赌注：一块显式暂存，编译器必须完美调度、没有任何缓存来掩盖错误——也与 NVIDIA 硬件管理的 L2 和 L1 相反。Trainium 同时继承了随之而来的天花板和脆弱性：调度对了引擎永不停顿，错了就没有兜底路径。设计跑的是慷慨的 HBM 预算配适度的峰值 FLOPs，所以按单位算力算，Trainium 比同档 NVIDIA 件带更多内存。但按绝对容量它落后：Trn2 的 96 GB 低于 H200 和 B200，Trn3 的 144 GB（2025）低于它对阵的 192 GB B200 和 288 GB B300。所以 AWS 争论大模型服务经济账时真正拉的杠杆不是内存领先，而是价格：单位算力和 HBM 的成本——用自己造、自己租的硅。

#### 数值格式

Trainium 跟着大家一样的精度减半曲线走（FP32 → BF16 → FP8 → FP4），带两个 Trainium 特有 wrinkle。第一个是可配置 FP8：不像 Hopper 那样固定 E4M3 和 E5M2，Tensor Engine 接受可调指数偏置，支持 E5M2、E4M3 和 E3M4，让编译器按张量在范围与精度之间权衡。第二个是 Trn3 的 FP4 不买任何额外吞吐：OCP MXFP4 操作数在到达阵列前被升格成 MXFP8，所以 FP4 以 FP8 速率运行，只省内存和带宽，不省算力。两代都靠行业那套精度找回技巧：Trn3 起微缩放块指数，每一代都有硬件随机舍入。唯一要怀疑的数字是稀疏峰值：AWS 头版头条的 4× FP8 数字，它自己的架构页写的是稠密 FP8 的 2 倍（4× 是相对稠密 BF16 说的），所以营销加速与数据通路并不完全一致。

#### 硅上集合通信

GPU 上没有干净对等物的那块，是集合通信核心。分布式训练和推理把很大一块墙钟时间花在集合通信上：每个梯度 step 都是一次 all-reduce，每个 MoE 层一次 all-to-all。在 GPU 上这些集合通信作为 NCCL kernel 跑在做数学的同一批 SM 上，所以通信与计算争抢同一块硅，重叠必须在软件里赢来。Trainium 把这项功能切出来做成专用硬件：Trn2 每芯片 20 个 CC-Core，直连 NeuronLink 端口，在 Tensor 和 Vector 引擎继续跑的同时执行 all-reduce、all-gather、reduce-scatter 和 all-to-all。这与 Google 做 SparseCore、Cerebras 做核外零过滤器是同一手：发现一个主引擎形状不对的工作负载，在它旁边花一点面积造一块专用块，而不是偷主核的周期。通信变成芯片并发做的一件事，而不是它停下来去做的事。

#### 赌注

• 赌注 1：云是产品，芯片是组件。Annapurna 把芯片、服务器、机柜、Nitro 网络和云 API 设计成一条栈，所以 Trainium 只需要在 AWS 内部赢在性价比上，永远不用在商用硅规格书上赢。
• 赌注 2：借用计算论点，不要重新发明。128×128 权重驻留阵列、软件管理 SBUF/PSUM 暂存、全程序编译——都是 TPU 的赌注，一直借到共享 Google 的 OpenXLA。省下的力气投进网络和机柜。
• 赌注 3：集合通信属于硅。专用 CC-Core 在硬件里把 all-reduce 和 all-to-all 与计算重叠，而不是让它们作为偷 matmul 单元 FLOPs 的 kernel 运行。
• 赌注 4：复用云自己的网络。scale-out 是带 SRD 传输的 EFA：同一套 Nitro 卸载、包喷洒的 RDMA，已经跑在 AWS 其余一切上。没有 InfiniBand。
• 赌注 5：把拓扑搬到工作负载上。Trn1 和 Trn2 抄了 TPU 的 torus；Trn3 的 NeuronSwitch 在 MoE 流量超出最近邻之后，用交换式全对全网络取代它。老实说，这是照着剧本走：先是 Google 的，现在是 NVIDIA 的。

扩展

Trainium 的扩展继承了 AWS 其余部分的分工：紧密耦合的 NeuronLink 域给必须表现得像一台的芯片，云里通用的 EFA 网络给它之外的一切。scale-up 域不是 NVLink 那种缓存一致共享内存；AWS 把 UltraServer 营销为池化的多太字节内存，但底下是点对点链路上的消息传递，精神上更接近 TPU 的 ICI，而非 NVSwitch crossbar。

#### Scale-up

NeuronLink 是 Trainium 的芯片间网络，扮演 NVIDIA 的 NVLink、TPU 的 ICI 的角色。到 Trn2 为止它把芯片织成 torus，正是 TPU 的选择：单个 trn2 实例是 16 颗芯片组成的 4×4 2D torus，每芯片约 1.28 TB/s；Trn2 UltraServer 把四个实例并成 64 颗芯片的 4×4×4 3D torus，以一个 scale-up 域呈现 83 稠密 FP8 PetaFLOPS 和约 6 TB HBM。第三条 torus 轴刻意做细（实例间环每芯片约 256 GB/s，对比实例内 1.28 TB/s），这是 torus 的招牌权衡：便宜的布线和巨大的最近邻带宽，代价是直径上的许多跳。AWS 拿 64 芯片 UltraServer 对阵 NVIDIA 的 72-GPU NVL72；聚合算力在同一量级，但 torus 不是 crossbar，两者在非最近邻流量上表现非常不同。

这个权衡正是 Trn3 放弃 torus 的原因。NeuronSwitch-v1 是一张交换式全对全网络，芯片间带宽大约翻倍，更重要的是压平了直径，任何芯片一跳到达任何其它芯片。Trn3 UltraServer 扩到 144 颗芯片，362 稠密 FP8 PetaFLOPS、20.7 TB HBM3e。动机与把 Google 推向 MoE 推理高基数拓扑的是同一个：专家路由是全对全——torus 的最坏情况——而交换机把最长跳的那对变成一次穿越。Trainium 的互连路线图是行业轨迹的一次压缩回放：工作负载还是最近邻时用 torus，不是了就用 crossbar。

#### Scale-out

Scale-out 不是定制的；它就是 AWS 已经在跑的那张网。每个 Trainium 实例带一块 Elastic Fabric Adapter NIC 进数据中心网络（每 Trn2 实例 3.2 Tbps），传输是 SRD（Scalable Reliable Datagram），卸载到 Nitro 网卡而不是跑在加速器上。SRD 是 AWS 对 RDMA 的白纸重写：不是 RoCE 或 InfiniBand 那种单一有序流，它把每条消息喷洒到最多 64 条平行路径上，可靠但乱序送达，把重组推给集合通信库，绕开单条拥塞路径会引起的队头阻塞。这是 AWS 为自己的云通用打造的传输，改作加速器网络用。

层级顶端是 UltraCluster，由 10p10u 网络（AWS 对跨数据中心约 10 petabits/s 带宽、亚 10 微秒延迟的简称）缝合，扩展到几十万颗芯片。证据点是 Project Rainier：跨多个美国数据中心约 50 万颗 Trainium2 芯片，2025 年底为 Anthropic 上线；到 2026 年初 Claude 跑在超过一百万颗芯片上——任何外部实验室对非 NVIDIA 训练平台做出的最大承诺。它存在是因为经济账端到端算得平。AWS 声称 Trainium2 比它的 Hopper 级 GPU 实例性价比高 30–40%（AWS 的数字，对的是上一代 NVIDIA 而非 Blackwell），而且因为亚马逊拥有从 Nitro 网卡到 API 的每一层，这个利差是亚马逊自己定的。

#### 软件

Trainium 的软件把「借用」说得明明白白：Neuron SDK 是一个编译器优先的栈，建在与 TPU 相同的 OpenXLA 地基上。Neuron 编译器（neuronx-cc）吃进 XLA HLO 图，降到 Neuron 运行时加载到 NeuronCore 上的 NEFF 二进制；前端 IR 是 Google 的，Google 自己的 OpenXLA 公告把 Trainium 列为与 TPU 并列的一等 PJRT 设备。torch-neuronx 通过 PyTorch/XLA 的 LazyTensor 跟踪跑 PyTorch（记录算子，在 step 边界编译图），jax-neuronx 通过 StableHLO 降 JAX。在从 kernel 驱动的 CUDA 这一极到全程序 XLA 那一极的光谱上，Trainium 几乎就压在 TPU 上面：编译器就是系统，而且大体是同一个编译器。

分歧在逃生门。XLA 独木难支，并不总能对新注意力变体或融合 MoE 派发合成最优解，所以 Neuron 出货 NKI（Neuron Kernel Interface）——一个 Python 的、分块级 kernel 语言，直接暴露四个引擎和 SBUF/PSUM 暂存。它是 Trainium 的 Pallas（或它的 Triton）：同样的分块 DSL 想法，在 kernel 的赢面在调度而非代数时，下探到全程序编译器之下。它下面是集合通信库，把 all-reduce 和 all-to-all 映射到 CC-Core 和 NeuronLink 拓扑上（NCCL 的对等物），NeuronX Distributed 提供分片训练层。

与 CUDA（甚至与 TPU 的栈）的差距是成熟度，不是设计。NKI、JAX 路径和分布式库到 2024 年底都还在 beta；移植的模型只能在 AWS 上跑，没有跨厂商兜底；vLLM 后端落后于上游项目。最清楚的迹象是锚定租户怎么干活：Anthropic 不只是通过 PyTorch 瞄准 Trainium，它跟 Annapurna 深度嵌入，自己写底层 NKI kernel，把修复上游进 Neuron 栈。Trainium 在前沿是可生产运行的，但在前沿它是联合工程，不是开箱即用：编译器是继承来的、而且很优秀，但周围生态还年轻。

Groq LPU

Groq LPU 是一台确定性机器。其它每一块芯片都在用硅容忍不确定性：缓存藏内存延迟、调度器填停顿、仲裁器解决它预测不了的争用。LPU 把它们全部删掉。剥掉每一个反应式组件（没有缓存、没有分支预测器、没有仲裁器、没有重排缓冲，甚至没有片上 crossbar），把整个调度问题交给编译器——它把每条指令、每个字节放在精确的周期上。剩下的是一块运行前就知道自身延迟的芯片。TPU 把调度搬进编译器但保留 HBM 和动态网络，Groq 则移除了最后几个非确定性的来源：内存全是 SRAM，网络也被调度，所以几百颗芯片像一份时钟精确的程序一样运行。

谱系

2016 — 创立：Jonathan Ross——从 20% 项目开始做 Google TPU 的人——离开 Google，去造一块确定性推理芯片。 2020 — TSP（GroqChip 1）：第一块硅（ISCA 2020，Think Fast）：单一功能切片核心，14 nm，没有 HBM、没有缓存。 2022 — 多处理器：ISCA 2022：软件调度网络把确定性调度扩展到几千颗芯片，经由编译出来的 Dragonfly。 2023 — Samsung 4 nm：第二代 LPU 在 Samsung SF4X 上公布；从未出货（一次报道过的失败流片）。 2024 — LPU / GroqCloud：TSP 更名为语言处理单元（Language Processing Unit）；公司从卖卡转向卖 token，凭创纪录的 decode 速度。 2025 — NVIDIA 授权：NVIDIA 获得 LPU 技术的非排他许可，并聘用 Ross 和团队大部分成员。 2026 — NVIDIA Groq 3 LPU（LP30 / LPX）：该技术以 GTC 2026 上一颗延迟协处理器的身份重现，坐在 Rubin NVL72 旁边，通过 Attention-FFN 解耦分工。

架构

其余玩家都是从一颗复制的核心构建的：把一颗 SM、TensorCore、CU 或数据流核心铺满 die，然后把工作分给副本。LPU 反着造。它拿一颗常规核心，把它拆开：指令控制、向量 ALU、矩阵单元、内存和网络各自变成一片功能切片——一列全高、彼此相同的硬件——这些列在 die 上并排站立。每片切片内部同质，跨芯片异构。数据不住在寄存器堆里等着被发射到某个单元；它像流水线上的零件一样横向流过切片，东西双向，每周期一跳寄存器，同时 VLIW 指令从控制切片向北发射去迎它。数据通路里没有任何东西在反应：编译器知道每个操作数每个周期在哪，硬件只是转时钟。流式就是它的身份：这个设计以张量流处理器（Tensor Streaming Processor，TSP）之名诞生，直到 2024 年更名为语言处理单元。

垂直轴是 SIMD 宽度。芯片 320 lane 高，组织成 20 个 16 lane 的 superlane（第 21 个是备件，为良率熔断、对软件不可见），每片切片同时对全部 320 条 lane 动作。水平轴是时间。每条 lane 有 64 个逻辑流寄存器，32 个向东、32 个向西，每个 tick 每条流沿它的方向推进一片切片，直到被消费或从 die 边缘掉出去。一片切片从经过的流里读操作数、计算、把结果写回通往下一片切片的流。die 围绕中央向量单元镜像成两个半球，所以一个值被产生一次，两边的切片都能消费。

#### 计算

LPU 保持和其它一切相同的分工——矩阵活在专用单元、其余活在向量引擎——但把两者都排成流里的切片。矩阵路径是 MXM：四个独立的 320×320 乘加平面（每个半球两个），共 409,600 个乘法器，吃 INT8 或 FP16 操作数、进 INT32 或 FP32 累加器。权重装进一个平面（全部装完不到 40 个周期），然后激活流过、乘积累加。900 MHz 下大约是 750 INT8 TOPS 和 188 FP16 TFLOPS，而且不同寻常地，这个数字不带稀疏星号：TSP 完全拒绝跳零，因为依赖数据的跳过会让执行时间依赖数据，而确定性是它唯一不肯交易的性质。

向量路径是 die 中央的 VXM：每 lane 16 个 ALU 排成 4×4 网格，5,120 个 32 位 ALU，跑激活、归一化、量化和残差相加。因为计算是空间性的而不是发射到共享单元，一个操作数可以在连续周期里穿过一串 VXM ALU 直接走进 MXM 平面，完全不碰内存：GPU kernel 手工构建的算子融合，在这里只是切片的物理顺序。第三种切片类型 SXM 处理直线流表达不了的移动：lane 移位、320-lane 置换、转置和芯片间链路都住在这里，所以跨 lane 重排数据是一等操作，而不是一趟 SRAM 往返。

#### 内存

没有 HBM、没有 DRAM、没有缓存。片上就是 MEM 切片：230 MB SRAM 分成 88 片（每半球 44 片），每个字节离计算切片一个周期，聚合约 80 TB/s。这就是整个层级：一层、平坦、软件寻址，没有任何会引入变延迟访问的驱逐、预取或一致性机制。

后果是这架构的定义性约束。230 MB 装不下一个模型。Llama-2 70B 在 FP16 下是 140 GB，所以它必须分片到几百颗芯片上，权重铺满一整柜或更多机柜的聚合 SRAM：已部署配置约 576 颗 LPU。GPU 把模型放在几颗封装里的 HBM 中、让 token 从旁边流过；LPU 把模型摊在跨集群的 SRAM 里、让 token 穿过集群。芯片数由容量而不是算力决定：权重必须装得下。这与 Cerebras 做的是同一个权衡（只有 SRAM、没有 HBM），从相反方向到达：Cerebras 保持一颗巨大 die、放弃每晶圆容量；Groq 保持常规尺寸 die、放弃在单颗芯片上装下模型的可能性。

#### 数值格式

数值格式是那条没走的路。这里其它每一家都在每代减半精度——FP16 到 FP8 到 FP4，用块缩放把精度买回来。TSP 留在 FP16 和 INT8 配 FP32 累加，从没在硅上出货 FP8 或 FP4。它唯一的数值想法是 TruePoint：一个 320 元素点积融合成单步舍入、FP32 累加，所以 FP16 乘法器阵列在归约上接近 FP32 精度（Groq 报告对 FP32 基线最大误差约 0.05%）。

16 位到底是信念还是一块从没等到低精度刷新的数据通路，很难与第二代芯片从未出货这个事实分开。SRAM 容量是这架构最稀缺的资源，8 位权重会让模型需要的芯片数减半；一台这么容量受限的机器有一切理由想要 FP8，却没在硅上得到它。这与悬在 Cerebras 16 位数据通路头上的同一个开放问题、同一种张力：最缺容量的厂商，用最宽的精度计算。

#### 确定性

其它每一台加速器都藏延迟；LPU 把延迟亮出来。ISA 携带每条指令的执行延迟，数据通路在构造上就是固定延迟，所以编译器提前算出每个结果出现的精确周期。硬件里没有任何东西能扰动这张调度表：没有可未命中的缓存、没有可卡住的仲裁器、没有可误预测的分支、没有可回卷的投机。Groq 自己的测量就是证明：24,240 次 BERT-Large 运行落在约 75 µs 的带内，编译器预测的延迟与实测差在 2% 以内。

这是 TPU 的本能（把调度搬进编译器、删掉事后质疑它的硬件）再进一步。TPU 编译器调度一颗芯片；LPU 编译器调度一个系统，因为确定性也跨网络成立。而且它与 Cerebras 正好相反——Cerebras 的核心是数据流，操作数一到就发射：WSE 对数据做出反应，LPU 按数据定时。两台机器都删掉调度器；一个用到达取代它，另一个用时钟。

#### 赌注

• 赌注 1：确定性优于容忍。删掉每一个反应式组件（缓存、仲裁器、预测器、重排缓冲），让编译器拥有每个周期。
• 赌注 2：空间性功能切片。把核心拆成切片，让操作数流过它们，于是融合就是平面图，数据复用活在导线里，而不是寄存器堆之舞。
• 赌注 3：SRAM 是唯一的内存。没有 HBM，任何容量代价都付。拿「模型上芯片」换单周期、固定延迟的访问，接受模型必须跨几百颗芯片。
• 赌注 4：网络也调度。让芯片当自己的路由器，逐周期编译通信，所以一个千芯片集群就是一份确定性程序，没有交换机、没有拥塞。
• 赌注 5：卖延迟，不卖吞吐。为 batch 1 的单用户每秒 token 数优化——GPU 最不擅长的区间——把这种速度定价为产品，而不是按每 token 成本竞争。

扩展

扩展 LPU 与这里的一切都不同，因为没有单独的 scale-up 网络要建：芯片本身就是交换机。每颗 LPU 最多带 16 条芯片间 RealScale 链路（卡上暴露 11 条），同时充当计算端点和路由器。把芯片直接互相接起来，集群就是一个无胶多处理器：没有 NIC、没有交换 ASIC、没有架顶交换机。而且因为确定性横跨这些链路，整个集群跑在一份编译期调度表上。

#### Scale-up

节点是 8 颗 LPU，完全连接：每颗芯片 7 条链路接到其它七颗，所以节点内每颗芯片到其它每一颗都是一跳。每颗芯片剩下的四条链路（跨节点 32 条）捆成一个 ISCA 论文所称的 32 端口虚拟路由器——节点进入更大网络的 uplink。没有基板交换机、没有一致地址空间；远程操作数不是被 load，而是被调度到达：由源芯片在编译器选定的周期注入，由目标在它落地的周期消费。

#### Scale-out

节点之外，节点织成 Dragonfly：9 个节点组成一个 72 芯片机柜（第九台热备，所以 64 台活跃），拓扑按规格扩展到 10,440 颗芯片，任意两颗之间少于六跳。网络是软件调度的：路由和流控移到编译期，论文的措辞直白——「被调度，而非被路由」。没有背压、没有动态仲裁，因为编译器已经证明接收方就绪；链路带前向纠错而不是重传，因为一次重试会扰动调度表。让一柜独立时钟的芯片保持锁步本身就是个问题：链路是准同步的，网络通过每 256 个周期在生成树上交换一次的硬件对齐计数器维持全局共识时间，用周期性 deskew 指令把每颗芯片重新拉回对齐。Groq 报告的回报是：8 路 all-reduce 在大张量上匹敌 A100/NVSwitch 节点、在小张量上胜过它——调度网络不用付动态网络那套握手延迟。

代价写在内存赌注的物理里。一个模型副本不是一个机箱，是一柜（或八柜）：Llama-2 70B 在约 576 颗芯片上跑，据一份分析，旁边要 144 台宿主机 CPU 和 144 TB 主机 RAM——而一台 8-GPU 服务器只要两颗 CPU。每颗芯片底下的晶圆很便宜（14 nm GlobalFoundries，据报道不到 6 千美元，对比 H100 级部件约 1.6 万美元），但你要几百颗，而且 decode 期间它们巨大的算力大多闲着，干活的是 SRAM。SemiAnalysis 说得直白：LPU 在优化延迟时赢得每 token 物料成本，一旦你批处理，按每美元吞吐算它输给 GPU 大约一个数量级。这架构不是拼成本。它拼速度。

#### 软件

编程模型是「编译器即机器」最纯粹的表达。没有 kernel。你把一个模型从 PyTorch、TensorFlow 或 ONNX 交给 Groq 编译器；它降到一个小张量算子集，静态调度每条指令、每条流、每一笔芯片间传输。没人写 wgmma 或手工调分块，因为没有可手工调优的动态硬件。Groq 的演示是四个人十天把 LLaMA 跑起来，而同样的模型在 GPU 上要花几个月手工 kernel。编译器周围的栈（profiler、runtime、GroqFlow bring-up 路径）又小又闭源，GroqFlow 在 2025 年被归档——公司停止卖卡，开始卖 token。

那个转向说明了这架构是为什么造的。LPU 在构造上只做推理（Ross 的说法：训练是局部游戏、推理是全局游戏），它在单一事情上无敌：单用户 decode 延迟。独立测量支持这个说法，Artificial Analysis 把 Groq 列为开源模型上每秒 token 最快的提供商之一。它与其它一切匹配得都很差：一个装不进一柜 SRAM 的模型、一个为了每美元吞吐想要大批量的工作负载、或静态调度表达不了的动态控制流。MoE 被服务着，但它依赖数据的专家路由与一个想提前知道一切的编译器别扭地共处，而 Groq 很少公布它如何调和两者。

尾声是这一切的买家是 NVIDIA。2025 年 12 月，NVIDIA 取得 LPU 技术的非排他许可，并聘用 Ross 和团队大部分成员。这不是收购：按 NVIDIA 自己的 10-K，没有产品、客户合同或股权易手——尽管交割时约 130 亿美元让媒体称之为收购。GTC 2026 上，该技术以 NVIDIA Groq 3 LPU 的身份重现：一柜 256 颗仅 SRAM 的推理芯片，坐在 Rubin NVL72 旁边，把 transformer 在两者之间拆分：GPU 跑注意力，LPU 跑前馈和 MoE 层，Dynamo 编排交接。AI 里最确定性的架构，最终成了最可编程架构里的一颗延迟协处理器。与此同时，GroqCloud 仍在最初的 14 nm 硅上服务 token。

对比

所有算力数字都是所述精度下的峰值；除非厂商不公布口径，条目均为稠密。内存带宽是所示原生层级：GPU、TPU 和 Trainium 是 HBM；Cerebras 和 Groq 是片上聚合 SRAM。这些数字不可直接比较。Scale-up 带宽遵循各家惯例，可能指每芯片聚合、机柜聚合或真实对分带宽。

#### 单芯片

#### 单机柜 / pod

* 标记分析师推算、按时代推断或厂商聚合推算的数字；未披露标记厂商没有公布的规格。

##### 这说明什么

• 单芯片 FP8 已经趋同。B200（4.5 PF）、Ironwood（4.6 PF）和 MI355X（10 PF）落在彼此的约 2 倍以内。单芯片军备竞赛已经接近；机柜和 pod 才是架构分道扬镳的地方。
• HBM 容量是 AMD 持续的胜利。2023–2025 年间 192 → 256 → 288 GB 每一代都追平或超过 NVIDIA。NVIDIA 直到 B300（2025 年底）才在 288 GB 追平；Rubin Ultra 在 2026 年以单封装 1 TB 重夺领先。
• 机柜级 scale-up 是 NVIDIA 到 2026 年的胜利。GB200 / GB300 NVL72 是 2024–2025 年唯一出货的一致机柜级域；AMD 在单机箱级扩展，直到 Helios 才到达机柜级。TPU 绕开这个问题：它的 torus 同时就是机柜和集群。
• TPU pod 在芯片数上碾压任何 NVIDIA 机柜。Ironwood pod = 9,216 颗芯片、42.5 ExaFLOPS FP8；NVL576 = 576 颗 GPU、约 5 ExaFLOPS FP8。TPU 的「每芯片平价 × 巨型 pod」配方在每系统聚合算力上更高，代价是每芯片带宽。
• 每芯片功耗快速上升。700 W（Hopper）→ 1,000 W（Blackwell、MI325X）→ 1,400 W（B300、MI355X）→ 约 1,800 W（Rubin Ultra，分析师）。约 1,000 W 以上液冷成为必须；风冷实际上止步于 Hopper。
• Scale-out NIC 带宽每代 NVIDIA 翻倍。400 Gbps（CX-7，Hopper）→ 800 Gbps（CX-8，Blackwell）→ 1.6 Tbps（CX-9，Rubin）。AMD 落后一代（Pollara 400 → Vulcano 800），反映 Pensando 更小的安装基数和更晚的整合。
• Cerebras 打破表格的轴。完全没有 HBM：44 GB 片上 SRAM、聚合 21 PB/s，每稠密 FLOP 约 1.3 字节，而 GPU 行坐在 0.002 附近。代价在同一行里看得见：总内存少于一颗 H200，每瓦稠密 FLOPs 落后于每一块当代 GPU，scale-up 列是空的，因为一致域就是晶圆本身。
• Trainium 拼经济账，不拼规格书。单芯片它落后（Trn2 的 1.3 PF FP8 大约是 MI355X 的四分之一），但 Trn2 UltraServer 在 2024 年就与 NVL72 同时到达 64 芯片机柜级 scale-up——作为消息传递 torus 而非一致 crossbar——Trn3 转向交换式 NeuronSwitch 网络。AWS 拥有从 Nitro 网卡到 API 的每一层，一个锚定租户（Anthropic，超过一百万颗 Trainium2 芯片）在前沿规模验证了它。
• Groq 拿容量换 SRAM 带宽，然后随芯片数扩大内存池。第一代 GroqRack 在 64 颗活跃芯片上只暴露 14 GB；Groq 3 LPX 把它长到 256 颗芯片 128 GB、聚合 SRAM 带宽 40 PB/s。它的 12 TB DDR5 层级和与 Rubin 的配对表明，LPU 补充而非取代一柜大内存 GPU。