Groq LPU：把调度复杂度前移到编译器¶

Groq LPU（Language Processing Unit）的核心思路不是再造一个带更多线程的 GPU，而是把机器学习图编译成一条空间上已放置、时间上精确到周期的张量流水线：矩阵、向量、数据重排和 SRAM 访问由不同功能切片负责，数据通过片上 Stream Register 在切片之间流动；编译器提前决定每条指令、每次访存和每段通信何时发生。

本页沿用 A100 架构图解 的拆解坐标，依次回答 芯片里有什么、数据怎样流、编译器怎样调度、模型怎样跨芯片展开。理解 LPU 的关键，是不要把 GPU 的 SM、Warp、Cache 和动态调度概念原样套过来。

1. 一张图看懂 LPU¶

下图按 Groq 原始 TSP 图的组织范式重画：横向是按功能分列的 Slice，纵向是 20 个 Tile 行。一条 Superlane 是横跨全部功能列的 16-Lane 横截面；20 条 Superlane 合起来形成最大 320-Lane 向量。ICU 从芯片南侧把指令向北送入各列，操作数和结果则沿 32 条 Eastward 与 32 条 Westward Stream 水平流动。它是二维流处理阵列，不是“几个计算模块围着一块共享 SRAM”的总线式结构。

1.1 三组数字先分清口径¶

首代 TSP 的详细数字来自 ISCA 2020 论文 Think Fast，产品数字来自 GroqCard Product Brief。峰值吞吐只说明上限，不代表某个 LLM 一定能持续达到该数值。

2. 功能切片微架构¶

传统多核处理器通常把取指、执行、Cache 和网络接口复制进每个 Core；TSP 则把这些部件按功能拆开，沿芯片的一个维度排成功能切片。这样做形成“局部同构、全芯片异构”的组织：同一切片里的 Tile 执行相同类型指令，不同切片分别负责访存、矩阵、向量或重排。

2.1 20 个 Superlane 怎样组成 320 Lane¶

• 一个 Tile 对 16 个 Lane 做 SIMD 运算，这个跨越各功能切片的 16-Lane 横截面称为一个 Superlane。
• 同一功能切片由 20 个 Tile 纵向组成，因此最小向量长度 minVL = 16，最大向量长度 maxVL = 20 × 16 = 320。
• 一条最大向量指令并非瞬间广播给 320 个 Lane：它从最南端 Tile 开始，随后逐周期向北传播，20 个 Superlane 的指令与数据因此呈错位流水。
• 数据主要沿东西方向在功能切片之间传播，跨 Lane 的南北移动则由 SXM 完成。换言之，指令流与数据流沿不同轴移动，并在正确的时间和位置相遇。

这不是 GPU 的 Warp。Warp 是动态驻留在 SM 上的一组线程状态；Superlane/Lane 是固定的 SIMD 数据通路，编译器直接选择向量长度、切片和执行周期。

2.2 主要切片与接口各做什么¶

2.3 计算链为何可以不落回 SRAM¶

Stream 是架构可见的片上寄存器通路。一个切片消费输入 Stream，执行功能，再把结果写到输出 Stream；下游切片可以直接消费结果。编译器因此可把多个操作连成 Producer–Consumer 链：

flowchart LR
    MEM0["MEM<br/>Read activation / weight"] -->|"Stream S0/S1"| MXM["MXM<br/>MatMul + Accumulate"]
    MXM -->|"INT32/FP result stream"| VXM1["VXM<br/>Scale / Bias"]
    VXM1 -->|"intermediate stays on stream"| VXM2["VXM<br/>Activation / Quantize"]
    VXM2 -->|"result stream"| MEM1["MEM<br/>Write only if reuse requires it"]
    SXM["SXM<br/>reshape / permute"] -. "按布局需要插入" .-> MXM

例如 Read → MXM → Requantize → ReLU → Write 可以让 MXM 结果直接经过多级 VXM ALU，省掉中间张量的一次 SRAM Write 和后续 Read。优势来自显式流水与数据流局部性，不是“计算完全不需要存储”；跨层复用、容量压力或依赖关系仍可能要求写回 SRAM。

3. 确定性执行与存储系统¶

3.1 编译器在二维时空里排程¶

TSP ISA 向编译器暴露功能延迟 d_func 和指令—操作数错位 d_skew。编译器同时追踪：

1. 指令在哪个功能切片、哪条队列上执行；
2. 数据此刻位于哪条 Stream Register、朝哪个方向传播；
3. 指令结果何时产生，以及到下游切片还需多少传输周期；
4. 哪个 SRAM Slice/Bank 在该周期可读写；
5. 多芯片时，哪个 C2C Link 在哪个时隙承载哪条 Stream。

flowchart TB
    GRAPH["Framework / Tensor Graph"] --> LOWER["Graph Lowering<br/>把高阶 Tensor 化为硬件支持的算子与二维布局"]
    LOWER --> PLACE["Spatial Placement<br/>选择 MEM Slice、MXM/VXM/SXM 与 LPU 分片"]
    PLACE --> TIME["Cycle Schedule<br/>安排依赖、传播延迟、NOP 与通信时隙"]
    TIME --> CODE["Per-slice Instruction Streams<br/>程序文本 + SRAM 初始布局"]
    CODE --> RUN["Deterministic Execution<br/>相同输入形状下按同一时空计划运行"]

运行时不需要 Warp Scheduler 持续寻找“哪个线程已就绪”，也没有 Cache Miss 后由硬件临时改变顺序的控制路径。代价是编译器必须预先知道形状、延迟和资源冲突；动态图、未覆盖算子或变化很大的 Shape 会增加编译、分桶或回退成本。

3.2 片上 SRAM 不是 Cache¶

首代 TSP 的 88 个 MEM Slice 形成一个分区全局地址空间（PGAS）。每个 Slice 有两个 Bank，若访问不冲突，编译器最多可以利用 176 路 Bank 并发。它与 Cache 的区别是：

“只有 SRAM”不表示一个 LPU 能装下整个大模型。Groq 的多芯片方案把各芯片 SRAM 组织成逻辑共享、物理分布的全局存储，模型参数和流水阶段分散在多个 LPU 上；芯片间只传递计划中需要的权重、激活或中间结果。该机制由 ISCA 2022 多 TSP 系统论文 详细描述。

3.3 “确定性”不等于端到端永远无抖动¶

确定性主要覆盖已编译程序在 LPU 计算与软件控制网络中的执行。Host 调度、PCIe 重传、网络请求排队、Tokenizer 和共享云服务仍可能引入端到端变化。Groq 的 BERT 论文就观察到 Host–TSP 的 PCIe 传输是测量中少量抖动的来源。因此评价时应分别观察：

• 芯片内 Kernel/程序的周期数；
• 多芯片模型流水的稳态延迟与吞吐；
• API 侧 TTFT（Time to First Token）、TPOT（Time per Output Token）和并发排队；
• Tokenizer、采样、网络等非 LPU 时间。

4. 贯通示例：batch=1 W8A8 线性层如何在 LPU 上执行¶

为了和 A100 页的示例直接对照，这里冻结同一个热点算子：Llama 类 Decoder 在生成一个 Token 时，计算一个 K=N=4096 的 W8A8 线性层。首代 TSP 的真实生产编译器和现行 GroqCloud 二进制不是公开接口，因此下面给出的是由公开 ISA 与 MXM 数据通路支持的教学映射，不是闭源编译产物的反汇编。

4.1 先固定计算、数据类型与规模¶

设输入 Activation 和 Weight 都做对称量化：

• q_x[4096]：当前 Token 的 INT8 Activation，附带一个 FP32 Scale s_x；
• q_W[4096,4096]：离线量化的 INT8 Weight，按输出通道保存 FP32 s_W[4096]；
• z[4096]：MXM 的 INT32 Accumulator；
• y[4096]：本例写成 FP16；如果下游仍走 W8A8，也可以在 VXM 中 Requantize 成 INT8 Stream。

仅这一层约占 16.04 MiB，能放进首代 TSP 的 220 MiB SRAM；这不表示完整 Llama 模型也能放进单芯片。程序文本、其他层权重、Activation 和运行时 Buffer 仍会占用 SRAM，完整模型通常需要跨 LPU 分片。

4.2 编译器怎样把 4096×4096 拆给四个 MXM Plane¶

一个 MXM Plane 可安装一个最多 320×320 的 INT8 Weight Tile。由于 4096 = 12×320 + 256：

• K 维拆成 13 段：12 个 320-Element Full Tile + 1 个 256-Element Residual Tile；
• N 维也拆成 13 段：每段产生最多 320 个输出；
• 四个 MXM Plane 可并行负责四个 N Tile，也就是同一 K 段最多同时推进 1,280 个输出；
• 13 个 N Tile 因而分为 4 + 4 + 4 + 1 四组，最后一组只有一个 256-Output Residual Tile。

flowchart LR
    subgraph MEM["MEM-W / MEM-E · 88 SRAM Slices"]
        W0["Weight Tiles<br/>最多 4 × 320×320 INT8"]
        A0["Activation K-Tile<br/>320 或 256 INT8"]
        S0["sₓ + per-output s_W"]
    end

    W0 -->|"LW → IW"| MXM["MXM Plane 0..3<br/>四个 N Tile 并行"]
    A0 -->|"Read → Stream → ABC"| MXM
    MXM -->|"ACC · 重复 13 个 K Tile"| ACC["4 × ≤320 INT32<br/>Output Accumulators"]
    ACC -->|"INT32 uses 4 aligned Streams"| VXM["VXM ALU Chain<br/>cast → ×sₓ → ×s_W → FP16/INT8"]
    S0 --> VXM
    VXM --> OUT["MEM Write / Downstream Stream<br/>最多 1,280 Outputs"]

下面的伪代码表达编译器要生成的调度关系，不是 Groq 汇编语法：

for n_group in [0..3]:                    # 每组最多占四个 MXM Plane
    clear_int32_accumulators()
    for k_tile in [0..12]:                # 12×320 + 1×256
        vl = 320 if k_tile < 12 else 256
        MEM: Read q_x[k_tile] -> activation_stream(vl)
        MEM: Read q_W[n_group, k_tile] -> weight_streams
        MXM: LW -> IW                      # Load / Install Weight Tile
        MXM: ABC activation_stream         # Activation Buffer Control
        MXM: ACC int8_dot_product          # 累加到 INT32
    VXM: cast(acc) * s_x * s_W -> fp16
    MEM: Write y[n_group]                  # 或直接交给下游切片

实际编译器还会把 Weight Layout、MEM Bank、Stream 编号、传播方向和 LW/IW 与前一 Pass 的执行重叠起来。公开 BERT 论文明确说明：当 GEMM 需要多次 MXM Pass 时，可在第 i-1 次执行期间装载第 i 次权重，从而减少 Plane 等待时间。

4.3 Tensor 操作怎样落到 Slice 指令¶

Stream 的基本 Lane 宽度是 1 Byte：一个 320-Lane INT8 Vector 占 320 Byte；FP16 需要两条自然对齐的 Stream，INT32/FP32 需要四条。VXM 接收 z 时，编译器因此不仅要追踪“哪个张量”，还要追踪四条 Stream 的编号、对齐和到达周期。

4.4 从装载到写回：一次线性层的执行时间线¶

冻结其中一个 N Group，可以看到 Producer–Consumer 关系：

sequenceDiagram
    participant MEM as MEM Slices / Banks
    participant MXM as MXM Plane 0..3
    participant VXM as VXM ALU Chain
    participant OUT as MEM or Next Slice

    Note over MEM,OUT: 编译器已知每个 d_func、d_skew 与 Stream 传播距离
    loop k_tile = 0..12
        MEM->>MXM: Read q_x + LW/IW Weight Tile
        Note over MEM,MXM: 第 i+1 次 Weight Load 可与第 i 次执行重叠
        MXM->>MXM: ABC → INT8 Dot Product → ACC
    end
    MXM->>VXM: 4 × ≤320 INT32 Output Streams
    VXM->>VXM: Cast → ×sₓ → ×s_W → FP16 / INT8
    VXM->>OUT: Write，或直接交给下游 Consumer

图中箭头表示数据依赖，不表示所有数据先完整落盘再进入下一步。真实执行时，一批结果一旦在正确 Stream 上出现，下游 VXM Tile 就可在编译器算好的周期开始消费。

4.5 把分块数字代回首代 TSP¶

• K、N 两个维度各有 13 个 Tile 位置，共 13 × 13 = 169 个 MXM Plane-Tile 工作项；边缘 Tile 的有效宽度是 256。
• 四个 MXM Plane 并行承担 N Tile，因此教学调度需要 13 × ceil(13/4) = 52 个“四 Plane Group”；每个 K Tile 的最后一组只有一个 N Tile 有效。
• 一个 Full Weight Group 为 4 × 320 × 320 = 409,600 Byte。ISCA 2020 论文给出的口径是：MEM 可在不到 40 周期内读取并把约 400K Weight 安装到四个 Plane，已包含 SRAM 与片上网络传输延迟；这不是完整 4096×4096 层的总周期数。
• 有用计算量仍是 4096 × 4096 = 16,777,216 MAC。TSP 的 Vector Length 能以 16 为步长从 16 配到 320，边缘 256 恰好是 16 的整数倍，因此不必像 A100 页的 m16n16k16、M=1 教学 Kernel 那样强制补出 15 行无效 Activation；MXM 正是面向“一个 Activation Vector × 一块 Weight Matrix → 一个 Output Vector”的数据流。
• Weight 已在片上 SRAM，并不表示不再移动。严格 batch=1、无跨请求复用时，每个 Token 仍需从 MEM 向 MXM 提供约 16 MiB Weight，只是这条高带宽、确定性路径不经过片外 HBM。Continuous Batching 或多请求流水可改变 Weight Tile 的复用策略。
• q_x 只有 4 KiB，Weight 才是主要数据量。编译器要让四个 Plane 同时工作，同时还要避免 MEM Bank、Stream 和 VXM Epilogue 成为瓶颈；750 TOPS 峰值不能直接换算成本例延迟。

4.6 扩展到 Attention：MXM、SXM、VXM 怎样重叠¶

线性层说明了单个 GEMM 的微观映射；Groq 的 Answer Fast 论文 则公开了完整 BERT-base 子图的流水。论文固定 batch=1、sequence length=128、hidden size=768、12 heads、head dimension=64、FFN=3072，Weight 使用 INT8，并给出以下功能分工：

flowchart LR
    X["INT8 Input X"] --> Q["MXM · GEMM Q"]
    X --> K["MXM · GEMM K"]
    X --> V["MXM · GEMM V<br/>independent branch"]
    Q --> RQ["SXM · Reorder Q"]
    K --> RK["SXM · Reorder K"]
    RQ --> QK["MXM · Batched QKᵀ"]
    RK --> QK
    QK --> SM["VXM Chains · Softmax"]
    SM --> AV["MXM · Attention × V"]
    V --> AV
    AV --> LN["VXM · Residual / LayerNorm / Requantize"]
    LN --> NEXT["MEM or Next Layer Stream"]

关键不是把上图的七个方框依次启动，而是让不同切片在同一逻辑时间处理不同批次的 Vector：SXM 仍在重排后部数据时，MXM 已可消费前部数据；Softmax 看到第一条 QKᵀ 结果后即可启动，最后一段 Softmax 又与不依赖它的 V Projection 重叠。这样既隐藏非 GEMM 延迟，也减少必须完整写入 SRAM 的中间 Tensor。

4.7 用一条因果链复述 LPU 执行¶

编译器把 16 MiB Weight 条带化到 88 个 MEM Slice/Bank → 将 4096 维 K/N 各拆成 12×320+256 → 每个 N Group 把最多四个 Weight Tile 交给四个 MXM Plane → ICU 让 MEM Read、LW/IW 与 Activation Stream 在精确周期相遇 → ABC 接收 320/256-Element q_x → MXM 沿 13 个 K Tile 做 INT8 Dot Product 并 ACC 到 INT32 → 四个 Plane 的结果通过四条对齐 Stream 进入 VXM → VXM 完成 Cast、×sₓ×s_W 与 FP16/INT8 转换 → 结果写回 MEM 或直接进入下游切片 → 四个 N Group 完成后得到 y[4096]。

如果能把这条链与 A100 页的 Block → Warp → Shared → WMMA → Tensor Core → Epilogue 对照复述，就能看出两者的真正差别：A100 由运行时调度大量 Warp，LPU 则由编译器预先安排功能切片、SRAM、Stream 与周期。

5. 多 LPU：把芯片内 Stream 延伸成系统流水线¶

当模型超过单芯片约 230 MB SRAM 时，编译器把参数、算子和通信共同分片。每个 TSP/LPU 既是计算端点，也能参与软件规划的数据转发；链路路由和发送时刻在编译期确定，以减少运行时争用带来的尾延迟。

sequenceDiagram
    participant H as Host
    participant L0 as LPU 0 / Stage A
    participant L1 as LPU 1 / Stage B
    participant L2 as LPU 2 / Stage C

    H->>L0: 输入与启动
    Note over L0,L2: 编译器已确定 SRAM 布局、链路路由与每个周期的发送/接收
    L0->>L1: 中间 Vector Stream
    L1->>L2: 中间 Vector Stream
    L2-->>H: 输出
    Note over L0,L2: 下一份输入可在前一份仍位于后级时进入流水线

这种“装配线”同时利用模型并行和流水并行：单请求延迟取决于穿过所有阶段的时间，稳态吞吐则取决于最慢阶段和流水间隔。只有各阶段负载、SRAM 容量和链路时隙都平衡时，增加 LPU 才能接近线性扩展；静态调度不会自动消除不均衡和通信成本。

6. 与 A100 放在同一坐标系比较¶

二者不是简单的“同一芯片把 HBM 换成 SRAM”。LPU 用更小的本地容量和更重的编译责任，换取可预测数据移动和深流水；A100 保留动态硬件机制与大容量外存，换取更强的通用性和运行时适应能力。比较 Token/s 时还必须固定模型、精度、上下文长度、Batch、并发和是否包含网络/Tokenizer，不能只比较峰值 TOPS。

7. 校验问题¶

参考资料¶

• Groq / IEEE：Think Fast: A Tensor Streaming Processor for Accelerating Deep Learning Workloads（ISCA 2020）
• Groq / ACM：A Software-defined Tensor Streaming Multiprocessor for Large-scale Machine Learning（ISCA 2022）
• Groq：GroqCard Accelerator Product Brief
• Groq：The Groq LPU Explained
• Groq：Answer Fast: Accelerating BERT on the Tensor Streaming Processor