现代 AI 加速器 GPU / TPU 系统课程 / 主线 / 专题六 / 推理 / L300 完整版

推理

训练一步算一大批,推理一步只出一个字。
decode 每一步都要把权重和 KV 搬一趟。推理的每一招,要么让这一趟分给更多 token,要么干脆少搬。
前置 专题三(KV cache)专题五(并行) 口径 截至 2026-10 ⏱ 讲约 334 分钟 📖 L300 完整版:自读、回查用|讲课看 90 分钟主线版

课程作者 Chris Yang·Google Cloud AI Infra 架构师

每个数字的出处在文末台账;自己推出来的数,都标了「本课推导」。

第 零 节

一次请求走一遍

🎯 开场热身:五种并行,各自要用哪几种集合通信? —— 回顾专题五,课上一起点开(课前勿点)。不做也不影响这一讲

每一行勾上这种并行训练一步里要用到的通信,可以勾不止一个。五行都勾完再点「对答案」。

并行方式AllReduceAllGatherReduceScatterAllToAll一对一收发
DP 数据并行每张卡一份完整模型,各吃一份数据
FSDP(ZeRO-3)权重、梯度、优化器状态全切开
TP 张量并行一层里的矩阵切给几张卡
PP 流水线并行按层切成几段 stage
EP 专家并行MoE 的专家分到不同卡

训练时答案已知,整段序列一起算,只看吞吐;推理得一个字一个字往外吐,还要守延迟。 吞 prompt 那一段(prefill)还像训练的前向,吃算力;往外吐字那一段(decode)每步只出一个字,吃带宽。 一次请求里,前后两段要的硬件正好相反。

开场新闻 · 2026 年 10 月:循环模型

做法:模型分三段。前段、后段各跑一遍,中间一段共享的层反复跑 k 圈,每圈都把前段的输出再喂一次。圈数推理时再选,权重只有一份。

NVIDIA 10 月 16 日放出 Dory 4B:前 8 层、中间 20 层循环、后 8 层。默认 2 圈;要省算力跑 1 圈,SWE-bench 一类 agent 任务开到 4 圈。

10 月 8 日的论文 Elastic Latent Recurrence 给出 Koi-4B:同一个 checkpoint,1 圈时 Artificial Analysis 智能指数估计 18,和 Qwen3.5-4B 持平;4 圈到 29。

留一个问题:圈数从 1 加到 4,每出一个字要从显存搬的字节变不变?答案在 0.2「回到开场新闻」。

循环模型怎么训,已训好的模型能不能改
  • 一次训练覆盖几个圈数。每个 microbatch 随机抽一个圈数 k,前向真跑 k 圈,梯度穿过全部 k 圈回传。只按一个固定圈数训,换别的圈数就变差,离得越远越差。
  • 多花的训练算力。0.5B 的消融里,全程混着圈数训,约是不循环基线的 1.79 倍;前 3/4 只跑 1 圈、最后 1/4 才混,降到 1.20 倍,保住 5 圈收益的 84%。论文估 4B 配置只多 16%。
  • 已训好的模型。直接把中间几层多跑几遍,通常变差。把每圈改成带阻尼的小步更新,不训练也能小幅提升:Qwen3-4B-Instruct 的 MMLU-Pro 高 2.64 个百分点(Training-Free Looped Transformers,2026-05)。
  • 要大幅提升得续训改造。例如 Retrofitted Recurrence(2025-11)、Relaxed Recursive Transformers、LoopUS(2026-05),都是在已有权重上划出循环段再接着训。

0.1 2022 年以来,推理怎么变便宜

2022 年的推理服务,一批请求要等最长的那个写完才一起退出。Orca 的连续批让每一步都能有人进出,同延迟下吞吐是老办法 FasterTransformer 静态批的 36.9 倍。可座位数由 KV(已读内容的缓存)定:KV 按最大长度预留,显存里真正存着 token(大致一个字,本课常叫“字”)的只有两到近四成(4.2)。同年的 FlashAttention 把注意力切块放进片上 SRAM 算,不再把整张分数表写回显存(5.1)。

2023 年 PagedAttention 把 KV 分页,利用率到 96%。浪费省掉以后,坐几个人就看 KV 池装得下几条 KV,偏偏上下文一路变长:2023 年 11 月 GPT-4 Turbo 开到 128K,2024 年 2 月 Gemini 1.5 Pro 预览 1M。模型侧用 GQA、MLA 把每条压薄;系统侧让相同的开头不再重算(SGLang 的 RadixAttention),存不下的往内存、SSD 放(Mooncake,给 Kimi 线上用)。

座位坐满后,长 prompt 进门那一步会卡住所有正在出字的人。2023 年 SARATHI 把 prefill 切块塞进 decode 的步里(2024 年 Sarathi-Serve 做成完整调度),可这只摊平了打扰;Splitwise、DistServe 干脆把两段分到两批机器(PD 分离)。代价是每个请求多传一趟 KV,还多了一份 prefill 与 decode 的机器配比要调。

DeepSeek-V3 这类 MoE(每个字只走几个专家)又把拼好的 batch 拆散:256 个专家选 8 个,每个专家只分到几行。SGLang 的 DP attention、DeepSeek 的大 EP 把专家铺到上百张卡上,凑够行数。随之而来的是每个 rank 要自备一份状态,K3 上 DEP8 直接显存不足;decode 快了,prefill 又喂不上。

2024 年 9 月的 o1、2025 年 1 月的 DeepSeek-R1 一题要写几百到几千个思考 token(R1 论文),交互档(同样的出字速度)又限住 batch,“读一趟权重出一个字”成了硬上限。投机解码、MTP 让一趟验好几个字;剩下能省的是字节,FP8、FP4 和合并 kernel(芯片上调起的一个计算函数)接着压。同一套 GB300(NVIDIA 整柜 GPU)跑 DeepSeek-V4-Pro,光改软件,同一交互档每卡吞吐比首发日(Day-0)涨了几倍?先猜一个数,答案在 15.3。

模型侧也在动。Qwen3-Next、Qwen3.5、K3 把大部分层换成线性注意力,每条序列只留一份固定大小的状态;循环模型让同一段层多跑几圈换深度(开场新闻)。两样都给引擎出了新题,分别在第十三节和 0.2。

问题链 —— 十三招各是哪年冒出来的 点落在首次公开的那一年(⑫⑬ 思路更早,落在进入主流大模型那年),年内只排先后;「→」是一直做到哪年;圈里是环号 系统侧 空心:模型侧 外力:上下文变长 外力:输出变长 2022 2023 2024 2025 2026 上下文变长 128K 1M 输出变长 o1 R1 2022 Orca 连续批 ① 2022 →2026 GPTQ 量化 ② 2022 →2025 投机解码 ③ 2023 →2025 GQA 压薄 KV ④ 2023 PagedAttention ⑤ 2023 分块 prefill ⑥ 2023 →2025 PD 分离 ⑦ 2023 RadixAttention ⑧ 2024 →2025 KV 分层下放 ⑨ 2024 →2025 切序列 CP ⑩ 2024 →2025 MoE 大 EP ⑪ 2025 →2026 线性注意力混合 ⑫ 2026 循环模型 ⑬
点落在这一招首次公开的年份,圈里的环号从左到右就是先后。
每环卡在哪、省了多少、又留下什么,展开图下的表。
出处与口径

首次公开:Orca OSDI'22;GPTQ arXiv 2210.17323;投机解码 Leviathan 等 arXiv 2211.17192;GQA arXiv 2305.13245;PagedAttention 博客 2023-06-20;Splitwise arXiv 2311.18677;RadixAttention arXiv 2312.07104;SARATHI arXiv 2308.16369;Mooncake arXiv 2407.00079;Meta 上下文并行 arXiv 2411.01783;SGLang v0.4 博客 2024-12-04(DP attention)、DeepSeek-V3 arXiv 2412.19437;⑫ Qwen3-Next 博客 2025-09-10(更早:H3 arXiv 2212.14052、Jamba 2403.19887);⑬ Koi-4B arXiv 2610.12582、NVIDIA-Nemotron-Labs-Dory1.0-4B 2026-10-16(更早:Universal Transformers arXiv 1807.03819)。末年:DeepSeek-V3.2-Exp 技术报告(DSA,2025-09);SGLang HiCache 博客 2025-09-10;NVIDIA Dynamo 新闻稿 2025-03-18;SGLang 大 EP 博客 2025-05-05;vLLM v0.10.2 release(DCP,2025-09);EAGLE-3 arXiv 2503.01840;Inferact TPU megakernel 博客 2026-09、vLLM DeepSeek-V4.1-Flash 博客 2026-10-07(FP4 KV)。外力:OpenAI DevDay 2023-11-06、Google 2024-02-15;OpenAI 2024-09-12、DeepSeek-R1 arXiv 2501.12948。年内等距排,只表先后。

十三环展开:每一招卡在哪、省了多少、又留下什么(按环号,也就是首次公开的先后)
环首次公开谁先做卡在哪 → 怎么解省了多少(对谁)解完又冒出什么节
①2022Orca 论文整批人陪最慢的那个写完 → 连续批,每步都能进出同延迟吞吐 36.9×(对 FasterTransformer)座位数归 KV 管,按最长预留,真用上的两到近四成三
②2022 → 2026GPTQ 等量化、megakernel大 batch 下能省的只剩字节 → FP8/FP4、合 kernelLlama 3 70B FP8 权重,每字间隔最好降到 BF16 的 1/2v7 上 FP4 推测只能存不能算;INT4 少了「减 8」会吐乱词十二
③2022 → 2025Google、DeepMind 论文;DeepSeek MTP、EAGLE-3思考题动辄几千 token → 投机解码/MTP,一趟验几个字MTP 约 1.8×;EAGLE-3 单请求最多 6.5×(都对不投机)并发大、上下文长、开 DEP 时收益缩水,甚至倒亏十一
④2023 → 2025GQA 论文、DeepSeek每条 KV 太厚 → GQA、MLA,再到 DSA 只挑一部分读GQA 约 ÷8、MLA 约 ÷57(本课推导);DSA 每字只读 2,048 条MLA 全层一份 KV,TP 切不开,开几路就复制几份四
⑤2023vLLMKV 预留白占显存 → PagedAttention 分页存KV 利用率 96%;吞吐 2–4×(对 FasterTransformer、Orca)能坐几人 = KV 池 ÷ 每条 KV,而上下文在变长四
⑥2023SARATHI 论文(2024 年扩成 Sarathi-Serve);引擎里 vLLM 先合入长 prompt 一进门全员卡住 → 分块 prefillSarathi-Serve 达标请求 2.6–3.7×(对 vLLM)只把打扰摊薄,两段还挤在同一批卡上三
⑦2023 → 2025Splitwise、DistServe → Mooncake → Dynamoprefill 与 decode 抢卡 → PD 分离DistServe 可接请求 7.4×(对当时最好的系统,两段同卡)每请求多搬一趟 KV,还得调 P、D 配比八
⑧2023SGLang 论文同样的开头一遍遍重算 → RadixAttention 复用前缀最多 6.4×(对当时其他系统)想复用的前缀多到显存放不下四
⑨2024 → 2025Mooncake(Kimi)、DeepSeek前缀放不下 → 分层下放到内存、SSDKimi 线上多接 107%–115%副本一多,前缀只在自己那份里有;靠 KV 感知路由把命中率从 20% 拉到 75%四、八、十四
⑩2024 → 2025Meta(CP);vLLM 2025 合入 DCPDEP 起不来、KV 被复制 → DCP/PCP 按序列切DCP 把 KV 副本让出来,PCP 切 prompt 压首字DCP 只在长上下文划算;PCP 遇上线性注意力,状态得一卡接一卡传七
⑪2024 → 2025SGLang、DeepSeekMoE 把 batch 拆碎,每专家约 8 行 → DP attention + 大 EPSGLang 复现:最多是同卡数纯 TP 的 5×每个 rank 自带一份状态,K3 开 DEP8 显存不够;prefill 也追不上变快的 decode六
⑫2025 → 2026(思路更早)Qwen3-Next → Qwen3.5、K3长上下文 KV 太大 → 大部分层换成线性注意力(GDN、KDA),每条序列一份固定大小的状态Qwen3.5-397B 60 层里只有 15 层存 KV状态截不开,前缀缓存只能存快照;tpu-inference 上跑 Qwen3.5 前缀缓存至今得关十三
⑬2026(思路更早)Koi-4B 论文、NVIDIA Dory 4B想多花算力换质量又不加参数 → 中间一段层反复跑几圈,圈数推理时选Koi-4B 同一个 checkpoint,智能指数估计 1 圈 18、4 圈 29多一圈多搬一趟权重;KV 每圈一份,显存跟着圈数涨零(0.2)

两股外力:上下文变长(2023-11 GPT-4 Turbo 128K,2024-02 Gemini 1.5 Pro 1M),每人占的 KV 多了座位就少;输出变长(2024-09 o1,2025-01 R1),一题几百到几千个思考 token。⑫⑬ 是模型侧的点,思路都早于 2022(混合:H3、Jamba;循环:Universal Transformers),图上落在进入主流大模型的那一年。这些招叠起来有多大:同一套 GB300 跑 DeepSeek-V4-Pro(2026-06),硬件、模型、交互档不动,只换软件,每卡是首发日的 5.1 倍(约 11,200 ÷ 约 2,200,本课推导;15.3)。表里每个倍数各有各的基线,彼此包含,不能乘起来(第二、十五节)。

两头一起变长 —— prompt 长让每趟更重,回答长让趟数更多 示意,格子数随手取,三块同一比例。每根柱是 decode 的一趟,高度是这一趟要从显存读的 KV;柱子总面积 = 这个请求一共要读的 KV prompt 留下的 KV 已写出的字留下的 KV ① 短 prompt、短回答 decode 第几趟 每根柱:这一趟要读的 KV ② prompt 变长:每一趟更重 decode 第几趟 深紫变厚,每一趟都多读 黑虚线 = ① ③ 回答变长:趟数变多 decode 第几趟 柱子多了好几倍;写出的字也进 KV,越往后越高 黑虚线 = ① 上下文变长把面积拉高,长输出把面积拉长 推理模型走的就是 ③;长 prompt 再配上长回答,面积又高又长。
深紫只在 ② 变厚,③ 多出来的全是浅紫。
格子数不是实测,只为三块能放在一起比。
出处与口径

示意图,无实测数。第 k 趟读的 KV = prompt 长度 + 已出字数(按定义)。没画权重:每趟都搬,但由 batch 里的人分摊;也没画 prefill:长 prompt 让它更贵,那是算力账。

全课的账建在 DeepSeek-V3(2024 年 12 月)上:MoE,总参数 6,710 亿,每个 token 激活的参数约 370 亿。 市面上推理这两年便宜得很快,斯坦福 AI Index 2025 主要归给更强的小模型;系统那一份单独拆不出来,15.3 再说。

这几年的引擎主要是 vLLM 和 SGLang 两家轮流领先。SGLang 2024 年 1 月首发时,博客写明用了 vLLM 的部分代码;一年后 vLLM 重写成 V1,致谢里点名的五家引擎就有 SGLang,原话是「显著影响」。分块 prefill、接 Mooncake 是 vLLM 先;MLA 优化、MTP、EAGLE-3、大 EP 是 SGLang 先。更多部件两家从同一个货架上拿:FlashInfer、xgrammar、DeepEP 与 FlashMLA、Mooncake、NIXL。

其他耳熟的名字落在哪。TensorRT-LLM 是 NVIDIA 自家引擎,和这两家同一层。Triton Inference Server 2025 年改名 Dynamo-Triton,是不限于 LLM 的通用模型服务器;LLM 的 PD 分离、前缀缓存、KV 落存储,NVIDIA 交给它上面的 Dynamo。

Hugging Face 的 TGI 已进入维护模式,官方改推 vLLM、SGLang 等引擎;LMDeploy 是上海 AI 实验室的引擎。llama.cpp、Ollama 跑单机和端侧,本课讲数据中心,不展开。

两大引擎 —— 你方唱罢我登场 只留八个关键时刻,横轴按月等距;带底色的小条是跟进的一方,颜色是先做的那一家 vLLM SGLang 外部锚点 vLLM 2023-06 PagedAttention vLLM 首发:KV 按页存 2024-09 v0.6.0 博客自承:CPU 开销拖累 GPU 2024-12 接 Mooncake 同月合入首批 PD 代码 2025-01 V1 重写 原文:受 SGLang 等影响显著 2023-06 2024 2025 2026 2024-11 Mooncake 开源 2025-02 DeepSeek 开源周 SGLang 2024-01 SGLang 首发 RadixAttention 原文:复用了 vLLM 的代码 2024-07 v0.2 纯 Python 调度 最多是 vLLM 0.5.2 的 3.1× 2025-04 接 Mooncake 晚 vLLM 3 个多月 2025-05 大 EP+PD 复现 最多是同卡数纯 TP 的 5× 2026-06 GB300 × V4-Pro 同交互档涨了几倍? 答案在最后一节
谁先做、谁跟进:蓝色小条是在跟 vLLM,红色小条是在跟 SGLang。
间隔按两边日期推算,往下取整;只凭推测的借鉴一律不标,其余时间点在图下的表里。
出处与口径

全部日期见第十六节台账「R85 补充」:vLLM 博客 2023-06-20、2024-09-05(v0.6.0)、2025-01-27(V1,「These engines have significantly influenced our work」);vLLM 合入 Mooncake 2024-12-15、首批 PD 代码 2024-12-01;SGLang lmsys 博客 2024-01-17(「reused some code from … vLLM」)、2024-07-25(v0.2,3.1× 对 vLLM 0.5.2)、SGLang 支持 Mooncake 2025-04-10、大 EP 博客 2025-05-05(96×H100,5× 对同卡数纯 TP);PyTorch 博客 2026-06-23(V4 on GB300,对自家 Day-0,同交互档;倍数最后一节揭晓);Mooncake GitHub README 时间线(2024-11 开源传输引擎);DeepSeek open-infra-index(2025-02 开源周)。晚 3 个多月按两边日期本课推导,往下取整。其余三十多个时间点见图下折叠表。

完整时间线:图上只留八个时刻,其余都在这张表里
日期谁做了什么跟进关系出处
2022外部Orca 迭代级调度(连续批)两家都建在它上面Orca,OSDI'22
2023-06vLLMPagedAttention 首发,吞吐最多是 HF 的 24×—vLLM 博客 2023-06-20
2023-11外部DeepSpeed-FastGen 提出切块拼批vLLM 回应「已在路线图」vLLM 博客 2023-11-14
2024-01SGLang首发 RadixAttention,最多 5×(对 Guidance、vLLM 等)原文写明复用了 vLLM 的部分代码lmsys 博客 2024-01-17
2024-01外部DistServe 论文(PD 分离)—arXiv 2401.09670
2024-03外部Sarathi-Serve 论文(分块 prefill)—arXiv 2403.02310
2024-03vLLM前缀缓存 APC 合入,V0 里默认关V1 改成默认开vLLM 合入记录;V1 博客
2024-04vLLM分块 prefill 在引擎里先落地SGLang 2024-07-29 跟进,晚 3 个多月两家合入记录
2024-05外部DeepSeek-V2 提出 MLA—arXiv 2405.04434
2024-06外部Mooncake 论文—arXiv 2407.00079
2024-07SGLangv0.2 纯 Python 轻量调度,点名 vLLM 的 CPU 调度开销;最多 3.1×(对 vLLM 0.5.2)—lmsys 博客 2024-07-25
2024-09vLLMv0.6.0 承认 CPU 开销让 GPU 吃不饱,Llama 8B 上 2.7×(对 v0.5.3)原文没说是回应 v0.2,不标vLLM 博客 2024-09-05
2024-09SGLangv0.3 先做 MLA 优化,3–7×(对基线系统)—lmsys 博客 2024-09-04
2024-11外部Mooncake 传输引擎开源—Mooncake README 时间线
2024-12SGLangv0.4:零开销调度、DP attention;V3 首发日支持V3 首发日比 vLLM 早一两天lmsys 博客 2024-12-04;两家 release
2024-12vLLM接 Mooncake(12-15),同月 12-01 合入首批 PD 代码SGLang 2025-04-10 跟进,晚 3 个多月vLLM 合入记录;Mooncake README
2025-01vLLMV1 重写,前缀缓存默认开原文:SGLang 等引擎影响显著vLLM 博客 2025-01-27
2025-02SGLangMTP 先合入(02-14)vLLM 02-19 跟进,晚 5 天两家合入记录
2025-02外部DeepSeek 开源周:FlashMLA、DeepEP、DeepGEMM两家随后都接入open-infra-index
2025-03SGLangEAGLE-3(03-18),自称首个支持vLLM 04-25 跟进,晚 5 周两家合入记录
2025-03外部NVIDIA Dynamo 开源一上来就同时支持两家NVIDIA 新闻稿 2025-03-18
2025-04vLLMKV Connector 接口(接 LMCache、NIXL)—vLLM 合入记录;LMCache 博客
2025-04SGLang接 Mooncake(04-10)晚 vLLM 3 个多月SGLang 合入记录
2025-05SGLang大 EP + PD 复现(96 张 H100),最多是同卡数纯 TP 的 5×vLLM 2025-06-03 接 DeepEP,晚近 1 个月lmsys 博客 2025-05-05
2025-09外部DeepSeek-V3.2(DSA)两家同一天首发日支持两家博客 2025-09-29
2025-09SGLangHiCache 分层 KV 缓存—lmsys 博客 2025-09-10
2025-09vLLM合入 DCP(MLA)—vLLM v0.10.2 release
2025-10vLLMv0.11 删掉 V0;KV 可下放 CPU;TPU 新后端 tpu-inference—v0.11.0 release;vLLM 博客 2025-10-16
2025-10SGLangSGLang-JAX 跑 TPU—lmsys 博客 2025-10-29
2025-12vLLMWide-EP,每张 H200 约 1.5k → 2.2k tok/s—vLLM 博客 2025-12-17
2026-03vLLMMRV2,吞吐 +56%(Qwen3-0.6B)—vLLM 博客 2026-03-24
2026-04外部DeepSeek-V4vLLM 04-24、SGLang 04-25 首发日支持两家博客
2026-06SGLangGB300 上跑 V4-Pro,同交互档对自家首发日涨了几倍(15.3 揭晓)—PyTorch 博客 2026-06-23
2026-09vLLM 生态Inferact 的 TPU megakernel—Inferact 博客

两家共用的外部部件:FlashInfer、xgrammar、DeepEP 与 FlashMLA、Mooncake、NIXL。间隔都按两边日期本课推导,往下取整;全部出处见第十六节台账「R85 补充」「L80 补充」。

0.2 一个请求的一生,和全课一句话

一个请求的一生 —— 一大块 prefill,接一长串一步一字的 decode 示意时间线,格子长短不按比例。上:在做什么、何时出字;中:显存里的 KV 有多长;下:decode 每一步要从显存读什么 prefill:整段 prompt 一次算完 decode:一步出一个字 权重 KV cache 从进门到结束 在做什么 何时出字 排队 prefill 整段 prompt 一次算完 第 1 步 第 2 步 第 3 步 第 4 步 第 5 步 第 6 步 第 7 步 第 8 步 字 1 字 2 字 3 字 4 字 5 字 6 字 7 字 8 结束 请求进门 TTFT:进门到第一个字(含排队) TPOT:平均每字间隔 显存里的 KV 有多长 prefill 一次写满整段 prompt 的 KV decode 每出一个字,KV 长一格 每一步 从显存读什么 权重:每步读一遍 KV:每步全部 两段的账正好相反 prefill 读一遍权重,分给整段 prompt 的几千个 token 一起算:卡在算力上。 decode 读一遍权重和全部 KV,只出一个字:卡在显存带宽上,而且字越往后 KV 越长、这一趟越重。
红点是第一个字,之后每个绿格出一个字;紫色阶梯每一步都在长。
示意时间线,长短不按比例。
出处与口径

⚠️ 示意时间线:格子长短不按比例,prompt 画成 6 格 KV、decode 画 8 步,都是为了看得清。

📌 TTFT、TPOT 的定义按 vLLM 的 benchmark_serving:TTFT 从请求发出算到第一个输出 token,TPOT 是除第一个 token 外平均每个输出 token 的时间。第二节会细讲它们的口径(含不含排队、平均还是 p99)。

⚠️ 「第一个字由 prefill 产出」是标准实现:prefill 的最后一个位置直接给出第一个输出 token 的分布。

用户只感觉得到两个数:等第一个字多久(TTFT,含排队),之后平均每个字隔多久(TPOT)。前者看排队和 prefill,后者看 decode(第二节)。

住在哪。权重和 KV 都常驻 HBM(芯片自带的显存)。真正做乘加的地方旁边那块片上存储,只有 HBM 的约 1/1,500:v7 每个 TensorCore 64 MiB VMEM,一颗芯片两个合 128 MiB,HBM 是 192 GiB(14.2)。几十 GB 放不进去,所以每一步都得从 HBM 再流一遍。

多大。V3 出一个字要用到 370 亿参数,FP8 每个 1 字节,约 37 GB(1.1)。KV 每层每个 token 存 1,152 B(怎么来的见下面逐层图),61 层合计 70,272 B(4.1)。

跟长度成正比。上下文 1 万 token,一条 KV 约 0.70 GB;128K 是 8.58 GiB。它是这个人自己的历史,一人一份,不跟别人共享。

出一个字,61 层逐层走一遍:

注意力要跟之前每个 token 比一遍,所以本层 KV 一格都跳不过。前馈只有第 1 到 3 层是稠密的、整块读;第 4 到 61 层是 MoE,一个人只读他挑中的 8 个路由专家和 1 个共享专家(config 里 first_k_dense_replace 是 3)。

出一个字,61 层逐层走一遍:每层读两样,写一格,传一条,其余丢掉 DeepSeek-V3,权重按 FP8 每参数 1 字节,KV 和传下去的向量按 bf16;条长按字节数同一比例画,数字由 config.json 推导 注意力权重 前馈/专家权重 本层 KV 写:KV 末尾 +1 格 只有一个人 decode:他的新 token 从上往下走一步 读:本层权重 每步都整块读一遍 读:本层全部 KV 之前每个 token 一格 写:KV 末尾 576 个数 × 2 B 传:下一层 丢:其余中间结果 第 1 层 稠密前馈 注意力 187 MB 稠密前馈 396 MB 583 MB 共 583 MB 128K:151 MB 1 万:11.5 MB +1,152 B 7,168 维 ↓ (bf16 14,336 B) 丢 第 2、3 层 同第 1 层:读、写、传、丢都一样 ↓ 第 4 层 MoE 注意力 187 MB 8+1 个专家 396 MB 585 MB 共 585 MB(含路由打分 1.8 MB) 128K:151 MB 1 万:11.5 MB +1,152 B 7,168 维 ↓ (bf16 14,336 B) 丢 第 5 到 60 层 同第 4 层:读、写、传、丢都一样 ↓ 第 61 层 MoE 注意力 187 MB 8+1 个专家 396 MB 585 MB 共 585 MB(含路由打分 1.8 MB) 128K:151 MB 1 万:11.5 MB +1,152 B 7,168 维 ↓ (bf16 14,336 B) 丢 输出层 61 层走完 输出层 0.93 GB:7,168 维 × 词表 129,280 打分挑出下一个字,然后回到第 1 层 出一个字 61 层走完才出一个字,下一个字从第 1 层重来 权重:61 层合计 35.7 GB,加输出层 36.6 GB,就是第一节那 37 GB;人多时这一趟大家共用。 KV:每层每 token 是 512 维压缩 KV(K、V 都从它解出)+ 64 维位置编码那截 = 576 个数,bf16 每个 2 B = 1,152 B;跟长度成正比,一人一份。
每一行都读两样:蓝绿那条大家共用,紫色那条跟着上下文变长、一人一份。
61 层加输出层的权重对上 37 GB;全部推导见第十六节台账「L83」。
出处与口径

📌 形状取 Hugging Face deepseek-ai/DeepSeek-V3 的 config.json:hidden 7,168、61 层、first_k_dense_replace 3、intermediate 18,432、moe_intermediate 2,048、256 个路由专家选 8 + 1 个共享专家、128 头、q_lora 1,536、kv_lora 512、qk_nope 128、qk_rope 64、v_head 128、词表 129,280、输入输出词表不共享。

📌 本课推导:注意力 = 7168×1536 + 1536×128×192 + 7168×576 + 512×128×256 + 128×128×7168 = 187,105,280;稠密前馈 = 3×7168×18432 = 396,361,728;单个专家 = 3×7168×2048 = 44,040,192,9 个正好 396,361,728;路由 256×7168。

📌 锚点:同一套公式总参数 671.0B(技术报告 671B,不含 MTP 层);激活 = 3×583.5M + 58×585.3M + 输出层 0.93B = 36.6B,取整即报告的 37B(输入词表查表只读一行,不计)。

⚠️ 口径:权重全按 FP8 每参数 1 字节,忽略 block scale;路由打分和 norm 实际精度更高,量级可忽略。KV、传下去的向量按 bf16。丢掉的中间结果包括本层的 Q、注意力分数、前馈中间那 18,432 维(专家是 2,048 维)的结果。

61 层加输出层的权重,合起来就是 1.1 那 37 GB(每层约 0.58 GB × 61 = 35.7 GB,输出层 0.93 GB;本课按 config 推导)。紫条单看一层不大,可到 128K 已和本层注意力权重(187 MB)一个量级。

几个人同时 decode 时,注意力和稠密层的权重大家共用:读一遍,每人各出一个字。专家不一样:各人挑的 8 个不同,按均匀路由算,64 人就碰到 256 个里的约 222 个,一百多人几乎挑遍,每层专家要读满 11.3 GB(本课推导,1.2)。KV 更不行,它是每个人自己的历史,各读各的(第一节)。

一句话 decode 每一步都要把权重和 KV 从显存里搬一趟。推理的每一招,要么让这一趟分给更多 token,要么干脆少搬。
还有一类不碰这一趟:把两段拆开,各放合适的机器。
后面每一节都在这一趟上做文章 —— 三根杠杆 decode 每出一个字,就要把权重和 KV 从仓库拉到工位一趟 车上多坐人 货变轻 开两个仓库 搬一趟 吞 prompt KV 仓库 = 显存 权重 KV 权重 工位 = 算力 开两个仓库 第八节 第九节 第十节 第十四节 货变轻 第四节 第五节 第十二节 车上多坐人 第三节 第六节 第七节 第十一节 第十三节 每出一个字,搬一趟 第一节 量这一趟 第二节
蓝色那组节最多:批处理、切专家、切序列、投机解码、新架构,都在让一趟多坐几个人。
归类是本课的分法,标签是讲这一招的节。
出处与口径

⚠️ 本课的分法:每节按它主要的贡献归一根杠杆。DEP 也让 attention 各管各的请求,KV 复用也省了 prefill 的计算,这类兼顾的地方只放一处。

⚠️ 投机解码放在「车上多坐人」:它让搬一趟换来好几个字,和批处理一样是把一趟分给更多 token。

回到开场新闻:多一圈,就多搬一趟

Dory 中间 20 层的权重是 GB 量级,比 128 MiB 的 VMEM 大一个数量级以上,放不下。所以每跑一圈都要从 HBM 再流一遍。4 圈的 Dory 每出一个字搬的权重,跟同样深度(8+20×4+8=96 层)的普通模型一样多(本课推导)。

省的是容量:存 36 层,跑出 96 层的深度,权重约占等深模型的 36/96≈38%(本课推导)。腾出来的显存装 KV、多坐人,这一趟就分给更多 token。

KV 是新麻烦:每圈各存一份,显存跟着圈数涨。Koi-4B 4 圈都存时,128K 一条要 7.5 GiB,是 1 圈 3.0 GiB 的 2.5 倍;只留最后一圈的 KV,压回 1 圈的大小,大部分收益还在。

圈数多了答得更短:Koi-4B 4 圈比 1 圈少出三成多的 token(2、3、4 圈依次少 21.8%、29.5%、32.7%)。每个字慢了,整道题不一定慢。

遇到不认识的词,回这儿查
  • prefill:整段 prompt 一次算完,顺手产出第一个输出 token。
  • decode:之后每步只出一个 token,再喂回去算下一个。
  • KV cache:每个处理过的 token 在每层留下的 K 和 V,后面的 token 算注意力要回头读,所以常驻显存(专题三)。
  • TTFT:请求发出到收到第一个输出 token 的时间;含不含排队要写清。
  • TPOT 与 ITL:TPOT 是首字之后平均每个 token 的时间;ITL 是相邻两个 token 的间隔,看 p99 用它。
  • goodput:满足延迟要求的那部分吞吐(第二节)。
  • 交互档:按每个用户看到的出字速度分档;只在同一档里比每卡吞吐(第二节)。
  • Little 定律:系统里的人数 = 到达速率 × 每人停留时间(第三节)。
  • connector:推理引擎里在 prefill、decode 两端收发 KV 的插件(第八节)。
  • batch 与并发:并发是同时在服务的请求数;batch 是引擎这一步实际拼在一起算的数,通常不超过并发。
  • 吞吐:每秒出多少 token;要写清总量还是每卡、分母含不含 prefill 卡、分子含不含输入。
  • 每 token 激活的参数:MoE 每个 token 只经过挑中的几个专家,这部分参数才参与计算;不是「激活值」(每层的中间结果)。
  • HBM 带宽:芯片每秒从自带显存读写的字节数;TPU v7 每芯片 7.37 TB/s。
  • 屋脊点:峰值算力 ÷ 显存带宽,即每读 1 字节至少做几次运算才不被带宽拖住;v7 bf16 约 313(专题二)。
  • chip 与 device:一颗 TPU v7 芯片对软件显示成 2 个 device;规格按芯片写,并行度和切片名按 device 数(v7x-8 是 4 颗芯片)。
  • PD 分离:prefill 和 decode 分到不同机器,中间传 KV cache(专题五第六节)。
  • 投机解码:先便宜地猜后面几个 token,大模型一步一起验,猜对几个就出几个(第十一节)。
  • MTP:多 token 预测,训练时在主干后多挂一层 transformer 猜再下一个字,推理时当投机解码的草稿(第十一节)。
  • MXU:TPU 里做矩阵乘的单元,v7 上 256×256;喂的行数不够就空转。
  • TP、EP、DP、DCP:四种分卡切法:TP 切开一层的矩阵;EP 把不同专家放不同卡;DP 整套复制、各接各的请求;DCP 把一条长序列的 KV 按 token 分到几张卡(第七节)。
  • TEP、DEP、dep8:MoE 推理的两种切法(第六节):TEP 注意力按 TP 切;DEP 注意力按数据并行切,每卡带自己的一批人;dep8 即 8 路 DEP。
  • rank:参与并行的一个进程,通常一卡一个。
  • NVLink 域:用 NVLink 直连、能互读显存的一组 GPU;NVL72 一柜 72 块是一个域,出域走慢得多的网卡。
  • 切片:ICI 直连的一组 TPU 芯片;切片之间走数据中心网络(DCN)。
  • v7 与 v7x:同一款芯片(Ironwood),云上和代码里写 v7x。
出场角色:本课反复出现的模型、硬件和软件
  • DeepSeek-V3 / R1:MoE,注意力用 MLA;R1 是同架构的推理版。
  • DeepSeek-V4-Pro / V4-Flash:DeepSeek 2026-04 的 MoE;本课 GPU 实测大多来自 V4-Pro 在 GB300 上的部署记录。
  • Kimi K3 / K2.6:Moonshot AI 的 MoE;K3 的注意力里混了 KDA(Kimi Delta Attention)线性注意力层。
  • Qwen3.5-397B:通义千问的混合模型,60 层里 45 层是 GDN(Gated DeltaNet)线性注意力,只有 15 层存传统 KV。
  • TPU v7:芯片间用 ICI 直连成 3D torus。
  • GB200 / GB300:NVIDIA Blackwell 代整柜系统(NVL72)。H100、H200、H800、H20 是上一代 Hopper,后两种是出口受限版。
  • vLLM、SGLang:两大开源推理引擎;tpu-inference 是 vLLM 在 TPU 上的后端。TensorRT-LLM 是 NVIDIA 的引擎,Dynamo-Triton(原 Triton Inference Server)是它的通用模型服务器。
  • Dynamo、llm-d:多机编排层,管路由、PD 分离和扩缩容;前者出自 NVIDIA,后者跑在 Kubernetes 上。
  • Mooncake、NIXL、LMCache:搬 KV、存 KV 的库(第四、八节)。
第 一 节

两个阶段:prefill 吃算力,decode 吃带宽

训练、prefill、decode 摆在一起比:prefill 一次喂几千个 token(矩阵乘里每个 token 占一行),decode 每人每步只喂一个。 行数差了三个数量级,瓶颈就从算力换到了显存带宽。0.1 里的每一招都冲着这个事实。

训练每步约 6 次运算/参数/token,前向占 2 次,反向约 4 次;推理只有前向。
训练prefilldecode
一步喂进去的整批完整序列一段 prompt,几千行每人一行
算什么前向+反向+更新只有前向只有前向
序列能不能并行能:答案已知,整段一起算能:prompt 已知不能:下一个字要等上一个
卡在哪算力、通信算力显存带宽
显存装什么权重、梯度、优化器状态权重+每人的 KV
看什么吞吐首字延迟字间隔,以及同时服务多少人

prefill 就是训练的前向,专题五那套切法和 kernel 大多能直接搬。decode 每步只出一个字,却要把全部权重和每人的 KV 读一遍;请求又随时到、长短不一。一颗很贵的芯片,大半时间在等搬运。

1.1 一次喂几行,决定卡在哪

v7 按 bf16(每个数 2 字节)算,每读 1 字节要做满 313 次运算才不被带宽拖住,这叫屋脊点。 矩阵乘一次喂进 M 行,每个权重就要做 M 次乘加(2M 次运算),而它只占 2 字节:只算读权重,每字节的运算次数(强度)就是 2M ÷ 2 = M。

一次喂几行,决定卡在哪 —— decode 在屋脊点下面,prefill 在上面 一个 7168×7168 的 bf16 矩阵乘:横轴是一次喂进去的行数 M(token 数),纵轴是每搬 1 字节做几次运算。两轴都是对数 decode:M = 同时解码的人数 prefill:M = prompt 长度 v7 屋脊点 运算强度 = 运算次数 ÷ 搬的字节 1 4 16 64 256 1,024 4,096 16,384 M:一次喂进去的行数(token 数) 1 10 100 1,000 运算/字节 v7 屋脊点:每字节要算 313 次才不用等显存(bf16) ↑ 这一侧卡在算力 ↓ 这一侧卡在显存带宽 一次喂到约 343 行才过屋脊点 decode 1 人:每字节算 1 次 decode 64 人:每字节算 63 次 decode 256 人:每字节算 239 次 prefill 一段 4K prompt:远在线上 decode 再多拼人也难过线,prefill 一段 prompt 就远远过线 decode 一步每人只喂 1 行,256 个人拼一起也才每字节算 239 次;prefill 一段 4K prompt 一次就是 4,096 行。 所以同一块芯片,prefill 时算力是瓶颈,decode 时显存带宽是瓶颈。
绿点全在红线下面,橙点在上面。
读权重、读输入、写输出都算进字节;本课推导。
出处与口径

📌 7168 = DeepSeek-V3 config.json 的 hidden_size。屋脊点 313 = v7 每芯片 bf16 2,307 TFLOP/s ÷ HBM 7.37 TB/s(Google Cloud 公开规格;bf16 是 FP8 4,614 的一半,本课推导;专题二同一个数)。

📌 本课推导:运算 2·M·H²,字节 2·(H² + 2·M·H)(权重读一遍、输入读一遍、输出写一遍,bf16 每数 2 字节),强度 = M·H ÷ (H + 2M)。令它等于 313 解出 M ≈ 343。

⚠️ 只算权重时强度就是 M,过线点正好是 313(专题五 fig5-decode-ai 的口径);这里把输入输出也算上,过线点往右挪到 343。

⚠️ 刻意没画:注意力(它读的是 KV,强度不随人数涨,第五节讲)和 MoE 专家层(见本节专家行数那张图)。

曲线比 M 低一点,是因为输入、输出也要读写。prefill 一段 4K 的 prompt 远在线上;decode 要一步凑够约 343 人才过线。

一个人解码一步:5 毫秒在读,0.016 毫秒在算。decode 每出一个字,都要把 V3 的 370 亿激活参数从显存读一遍;按 FP8(每个 1 字节)存,就是 37 GB。

一个人解码一步:读权重 5.02 ms,算只要 0.016 ms DeepSeek-V3,batch 1,一颗 TPU v7 的规格,只算权重。两根条用同一把时间尺 从显存读权重 MXU 做运算 一步解码的时间(同一把尺) 读权重 37 GB ÷ 7.37 TB/s 5.02 ms 做运算 74 GFLOP ÷ 4,614 TFLOP/s 0.016 ms 其余时间:MXU 在等数据 0 ms 1 ms 2 ms 3 ms 4 ms 5 ms 算力利用率 0.32%:一个人解码,芯片几乎全在等显存 0.016 ÷ 5.02 = 0.32%,正好是 1/313:FP8 每读 1 字节要做约 626 次运算才不用等显存,这里只做 2 次,差 313 倍。 换更快的 MXU 毫无用处,这一步的下限是显存带宽定的。
橙条细到几乎看不见。
理想下限:只算权重,不算 KV、通信和 kernel 开销;按每芯片规格,摊到多颗上比例不变。
出处与口径

📌 37B 激活参数、671B 总参数:DeepSeek-V3 技术报告摘要。FP8 权重每参数 1 字节(V3 原生发布 FP8)。v7 每芯片 FP8 4,614 TFLOP/s、HBM 7.37 TB/s:Google Cloud 公开规格。

📌 本课推导:37e9 ÷ 7.37e12 = 5.02 ms;2 × 37e9 ÷ 4,614e12 = 0.016 ms;比值 0.32% = 2 ÷ (4,614 ÷ 7.37) = 1/313。

⚠️ 理想下限:只算权重,不算 KV、激活、通信和 kernel 开销,实测只会更慢。

⚠️ 671 GB(≈ 625 GiB)一颗 192 GiB 的芯片放不下,至少 4 颗(还没算 KV)。摊到 N 颗上,两根条都 ÷N,0.32% 不变。

算的一侧按 W8A8(权重和激活值都用 8 位)计。这 5 毫秒是每步用时的下限,实测离它越近,带宽用得越满。可这一趟只出了一个字。

1.2 KV 和 MoE:拼好的 batch 又被拆薄

权重一次读完能分给一整批人,KV 却是每人自己的历史。

每出一个字搬多少:权重能分摊,KV 每人一份 DeepSeek-V3,FP8 权重,bf16 的 MLA KV。每根条 = 一步读的权重 ÷ 人数 + 这个人自己的 KV。同一把尺 分到每个字的权重 这个人自己的 KV 每个字的字节(GB) 1 人同时解码 整份 37 GB 只给一个人 4K KV 0.8% 32K KV 6% 128K KV 20% 64 人同时解码 每人摊到 9.14 GB(87% 专家被碰到) 4K KV 3% 32K KV 20% 128K KV 50% 256 人同时解码 每人摊到 2.62 GB 4K KV 10% 32K KV 47% 128K KV 78% 0 8 16 24 32 40 48 GB/字 人越多、上下文越长,这一趟里 KV 越重 权重一次读完分给所有人;KV 是每人自己的历史,128K 时每个字要读 9.21 GB,拼多少人都不变。 256 人、128K 时 KV 已占 78%:再往后,省的就得是 KV 本身。
蓝段随人数缩短,紫段只随上下文变长。
64 人时 87% 的专家被碰到(一个专家没人挑的概率 (1 − 8/256)64 ≈ 13%),所以每人摊 9.14 GB,不是 37 ÷ 64。路由均匀、上下文等长;不含激活值与通信。
出处与口径

📌 本课推导:KV = 70,272 字节/token(MLA 每层存 512 + 64 个数,bf16,61 层,config.json)× 上下文。128K 时 9.21 GB = 8.58 GiB,与专题五同一个数。

📌 本课推导:b 人一步读的权重 = 不经路由的部分 + 653.9B 路由专家 × [1 − (1 − 8/256)^b](FP8,每参数 1 字节)。b=1 时恰好 37 GB,b 很大时趋近 670.5 GB,对上 671B。

⚠️ 64 人时每人摊到 9.14 GB 而不是 37 ÷ 64:每人挑的专家不同,一步里 87% 的专家都被碰到、都要读。

⚠️ 假设路由均匀、所有人上下文一样长;没算激活和通信字节。KV 改存 FP8 时紫段减半。

这还是 MLA 压过的 KV(0.2 里 128K 那份 8.58 GiB)。

MoE 把拼好的 batch 又拆散。拼 batch,就是让读一次的权重多喂几行。 可 V3 每层有 256 个路由专家,每人只挑 8 个;256 人进来,每个专家平均只分到 8 行,按 1.1 强度也只有约 8。

MoE 把一批人拆散:256 人进来,每个专家只分到 8 行 同一批 256 人解码一步。方块是 v7 的 MXU(一边 256),填色的是这一步真正喂进去的行 这一步喂进 MXU 的行(decode 的 token) 稠密层 vs 一个专家 稠密层:256 人共用一块权重 MXU 256 × 256 256 行,填满一边 运算强度 ≈ 239 屋脊点 313 MoE 层:一个专家 MXU 256 × 256 平均 8 行,占一边的 1/32 运算强度 ≈ 8 屋脊点 313 256 × 8 ÷ 256 = 8 仍在线下,但差得不多 拼来的 256 人,到了专家这里又被拆成 256 份 每人只挑 8 个专家,一个专家平均只分到 8 行,强度约 8;稠密层约 239,差 30 倍。 要让专家吃饱,得把很多卡上的人收到一起:这就是大 EP 要做的事。
左边填满一边,右边只剩一条细线。
8 是均匀路由下的平均数;共享专家不受影响。
出处与口径

📌 256 个路由专家、每 token 挑 8 个:DeepSeek-V3 config.json(n_routed_experts、num_experts_per_tok)。MXU 一边 256:JAX 公开源码 jax/_src/pallas/mosaic/tpu_info.py,TPU 7 的 mxu_column_size=256。

📌 本课推导:专家矩阵 7168×2048,M=8 时强度 = 2·8·7168·2048 ÷ [2·(7168·2048 + 8·(7168 + 2048))] ≈ 8。稠密层 239 来自本节第一张图。

⚠️ 8 是平均数,路由不均时有的专家几十行、有的零行。共享专家每个 token 都过,不受影响。

这一节只要带走一件事 prefill 卡算力,decode 卡带宽;decode 每一步都要把权重和 KV 搬一趟。 要让这一趟分给更多人,先得让批一直坐满、装下更多人的 KV(第三、四节),再把被 MoE 拆散的行收回来(第五、六节)。动手之前,先把量这一趟的尺子对齐(第二节)。
第 二 节

先校准尺子:指标与口径

要说清后面每一招省了多少,先得有把尺子。可同一次测量,换一种数法,每卡每秒的 token 数可以是 5,270,也可以是 11,880。 先把尺子对齐,后面每一节的数才能放在一起比。

2.1 四个时间指标,一条吞吐—交互性曲线

四个时间指标各量哪一段 —— 先问含不含排队、含不含首字 一个请求的时间线(示意)。每个绿块是一次到手的一段字,宽度按它带的字数画 排队 prefill decode 推出的一段字(chunk) 一个请求的时间线 排队 prefill 1 字 1 字 2 字 1 字 3 字 1 字 2 字 第一个字 请求进门 TTFT:进门 → 第一个字 含排队、prefill、网络 ITL:这一次间隔 带 3 个字,所以最长 TPOT = 这一段 ÷ (字数 − 1),每个请求一个平均数 每用户 tok/s ≈ 1000 ÷ TPOT(ms) 共 12 个字
比三根横杠的起点:只有 TTFT 从进门算起。
时间线是示意,绿块宽度按字数画。
出处与口径

vLLM 定义:vllm/benchmarks/serve.py(TPOT = (latency − ttft) ÷ (output_len − 1);ITL 逐 chunk,源码注释写明 multiple output tokens may be bundled together)。

NIM 定义:NVIDIA NIM for LLMs 的 benchmarking 指标页(TTFT 含排队、prefill、网络;ITL also known as TPOT)。AIPerf 沿用同一套。两家对同一个词的口径不同,正文第 2.1 节对照。

⚠️ 时间线是示意:chunk 带几个字、各段长短都是为了看得清,不对应任何实测;绿块宽度按字数画,表示这几个字是攒在一起才到手的。

TTFT 压测时往往大半是排队:同一个 Gemma4-31B,并发 1 时不到 0.1 秒,并发 256 时将近 8 秒(86 ms → 7,756 ms)。

同一个词两家定义可能不同:NVIDIA NIM 的 ITL 是平均值,注明「也叫 TPOT」;vLLM 的 ITL 是逐次间隔的列表。

吞吐和交互性是一条曲线。

吞吐和交互性是一条曲线 —— 先定档,再比吞吐 GB300 · DeepSeek-V4-Pro · 8K 进 1K 出 · 纵轴只数输出 token、只除以 decode 卡(11,200 官方没写怎么数) InferenceX:Dynamo + vLLM(同一条曲线) PyTorch 博客:SGLang 本仓库实测:SGLang dep8 每张 GPU 的吞吐 vs 每个用户的速度 0 50 100 150 200 0 3,000 6,000 9,000 12,000 每个用户每秒拿到的字(tok/s/user)→ 越右越跟手 每张 GPU 每秒出的字 ↑ 先定档:每用户 50 tok/s 9,759 @ 68 3,816 @ 121 895 @ 173 11,200(2026-06,开 MTP) 2,200(首发,无 MTP) 9,168 @ ≈ 17 (TPOT 约 60 ms) 同一档上:11,200 对 2,200,几倍? 每卡约 224 个用户同时在线(11,200 ÷ 50) 单报一个每卡吞吐,等于没报 同一条 vLLM 曲线上,每用户从 68 提到 173,每卡吞吐从 9,759 掉到 895。报吞吐必须连同交互档一起报。 本仓库的 9,168 落在每用户约 17 的低档,跟 50 档上的 11,200 不能直接比高低。
沿着曲线往左走,每卡吞吐就往上涨。
只有绿色三点是同一条曲线;其余点分属不同框架和配置。
出处与口径

InferenceX 三点:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:683-695(GB300 Dynamo + vLLM,V4-Pro FP4,8K/1K,output ÷ decode GPU)。

PyTorch 博客 2026-06-23「Serving DeepSeek-V4 on GB300 with SGLang: 5x Higher Throughput at the Same Interactivity Since Day-0」:~11,200 tok/s/GPU at roughly 50 tok/s/user,Day-0 无 MTP 曲线约 2,200。

⚠️ 11,200 用的是 output ÷ decode GPU 还是 (in+out) ÷ 全部 GPU,公开材料没钉死(SGLANG-V4PRO-RUNBOOK.md:745)。本图按前者画,若是后者,这个点要往下挪。

本仓库实测 9,168:SGLANG-V4PRO-RUNBOOK.md:596(conc600,TPOT 59–61 ms)、723-725。横坐标 1000 ÷ 60 ≈ 17 是本课推导。

goodput:DistServe(arXiv 2401.09670)。

每人出字慢一点,一步就能多拼几个人,每卡吞吐就涨(1.2)。所以先定交互档,再在这一档上比吞吐。

把档位写进定义的指标叫 goodput(DistServe,2024,arXiv 2401.09670):规定比例(如 90%)的请求同时满足 TTFT 和 TPOT 目标时,每张卡能扛的最大请求速率。

同一次测量,四把尺子。

同一次测量,四把尺子 —— 换个数法,最大差 36 倍 GB300 · SGLang · V4-Pro · 8K 进 1K 出。实心条是 InferenceX 实际报出的两个数,虚线条是本课补算的另两种数法 输出 token 输入 token decode 卡 16 张 prefill 卡 48 张 每张卡每秒多少 token 数哪些 token 除以哪些卡 ÷ = 5,270 ÷ = 11,880 ÷ = 1,318 ÷ = 47,520 官方标称 11,200 最大 ÷ 最小 = 36 倍
先比框住的格子再看结果条:分子框得越多、分母框得越少,数越大。
虚线两条是本课推导,没有工具这样报。
出处与口径

本课程作者实测:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:794-809(dep16:聚合 output 84,321;÷16 = 5,270;tput_per_gpu = 11,880);字段定义见同文件 731-735(InferenceX process_result.py:output_tput_per_gpu = output ÷ decode GPU,tput_per_gpu = (输入+输出) ÷ 全部 GPU)。

本课推导:(in+out) = 11,880 × 64 = 760,320;output ÷ 64 = 1,318;(in+out) ÷ 16 = 47,520。自洽检查:8K 进 1K 出时 in+out 约为 output 的 9 倍,9 × 84,321 = 758,889,与 760,320 差 0.2%。

⚠️ token 和卡的小方块只画比例:输出 4 个对输入 32 个 = 1 : 8;卡 16 : 48 是实数。

⚠️ 一颗 TPU v7 芯片对软件显示成 2 个 device,按 device 报的每卡数是按芯片报的一半。

PD 分离(第八节)把 prefill 和 decode 放在不同的卡上,「每卡每秒多少 token」就有两处能挑:分子(token)数不数输入,分母(卡)算不算 prefill 卡(InferenceX 是 SemiAnalysis 的公开基准)。

2.2 尺子以外的四个坑

尺子以外的坑 —— 每一个都能单独让数字差出一截 GB300 上的 DeepSeek-V4-Pro,两组各自独立的实测;每组上面是坑里的数,下面是改对之后的数 坑里的数 改对之后的数 峰值当稳态 虚高 13% 同一轮,换个读数 峰值 12,070 端到端 10,704 没预热 ×2.05 同一套配置,跑第二遍 第一轮 13,585 第二轮 27,803
左边的坑让数虚高,右边的坑让数虚低。
出处与口径

峰值:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:849-858(ISL 4096,#7 端到端 10,704、峰值 12,070)。峰值是 decode 引擎自报的瞬时 gen throughput,按 DP rank 计(同文件 835-845)。另一组峰值稳态:tpu/tpu-inference/Gemma4-31B/README.md:460(TPU v7x,并发 256,输出 4,495、peak 6,144)。

预热:VLLM-V4PRO-RUNBOOK.md:431-433(2P1D conc256,13,585 → 27,803);另一组 SGLANG-V4PRO-RUNBOOK.md:480-494(8,520 → 9,118,+7.0%)。闭环:SGLANG-V4PRO-RUNBOOK.md:478、1135(闭环比开环低 13%)。

温度这个坑(接受率 1.16% 对 34%)画在第十一节的图里,这里不重复;出处 VLLM-V4PRO-RUNBOOK.md:394-420。

2.3 落到钱上

每百万输出 token 的成本 = 每卡每小时的价 ÷(每卡 tok/s × 3,600)× 10⁶。卡价不变,每卡 tok/s 涨几倍,每个字就便宜几倍。2.1 那一档每卡从约 2,200 到约 11,200,正是开场那道题的数据;倍数和成本留到 15.3 一起对账。

线上真有人选吞吐那头。DeepSeek 公布过一天的线上数:decode 时每节点输出约 14,800 tok/s,每用户只有 20–22 tok/s。

这一节只要带走一件事 报一个吞吐,要连同五样一起报:分子分母、交互档、峰值还是稳态、温度和采样、有没有预热和是不是开环。 缺一样,差距可能全是口径。
尺子对齐了,接下来量第一节那件事:一趟搬运能分给几个人。先看谁在什么时候上车(第三节)。
考考自己:一份材料写「每卡 12,000 tok/s,超过官方」。你要先问哪三件事?

分母只算 decode 卡还是全部、分子含不含输入;在每用户多少 tok/s 的档位测的;峰值还是稳态。TPU 上再问:卡按芯片还是 device 数。

第 三 节

批处理与调度:一趟分给更多人

第一节算过:decode 每一步把权重搬一遍,同一趟坐的人越多,每人摊到的越少。最早的服务一批人一起进、一起出,先答完的人座位空着,等最慢的那个。 调度决定这一趟能坐满几个人。

3.1 每一步都重新排一次

每一步都重新排一次 —— 谁跑完谁让位,槽位不空等 示意:4 个槽位 × 8 个请求,每个请求一种颜色、字母标在它的第一格。每一列是一步 decode 彩色实心格 = 这个请求这一步出一个字 虚线格 = 槽位空转,这一趟白搬 静态 batch:凑满一批,等最慢的跑完 A B C D E F G H 槽位 1 槽位 2 槽位 3 槽位 4 ↑ 第二批到这里才能进来 15 步做完 空转 23 格 C 第 2 步就写完, 要陪 B 到第 8 步才返回 逐步调度(Orca):每一步都看一次,空出来就补人 A B C D E F G H 槽位 1 槽位 2 槽位 3 槽位 4 ↑ 从这里起队列空了,才开始有空格 12 步做完 空转 11 格 排队的人一来, 下一步就有位子
同样 37 格活,看两种排法各搬几趟。
示意:请求长度是编排的,步数和空转格数由脚本模拟。
出处与口径

逐步调度:Orca(Yu et al., OSDI'22)的 iteration-level scheduling;论文在 GPT-3 175B 上报告同等延迟下吞吐是 FasterTransformer 的 36.9 倍。

⚠️ 示意:请求长度是编排的,假设一开始全在排队;两种调度的步数、空转格数由本脚本模拟得出。

动画里队列一直不空,看两组各做完几个。 (18 秒无声循环,Manim 渲染。请求长度是示意,每步按等长算,没画进门那步的 prefill,3.2 那支补上。)

Orca 是 2022 年 OSDI 上的一篇论文,也是论文里做的那套服务系统。今天没人直接跑它,跑的是它的招:论文叫迭代级调度,业界后来通称连续批(continuous batching),vLLM、SGLang 都按步调度。同延迟下,吞吐是 FasterTransformer(NVIDIA 早年的推理库)静态批的 36.9 倍(GPT-3 175B:每 token 中位延迟都压在 190 ms,每秒服务 0.185 → 6.81 个请求)。

3.2 新人进门:chunked prefill,一步里装了什么

长 prompt 切开喂 —— 别人的字间隔摊平,新人的首字晚一点 示意单位:decode 一步 1 格,长 prompt 的 prefill 8 格。混合步按两者相加计时 decode:老请求各出一个字 prefill:新来的长 prompt 正在出字的人,每个字隔多久 不切:一步吞下 prefill 8 格 最长字间隔 9 格 新请求首字在第 9 格 切成 4 块 prefill 2 格 prefill 2 格 prefill 2 格 prefill 2 格 最长字间隔 3 格 新请求首字在第 12 格 竖线 = 老请求出一个字。两行都在 12 格里出 4 个字 token 预算是一个旋钮,两头各拧一边 每步塞多少 prefill token(vLLM 的 max_num_batched_tokens):调小,字间隔稳;调大,首字快。 这只解决一半:prefill 和 decode 还挤在同一批卡上抢算力。彻底分开要靠 PD 分离:两种活放到两批机器上。
看正在出字的人最长间隔,和新人首字晚了几格。
示意单位;混合步按相加计时,偏保守。
出处与口径

chunked prefill:Sarathi(arXiv 2308.16369)、Sarathi-Serve(arXiv 2403.02310,stall-free 调度)。

vLLM 文档 Optimization 页:V1 默认开 chunked prefill、decode 优先;max_num_batched_tokens 小则 ITL 好、大则 TTFT 好。

本课程作者实测:gpu-tpu-pedia tpu/tpu-inference/Gemma4-31B/README.md:225-226(TPU v7x 上 --max-num-batched-tokens 16384,256K prompt 切成 16 块 16K)。

⚠️ 示意:格子数是编排的。混合步按相加计时偏保守,Sarathi 的观察是 decode 搭在 prefill 上几乎不额外花时间。

新请求的长 prompt 一口吞下,那一步就特别长,正在出字的人都卡一下。

Sarathi(arXiv 2308.16369)和 Sarathi-Serve(arXiv 2403.02310)把 prompt 切成小块,每步只带一块和 decode 拼着走,哪步都不会被拉长;延迟达标时能接的请求是 vLLM 的 2.6–3.7 倍。 引擎里 vLLM 2024 年 4 月先合入,SGLang 同年 7 月跟进;vLLM V1 默认打开,decode 先上车;每步塞多少 token 由 max_num_batched_tokens 控制。

TPU v7x 上跑 Gemma4-31B 的公开记录把它设成 16,384,256K 的 prompt 切成 16 块。

一步里装了什么:新人怎么接上。

一步里装了什么 —— decode 先占位,剩下的格子切给 prompt 示意:每步预算 10 格(真实 8K–16K),每格 = 一个 token;同一个人同一种颜色 实心:decode,每人 1 格、出 1 个字 浅色:prompt 块,最后一块那步出首字 每一行 = 一趟前向(一步) 第 1 步 A B C D E E E E E E E 切走 6 格,不出字 · D 出完最后一字,下车 第 2 步 A B C E E E E E E E E 剩下 7 格装完 → 这一步就出首字 · F 排不上 第 3 步 A B C E F F F F E 上车 decode · F 一块装完 → 出首字 · 空 2 格 第 4 步 A B C E F 没人排队:全是 decode · 空 5 格 新人没有「等着上车」那一下 看 E:第 2 步出首字,第 3 步已经是实心格。从门口到车上,没有哪一步空等。 看第 4 步:空着 5 格也照跑。预算是上限,没人排队就不凑。
每一行先排实心,剩下的才轮到浅色。
示意:规则照 vLLM V1 文档;预算、人数、prompt 长度是编排的,格子由脚本模拟。
出处与口径

调度规则:vLLM 文档 Optimization 页(V1 默认开 chunked prefill;先排全部 decode,预算有剩再排 prefill,装不下就切)。

SGLang 默认一步只跑一种:要么一块 prefill,要么全员 decode;开 --enable-mixed-chunk 才混(Server Arguments 页)。

⚠️ 示意:预算、人数、长度都是编排的;格子由 mix_sim 现算。

盯住 E:从门口到车上,中间没有停靠。 (42 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。规则照 vLLM V1;预算、人数、长度是示意,格子由脚本模拟。)

一步就是一趟前向。每步开头调度器排一次:车上的人各占一格,剩下的格子按排队顺序切给新 prompt(3.2)。拼好的这一行一起乘权重,只有注意力各读各的 KV(3.1 的选择性批处理)。

3.3 槽位满了以后

槽位满了再加并发 —— 吞吐几乎不动,多出来的人全在排队 GB300 · SGLang · DeepSeek-V4-Pro · dep8 decode · 8K 进 1K 出 · 吞吐按 output ÷ decode GPU 每张 decode 卡的吞吐 TTFT 中位数(含排队) 像一家坐满的餐厅 座位 = 槽位:全坐满了,翻台速度不变 并发 600 并发 1,200 并发 1,800 门口的队越排越长 = 首字等待 翻台速度:总负载 ×4.5,吞吐 +11% 8,777 并发 400 TPOT 58–59 ms 9,168 并发 600 TPOT 59–61 ms 9,280 并发 900 TPOT 62–63 ms 9,442 并发 1,200 TPOT 62 ms 9,745 并发 1,800 TPOT 60 ms 门口排队:首字等待 45 秒 → 253 秒 未记录 并发 400 45 秒 并发 600 未记录 并发 900 150 秒 并发 1,200 253 秒 并发 1,800
左边绿柱几乎一样高,右边红柱越来越高。
GB300 上 SGLang 跑 V4-Pro 的公开实测;TTFT 只记三档;排队人数按比例示意;并发按每个前端计,共 14 个。
出处与口径

本课程作者实测:gpu-tpu-pedia gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:593-609(并发 = 每路 conc × 14 个 frontend;ISL 8192、OSL 1024;--max-running-requests 8192;TTFT 只记了三档)。

⚠️ 餐厅里的人数是示意:14 个座位、门口排的人数按 TTFT 的比例画(45 : 150 : 253 秒 → 2 : 7 : 11 人,三档各画一排)。

Little 定律核对与「槽位不白给」实验(batch 886 → 999、TPOT 77.7 → 85.3 ms)见正文;出处同文件 794-801、849-858、885-894。

槽位就是 KV 池装得下几个人。Little 定律(见词表):批里的人数 ≈ 吞吐 × TPOT,反过来吞吐 ≈ 槽位数 × 1000 ÷ TPOT(ms)。

GB300 上 V4-Pro 的 dep8(第六节)实测每张 decode 卡 9,032 tok/s、TPOT 60 ms(gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:794-801,ISL 8K 的基线)。 客户端并发 8,400 路,进 decode 批的只有约一半,其余在 prefill 端排队。

Little 定律核一遍:批里到底几个人?

9,032 × 8 张 decode 卡 × 0.060 s 反推 decode 批里约 4,335 个请求,每卡约 542。

槽位也不白给。同一组实测多给 KV 池 13% 的显存(mem-fraction-static 0.85 → 0.88),每卡多装 13% 的人(886 → 999),端到端吞吐只多 0.8%,TPOT 从 77.7 拖到 85.3 ms:人多了,每步就长了。按 Little 定律,人多 13%、每步慢约一成,吞吐上限本来也只该涨约 3%(999 ÷ 886 × 77.7 ÷ 85.3 ≈ 1.027,本课推导)。

TPU 上多一层:batch 大小要落在档位上 XLA 按静态形状编译,batch 大小也是形状:人数不在预编译的档位上就补到最近一档,补的行照样计算(专题二「运行时,还是编译期」;选档见 14.1)。

CPU 那几毫秒也要藏起来。

CPU 排下一批,别让加速器干等 —— 12 ms → 38 µs 示意时间线。只有 12 ms、38 µs 两个数是原文的(SGLang-JAX,Qwen3-32B,prefill 与 decode 之间的空档) CPU:调度、拼 batch、准备输入 TPU:跑这一批 两条泳道:CPU 和 TPU 串行 CPU TPU 排 N 算 N 空等 排 N+1 算 N+1 空等 排 N+2 算 N+2 重叠 CPU TPU 排 N 算 N 排 N+1 算 N+1 排 N+2 算 N+2 空档 ≈ 12 ms 空档 ≈ 38 µs decode 一步越短,CPU 那几毫秒占得越多 批开得越大,CPU 要拼的东西越多;TPU 一步本来才几十毫秒,串着走就白白空掉一截。 SGLang-JAX 的做法是 TPU 跑第 N 批时 CPU 先排第 N+1 批,并提前为不同 batch 大小编译好计算图。
比两行 TPU:上面的「空等」格在下面没了。
时间线是示意,只有空档 12 ms 与 38 µs 是 SGLang-JAX 原文数字。
出处与口径

SGLang-JAX 博客(lmsys.org/blog/2025-10-29-sglang-jax)原文:For Qwen/Qwen3-32B, we reduced the time gap between prefilling and decoding from approximately 12ms to 38us, and from approximately 7ms to 24us。同文:The scheduler pre-compiles Jax computation graphs for different batch sizes。

⚠️ 示意:格子长短是编排的,CPU 与 TPU 段的比例不对应任何实测。

每步之前 CPU 要挑人、拼 batch、准备输入;串着走,加速器每步都要等它。

GPU 上,2024 年底 SGLang 的零开销调度把下一批的 CPU 准备和这一批的 GPU 计算重叠,吞吐是原来的 1.1 倍。2025 年 vLLM V1 吞吐最多是 V0 的 1.7 倍,原因之一是分词、回传等 CPU 活挪到了别的进程。

CPU 提前一步,怎么知道谁写完了?它不等。连续批每一步都重新组车,所以这道题每一步都有,不只在批次交界。SGLang 的重叠循环是:先把这一步发出去,再回头处理上一步的结果。

3.4 显存不够时踢谁

批开大了,KV 可能中途装不下,只能先请出去几个。回来两种办法:KV 换到主机内存再搬回(swap),或丢掉、重算 prefill(recompute)。

vLLM V1 默认重算,文档说 V1 里重算开销更低。

这一节只要带走一件事 逐步调度是「一趟分给更多人」的地基。槽位满了,吞吐就钉在槽位数 × 1000 ÷ TPOT 上,再加并发只加排队。 chunked prefill 只摊平打扰,拆到两批机器上是第八节的事。 留下的问题:槽位数由显存里的 KV 定,而 Orca 给每人按最大长度预留一整段 KV,实际只用上两到近四成(第四节)。
考考自己:TPOT 稳定在 50 ms,想让每张卡出 10,000 tok/s,每张卡的批里至少要同时坐多少人?显存只装得下 300 人时会怎样?

10,000 × 0.05 = 500 人。只装得下 300 人,吞吐钉在约 300 × 1000 ÷ 50 = 6,000; 要么少搬(第十二节末尾的 FP8 KV 让每条 KV 约减到 61%,含索引键),要么换个交互档。

第 四 节

KV cache:账、池、复用

上一节的槽位要靠 KV 撑:每条在跑的序列都在显存里单独占一块 KV。Orca(2022)已让每步都能换人,KV 却按最长预留,只用上两到近四成。 KV 池装得下几条序列,decode 每一趟搬运最多就分给几个人。 2023 年 vLLM 的 PagedAttention 起,几招都在同样的显存里多装人、少重算。

4.1 一个 token 留下多少字节,batch 就能坐多少人

按 bf16、所有层合计;存 fp8 约减半(MLA 见 12.4)。字节数取自各模型 config.json,本课推导;Qwen3.5 线性层状态按 fp32 算(config 的 mamba_ssm_dtype);MHA 一行按 DeepSeek-V2 论文的口径(K、V 各 128 维 × 128 头)。
记法每层存什么每 token 字节例子
MHA(2017)每个头各存一份 K、V3,997,696V3 的形状假如用 MHA;128K 一人约 524 GB(488 GiB),一颗 192 GiB 的芯片装不下(本课推导)
GQA(2023)几个头共用一组 K、V327,680Llama-3.1-70B:8 组 × 128 维 × 80 层
MLA(2024)一条压缩向量,所有头从它解出 K、V70,272DeepSeek-V3:(512 维压缩 KV+64 维位置编码那截) × 61 层(不含 MTP 层)
线性注意力(2020)不按 token 存,每条序列一个大小固定的状态0(另交固定状态)Qwen3.5:45 层线性层每条序列 180 MiB,另 15 层全注意力 30,720 B/token

GQA 省下的不只是字节:解码快五倍多,平均分几乎不掉。原论文(2023)在 TPU v4 上把 T5-XXL 改成 8 组,每条样本的解码时间从 1.51 降到 0.28,约快 5.4 倍(本课推导,1.51 ÷ 0.28);平均分 47.1,原版 MHA 是 47.2。走到头所有头共用一组,就是 MQA(0.24、46.6):再快一点,掉分多。

DeepSeek 自家这条线后来又改了三代。V3.2 的 DSA 存的一点没少,省的是读:先用小打分器扫一遍历史,只读挑中的。V3.2-Exp 报告说架构上只改了这一处,基准和改之前的 V3.1-Terminus 基本持平(MMLU-Pro 都是 85.0,HLE 从 21.7 降到 19.8);省多少只画了按租卡价算的成本曲线,没给比值。V4 存和读都改:沿 token 方向把相邻几个 token 并成一条,另开滑窗池原样留最近一段(分预算见 4.2);其中压得轻的层还照 V3.2 只挑一部分读。

DSA 省的是读 —— V4、V4.1-Flash 省的是存 DeepSeek 一条线上的四代,每代一列。上排:每个 token 存下多少 KV;下排:生成一个字时读回多少。方块只是示意,不按比例 存着的 KV 生成这个字时读的 黄框:这一代改的是这一排 2024 DeepSeek-V3 MLA 2025-09 V3.2-Exp MLA + DSA 2026-04 V4 CSA + HCA 2026-09 V4.1-Flash 跨层共用 + FP4 存:每个 token 留下多少 存 省存 省存 每个 token 存一条 70,272 B(61 层合计) 照 MLA 存,一条不少 和左边一样多 CSA 4→1 HCA 128→1 最近 128 个 每层一条,所有头共用; 再沿 token 方向压 CSA 4→1 HCA 128→1 最近 128 个 890 B/token 约 V4-Flash 的 1/4 几层共用一份,主 KV 存 FP4 读:生成一个字时读回多少 读 省读 每个字读全部历史 只读挑出的 2,048 个 打分器仍扫全部(头少、FP8) CSA 4→1 HCA 128→1 CSA 只挑一部分读,HCA 全读 索引 K 也跨层共用
只有 DSA 那一列是下排变少,后两列变少的是上排。
方块示意,不按比例;各数出处见文末台账(V3.2-Exp、V4 技术报告与 V4.1-Flash 模型卡)。
出处与口径

出处:MLA 每 token 70,272 B 见 3.1 表格(V3 config.json,(512+64) × 61 层 × 2 B,本课推导)。DSA 每字读 2,048 个 token 见 DeepSeek-V3.2-Exp 技术报告 §2.1;打分器(lightning indexer)仍对全部历史打分、头少、可跑 FP8,同一报告 Inference Costs 一节。

出处:CSA 每 4 个 token 压成一条、HCA 每 128 个压成一条,见 DeepSeek-V4 技术报告 §2.3;最近 128 个 token 的滑窗取自 Hugging Face DeepSeek-V4-Pro config.json(compress_ratios、sliding_window)。

出处:V4.1-Flash 各层共用主 KV 和索引 K、主 KV 存 FP4、全局 KV 每 token 890 B、约 V4-Flash 的 1/4,见 Hugging Face deepseek-ai/DeepSeek-V4.1-Flash 模型卡。

口径:方块个数和压缩块宽度是示意,不按比例;V4、V4-Flash 每 token 的字节数原文没给,图里不画;V4.1-Flash 读法的变化模型卡没写,那一格只记索引 K 共用。

batch 上限 = KV 池 ÷ 每条序列的 KV。账要按 device 算:一颗 v7 芯片在软件里是两个 device,各有 94.75 GiB,不能当一整块用。8 颗芯片=16 个 device,每个 device 扣掉激活值和分到的那 1/16 V3 权重,剩下的给 KV(拆法见图)。每条序列的 KV 整条住一个 device(注意力走数据并行,见第六节),所以池子除以每条的 KV 就是装几条。权重这里按全切粗算;实际非专家权重每个 device 各存一份,池子更小。

上下文长到 8 倍,纯注意力只装得下 1/8,线性混合还剩 1/4 以上 —— KV 的记账方式决定 batch 上限 一个 v7 device,V3 权重铺 8 颗芯片 = 16 个 device 后剩下的空间全给 KV。横轴上下文长度,纵轴能同时装下几条序列(对数,向下取整) MLA · DeepSeek-V3 线性+全注意力 · Qwen3.5 形状 GQA · Llama-3.1-70B MHA · V3 形状(假想) 一个 device 可用的 94.75 GiB(一颗芯片 = 两个 device) V3 权重的 1/16(FP8):39.1 GiB 留 10% 9.5 GiB KV 池:46.2 GiB 能同时装几条序列 1 10 100 1000 1K 2K 4K 8K 16K 32K 64K 128K 上下文长度(对数,每格翻倍;1K = 1024 token) 条 172 21 5 条 MLA 70,272 B/token 157 41 11 条 线性+全注意力 30,720 B/token + 180 MiB/条 36 4 1 条 GQA 327,680 B/token MHA:16K 起一条都装不下 12 3 装得下几条序列,每趟搬运就分给几个人 MLA 在 4K 装 172 条,32K 只剩 21 条。线性层每条序列先交 180 MiB 固定状态: 4K 时反而比 MLA 少装(157 < 172),128K 时是 MLA 的两倍多(11 > 5)。
纯注意力三条线往右一格人数减半;紫线先交固定状态,少得慢;红线 32K 起装不下。
口径同正文;KV 按 bf16、attention 数据并行。本课推导。
出处与口径

出处:每 token KV:V3 (512+64)×61×2 B = 70,272(config.json);Llama-3.1-70B 2×8×128×80×2 = 327,680(HF config.json);Qwen3.5 全注意力 15 层 × 2 头 × 256 维 × K、V × 2 B = 30,720,线性层状态 45×64×128×128×4 B = 180 MiB(HF config.json,mamba_ssm_dtype float32)。

口径:MHA 一行是 V3 形状的假想(128 头 × 128 维,专题三第一题):3,997,696 B/token。

本课推导:v7 一颗芯片对软件是两个 device,各管自己的显存,按 device 记账;V3 权重全按 FP8 1 B/参数算 671 GB ÷ 16 个 device = 41.9 GB = 39.1 GiB;每 device 实测可用 94.75 GiB(tpu-inference R1 FP4 README),再留 10% 给激活(本课假设);KV 池 = 94.75 GiB × 0.9 − 39.1 GiB = 46.2 GiB,先按权重全切粗算,DP attention 下非专家权重每个 device 各一份,实际更少。假设 attention 走数据并行(每个 device 只存自己那几条序列);若 attention 走 TP,MLA 的 KV 每个 device 复制一份(专题五)。

口径:没算激活与通信缓冲(归入那 10%)、线性层卷积状态、引擎实际的状态 dtype(可能不是 fp32)。

上下文越长人越少,一趟搬运分到的 token 越少:这是长上下文贵的第一个原因。

4.2 PagedAttention 分页,混合模型分两个池

早先按最大长度给每条序列预留一整段连续显存。PagedAttention 把 KV 切成固定大小的块,用页表记每块住在哪。

页表让 KV 不必连续存放 —— 共用的前缀只存一份,谁要改谁复制 两条采样共用同一个 prompt。每块 4 个 token(仅为示意) 两条共用 只属于 A 只属于 B 空闲块 逻辑上:每条序列以为自己是连续的 物理上:显存里零散的块 序列 A 请 写 一 首 第 0 块 关 于 秋 天 第 1 块 的 诗 : 落 第 2 块 叶 第 3 块 A 的页表 第 0 块 → 1 第 1 块 → 3 第 2 块 → 4 第 3 块 → 6 序列 B 请 写 一 首 第 0 块 关 于 秋 天 第 1 块 的 诗 。 枫 第 2 块 B 的页表 第 0 块 → 1 第 1 块 → 3 第 2 块 → 7 块 0 空闲 块 1 请 写 一 首 两条共用 块 2 空闲 块 3 关 于 秋 天 两条共用 块 4 的 诗 : 落 A 块 5 空闲 块 6 叶 A · 没写满 块 7 的 诗 。 枫 B 的拷贝 B 要往里写, 先复制一份
绿色两块两条序列共用,橙色那块是 B 要改时复制的。
每块 4 个 token 只为画得下;机制见 vLLM 论文(arXiv 2309.06180)。
出处与口径

出处:Kwon et al., Efficient Memory Management for LLM Serving with PagedAttention(SOSP'23, arXiv 2309.06180)—— 块级写时复制、并行采样与 beam search 共享块;原文统计既有系统 KV 显存里真正存 token 状态的只有 20.4%–38.2%,vLLM 达 96.3%。

口径:每块 4 个 token 只为画得下;真实系统常用 16(GPU)或 256(TPU 上这个模型)。物理块编号是示意。

盯住块 2 和块 5:请求 2 一还,请求 4 就住进去;再看同一个请求的块散在各处。 (18 秒无声循环,Manim 渲染。块大小、块数、请求长度都是示意。)

混合模型有两个池,预算要分。SGLang 让 V4 两个池共用一份显存预算,用 --swa-full-tokens-ratio 定隔板。滑窗池每条用量封顶,全长池随输入变长一直涨,隔板因此跟着输入长度挪。

一份预算一块隔板 —— 隔板挪到两边一起满,吞吐高 54% V4-Pro 每层两个 KV 池,共用一份显存预算:滑窗池只留最近 128 个 token,全长池存压缩后的整段。ratio = 滑窗池 ÷ 全长池,就是隔板的位置 已用 约九成以上,算满 输入 4K · 全长池先满 一份显存预算 隔板 ratio 0.20 93% 全长池 满 63% 滑窗池 6,887 tok/s(每张 decode GPU) 输入 4K · 两个一起快满 一份显存预算 隔板 ratio 0.15 92% 全长池 满 89% 滑窗池 满 10,614 tok/s(每张 decode GPU) 输入 8K · 滑窗池先满 一份显存预算 隔板 ratio 0.10 78% 全长池 96% 滑窗池 满 9,354 tok/s(每张 decode GPU) +54%
隔板挪到两池一起快满时最快;一边先满,另一边就空转。
V4-Pro 在 GB300 上的 SGLang 实测,按单卡计;前两格输入 4K、第三格 8K,输出 1K,关前缀缓存。
出处与口径

出处:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md §11.5 消融表(约 L849–866)与结论(L872–896):ISL 4096/8192、OSL 1024、--disable-radix-cache;吞吐是每张 decode GPU 的 e2e 输出 tok/s;占用是 full/swa 两池峰值;每 rank 请求数 727/886/999/588/410。

出处:swa_tokens = full_tokens × ratio(runbook L946 引 pool_configurator.py:387);V4 是 CSA+HCA 混合注意力,不是 MLA;sliding_window 128 取自 HF config.json。

本课推导:+54% = 10,614 ÷ 6,887。图里只画三个状态;同表另两行:4K · ratio 0.15 + mem-frac 0.88 为 10,704(多装 13% 的人,只快 0.8%),8K · ratio 0.15 两池都没满(0.80/0.37)、每 rank 只有 410 条,runbook 没有解释原因,这里照录不推断。

口径:8K 那一格输入长度不同,吞吐不和左边两格直接比;隔板位置是示意,不代表真实字节比。

第三格为什么反过来是滑窗池先满?因为隔板已经不在原处。输入翻到 8K,每条在全长池里的用量跟着涨,滑窗池每条仍只留 128 个,所以隔板往滑窗池那边挪,从 0.20 挪到 0.10,把预算让给全长池。这一下挪得稍多,滑窗池先满,但两边已接近平衡。同样 8K 放在 0.15,两池都没满(全长池 80%、滑窗池 37%),每卡只装 410 条、9,053 tok/s;实测 8K 的甜点在 0.10–0.12。

两边一起满之后再多装人,吞吐几乎不涨(3.3):瓶颈从装不下换成了算不动。

两个池各装什么。不是「一部分层记全文、一部分层只看近处」,而是每一层都两样都有。V4-Pro 61 层:30 层 CSA(4 个 token 并一条,再挑 1,024 条读)、31 层 HCA(128 个并一条),每层另留最近 128 个 token 的原样 KV。

比例能算吗?大致能。比例 = 滑窗池 ÷ 全长池(按 token 槽算)。每个请求在滑窗池里要的不止 128 槽:SGLang 还要给滑窗淘汰留余量(默认每 128 步淘汰一次,开投机再乘草稿数)、按页对齐、给下一步预留,合起来是几百槽,跟输入长度无关;在全长池里要的约等于它的总长度。所以最优比例 ≈ 每请求固定的滑窗槽数 ÷ 平均序列长度,输入翻倍,比例大致减半。拿 4K 甜点反推:车上每人平均约 4,600 个 token(输入 4,096,输出 1,024 平均写到一半),× 0.15 ≈ 700 槽(本课推导,只看量级)。

新版 SGLang 已经能自动配。按 2026 年 10 月的源码,不显式传 --swa-full-tokens-ratio、又给了每卡最多几个请求时,滑窗池直接按「每请求最坏要几槽 × 请求数」加一点前缀缓存余量来留,剩下的全给全长池;条件不满足才退回默认比例 0.1。我们七月那次是手动给的比例,所以要自己扫。

池子算错不一定报错:tpu-inference 跑 Qwen3.5 时块编号池大了约 3.5 倍,越界写入被静默钳回末尾,输出乱码。

4.3 前缀复用:算过的不再算

很多请求开头一样(同一段 system prompt、多轮对话的前几轮),这段的 KV 留着,下一个直接接着算。

命中的前缀不用重算 —— 首字从 13 s 降到 0.5 s DeepSeek 线上服务,把算好的 KV 存在磁盘上。上:一条 128K 高复用 prompt 的首字延迟(线性,0–14 s);下:一天的输入里有多少命中 不命中:prefill 重算整段前缀 命中:从磁盘读回 KV 128K prompt 的首字延迟 0 s 2 s 4 s 6 s 8 s 10 s 12 s 14 s 不命中 命中 重算 128K 前缀 13 s 0.5 s 首字(含读盘) ≈ 1/26(本课推导:13 ÷ 0.5) 24 小时的输入 token(另一份统计,2025-02) 6,080 亿 56.3% 命中磁盘上的 KV 43.7% 不命中(本课推导:100 − 56.3) 0% 100%
上栏是一条请求能省多少,下栏是一天的输入里多少能这样省。
首字延迟出自 DeepSeek API 文档 2024-08,命中比例出自 open-infra-index 2025-02,两次统计不同时;1/26 为本课推导。
出处与口径

出处:首字 13 s → 0.5 s 取自 DeepSeek API 文档的磁盘缓存公告(api-docs.deepseek.com/news/news0802,2024-08,原文 128K prompt with high reference)。

出处:6,080 亿输入 token、56.3% 命中取自 DeepSeek open-infra-index 202502OpenSourceWeek day_6(统计窗口 2025-02-27 12:00 到 02-28 12:00 UTC+8,608B 里 342B 命中,V3 与 R1 合计)。

本课推导:13 ÷ 0.5 = 26;100% − 56.3% = 43.7%。两个数来自两份文档、两个时间点,不是同一次测量。价格不画。

看每个请求往下找了几层,以及显存满时谁被挤下去。 (27 秒无声循环,Manim 渲染。层的容量、块的摆放和四个请求是示意,命中哪层由 LRU 现模拟。)

线性注意力和滑窗难复用:线性层的状态截不回任意位置,滑窗层早先的 KV 已经丢了,只能隔一段存一份快照(第十三节)。

4.4 分层卸载:搬回来,还是重算

显存留不下所有想复用的 KV,就往下放到主机内存、磁盘乃至远端存储,用时搬回。

盈亏带宽 搬回 = 每 token KV 字节 × L ÷ 带宽;重算 ≈ 每 token FLOP × L ÷ 有效算力。L 是命中的前缀长度,有效算力是峰值乘利用率。
两者相等时:带宽 = 每 token KV 字节 × 有效算力 ÷ 每 token FLOP。链路比它慢,就不如重算。
公式只算线性部分,注意力那项随 L² 涨,越长越该下放(图里算进了它)。负载高时重算挤占别人的算力、搬回能和计算重叠,盈亏点再往慢链路移。
搬回来还是重算?比的是一个字节的 KV 值多少 FLOP —— V3 的 KV 很省,2.19 GB/s 就够 横轴:命中的前缀有多长;纵轴:把这段前缀的 KV 准备好要多久(都是对数)。每芯片口径,DeepSeek-V3 重算(prefill 一遍) 从 20 GB/s 的地方搬回 从 2.19 GB/s 的地方搬回(盈亏线) 从 1 GB/s 的地方搬回 准备好一段前缀的 KV 要多久 1 ms 10 ms 100 ms 1 s 10 s 256 1K 4K 16K 64K 128K 命中的前缀长度(token,对数) 重算 20 GB/s 搬回 2.19 GB/s 搬回 1 GB/s 搬回 交点 ≈ 35K token 短于它,1 GB/s 不如重算 短前缀:两条重合 再往右重算变陡: 注意力的平方项接管
绿线始终在红线下面:链路够快,多长都该搬。
灰虚线是盈亏带宽 2.19 GB/s;每芯片口径;有效算力按 FP8 峰值 50% 假设,两档带宽是示意值。本课推导。
出处与口径

本课推导:重算 = (2×37e9×L + 4,997,120×L²/2) ÷ (4,614 T × 50%);注意力每对 (q,k) = 2×128 头×(192+128)×61 层 = 4,997,120 FLOP。搬回 = 70,272 B × L ÷ 带宽。盈亏带宽 = 70,272 × 2,307 T ÷ 74 G ≈ 2.19 GB/s(只按线性项算,偏保守);GQA 的 Llama-3.1-70B 同法得 5.35 GB/s。

假设:prefill 跑到 FP8 峰值的 50%;1 GB/s 与 20 GB/s 是示意档位,不对应具体硬件;只比带宽与算力,不含延迟、排队和与 decode 抢带宽。每芯片口径 = 假设算力和 KV 字节按芯片数等比摊开。

出处:Llama-3.1-70B 激活参数 70.6B 取自 HF 模型页;KV 327,680 B/token 取自 config.json。

V3 的 KV 省,盈亏线很低;GQA 的 Llama-3.1-70B 每 FLOP 摊到的 KV 字节多,链路至少 5.35 GB/s 才划算。

这一节只要带走两件事 ① KV 池定了 batch 上限。
② 复用和卸载是少算、少搬。下放之前算清搬回来是不是比重算快。
留下的问题:座位坐满以后,一步本身的时间还压不下来,注意力和 MoE 是两块硬骨头(第五节)。
考考自己:一个 v7 device 的 KV 池是 46.2 GiB,V3 跑 64K 上下文能装几条?要是把 KV 存成 fp8 呢?

每条 70,272 × 65,536 字节 ≈ 4.29 GiB,装 10 条。存 FP8 按 12.4 的布局每 token 40,016 字节,约装 18 条(严格减半才是 21 条)。

第 五 节

单卡里的两块硬骨头:decode 注意力与 MoE

座位坐满后,权重一趟已分给几百人,每一步本身却还慢。一张卡上的 decode 有两块最难啃:注意力读的是每个人自己的 KV(5.1、5.2),MoE 的每个专家只分到几行(5.2)。两块都是搬运问题。最后补一条小 AllReduce(把各卡的部分和加起来再发回每张卡,5.3),它卡的是延迟。

5.1 注意力 kernel:攒 batch 救不了,只能把搬运做顺

长上下文除了占座位(第四节),每人每步要读的 KV 也更长,且各读各的,攒 batch 摊不薄。

decode 注意力每读 1 字节只做 G 次运算(G = 几个查询头共用一个 KV 头),推导见专题三 §3.1。Llama-3.1-70B 64 个查询头配 8 个 KV 头,G=8,v7 的屋脊点 313 是它的近 40 倍。

攒 batch:权重一趟分给所有人,KV 每人一份 —— batch 越大,KV 越成主角 柱高 = decode 一步要从显存读的字节(全模型合计,不分卡);柱顶 = 摊到每个 token 的字节。Llama-3.1-70B,bf16,每条序列上下文 8K 权重:一步读一遍,所有序列共用 KV:每条序列读自己的 一步要读多少字节 0 GB 100 GB 200 GB 300 GB 400 GB 500 GB batch 1 每 token 143.8 GB 141 GB KV 2.68 GB batch 16 每 token 11.5 GB KV 43 GB batch 64 每 token 4.89 GB KV 172 GB batch 128 每 token 3.79 GB KV 344 GB batch ≈ 53 时 两块一样重
柱顶的数越降越慢:权重摊薄了,紫段摊不薄。
只记读显存的字节,没算激活值和 logits(给词表里每个字打的分)。
出处与口径

📌 Llama-3.1-70B config.json:hidden 8192、80 层、64 查询头、8 KV 头、每头 128 维、intermediate 28672、vocab 128256、词表不共享。参数量按 config 现算 = 70,553,706,496,×2 字节正好等于 safetensors index 的 total_size 141,107,412,992。

本课推导:每 token 的 KV = 2(K、V)× 8 头 × 128 维 × 2 字节 × 80 层 = 327,680 字节;上下文 8K 时每条序列 2.68 GB;141.1 ÷ 2.68 ≈ 52.6,就是两块一样重的 batch。没算激活值、logits 和读进来就丢的东西;模型实际要切到好几张卡上,这里是全模型合计。

注意力每字节 8 次运算的推导见专题三 §3.1 图下:读 4·S·d 字节、算 4·G·S·d 次,比值 = G。

batch 小、序列长时,注意力的活只按 batch 和头分给计算单元,份数太少,单元大半闲着。 Flash-Decoding(斯坦福 CRFM 博客,2023-10)把每条序列的 KV 切成几段同时读,最后合并(7.1 有图)。

名字借自 FlashAttention(0.1)。博客在 CodeLlama-34B 单请求上报,序列很长时 Flash-Decoding 最多是旧实现的 8 倍。

一个 kernel 装下 prefill 和 decode。chunked prefill 让一步里混着 prefill 和 decode。RPA(Ragged Paged Attention,2025 年进 vLLM 的 TPU 后端)把两者放进同一个注意力 kernel(arXiv 2604.15464 §3.4–3.5)。GPU 上做同一件事的是 FlashInfer(MLSys 2025),已是 SGLang、vLLM 的注意力后端之一。

一个 kernel 装下 prefill 和 decode —— 先分段,再派给三份预编译版本 左:一批怎么拆给三份版本(示意);右:KV 页大小这个旋钮(Qwen3.5-397B,TPU7x) decode 请求:1 个新 token prefill 请求:一段多个 token KV 页 同一批,按成分分三段 一批 纯 decode 版 每条 1 token · 自带块大小 纯 prefill 版 定长分块 · 自带块大小 混合版 长度不定 · 自带块大小 KV 页大小:另一个便宜的旋钮 页 16 个 token 页太小:查索引让向量单元频频停顿 428 µs 页 256 个 token 283 µs 并发 512 · 这个 kernel 的 decode 一步,不是整步
左边看箭头:一批切成三段,各走一份版本;右边比两根条。
段的切法和请求数是示意;页的格数只表示比例。
出处与口径

分段与三份预编译版本:Ragged Paged Attention,arXiv 2604.15464 §3.4–3.5,段序按原文:纯 decode、定长分块 prefill、长度不定的混合段。每段几条请求、块大小都是示意。

页大小:Google Developers Blog「Systems Engineering Playbook: Optimizing Qwen 3.5-397B MoE on Ironwood (TPU7x)」,原文 decode step latency under Concurrency-512 from 428µs to 283µs(kernel-level)。页的格数只表示 16 与 256 的比例。

RPA 在 TPU7x 上跑 Llama 3 8B,decode 最多用到峰值带宽的 86%,prefill 最多用到峰值算力的 73%,三招拆解见专题三 §9.2。图右数据出自 Google 开发者博客的公开调优。

KV 一页页怎么搬上芯片。MLP 和专家那边,一批里的 token 不分是谁的,都是矩阵的一行,权重搬一次全员算完。注意力不行:每条序列的 KV 是它自己的私货,并发 512 就是 512 份,谁也替不了谁。所以注意力 kernel 能做的只剩一件:每个字节只搬一次,搬的时候别让计算单元等。

KV 一页页怎么搬上芯片 —— 按页表取,边算边搬,一块喂一组头 示意:每页 4 个 token、每块 2 页、3 条序列;同一条序列同一种颜色 A:15 个 token B:10 个 token C:3 个 token 显存(HBM):KV 页池 空 A 第 2 页 B 第 3 页 空 A 第 4 页 空 A 第 1 页 C 第 1 页 空 B 第 1 页 空 A 第 3 页 空 空 B 第 2 页 空 A 的页表:格 7 → 格 2 → 格 12 → 格 5 B 的页表:格 10 → 格 15 → 格 3 C 的页表:格 8 片上(VMEM):两个槽 槽 1 正在算:A 块 1(8 个 token) A 第 1 页 A 第 2 页 槽 2 正在搬来:A 块 2(7 个 token) A 第 3 页 A 第 4 页 两页挨着放:散页拼成连续的一块 一块 KV 喂一组查询头 查询头 1 查询头 2 查询头 3 查询头 4 A 块 1 的 K、V 片上只放一份 4 个头摞成 4 行,一起乘这一块 搬一次,用 4 次:每读 1 字节做 G 次运算 时间轴:搬总比算早一格 搬(显存 → 片上) 算(注意力) A 块 1 · 8 个 A 块 2 · 7 个 A 块 1 B 块 1 · 8 个 A 块 2 B 块 2 · 2 个 B 块 1 C 块 1 · 3 个 B 块 2 C 块 1 ↑ A 还没算完,B 块 1 已经在路上 每个字节只搬一次,算的时候下一块已在路上 看页池和槽:散页按页表拼成一块搬上片;C 只有 3 个 token,就只搬 3 个。 看时间轴:搬总比算早一格,序列交界也不停;右边 4 个头共用同一块 K、V。
先看中间两个槽:一个在算,一个在装下一块;再看时间轴,搬总比算早一格。
页、块、序列长度、G=4 都是示意;规则照 RPA 论文。
出处与口径

搬运规则:Ragged Paged Attention,arXiv 2604.15464。按页表从显存取页、和本步新算的 KV 拼成片上连续的一块(§3.3「Fetch B_kv」);Q、KV、输出三类块都双缓冲,算第 j 块时已发起第 j+1 块的 DMA,一条序列算完就接着取下一条的第一块(算法 1 第 7–13 行);DMA 只搬有效长度(§3.4 开头);同组查询头摞成 c_q·h_g 行,对同一块 K、V 算(§3.1.2)。

本步新算的 KV 也在流水线里异步写回页池(§3.3「Update U_kv」),图里没画。

⚠️ 示意:页大小、块大小、序列长度、页号、G=4 都是编排的;时间轴每格等宽,真实耗时随 token 数变。

盯住两个槽:一个在算,另一个总在装下一块。 (30 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。规则照 RPA 论文的流水线;页、块、长度是示意。)

RPA 的做法(arXiv 2604.15464 §3.3、算法 1)拆开是五件事:

拿并发 512、每条 2K 到 8K 算一笔:平均 5K 的话,decode 一步每层要把约 256 万个 token 的 KV 过一遍(本课推导:512 × 5,000)。这个量躲不掉,能抠的是每趟搬运的效率。两个办法:页调大,查页表的次数就少,向量单元不再频频停下来等索引(5.1 图右,428 → 283 µs);K 和 V 并进一趟搬(5.1,论文 §3.1.3)。

prefill 是另一回事:一块查询有几百行,同一块 KV 被这么多行共用,每读一字节的运算跟着多出几百倍(本课推导:G × 查询行数),瓶颈回到算力,走的是 FlashAttention 的路数。所以 RPA 给 decode 和 prefill 各调一套块大小:decode 调到吃满带宽,prefill 调到矩阵单元不空(RPA 论文 sec. 3.5)。

稀疏注意力的 prefill:挑出来的,反而按稠密算。DSA 每个查询只挑 2048 个位置(4.1)。decode 一次一行,照着挑的去 gather 正合适;prefill 几千行查询各挑各的,挑中的大量重叠,gather 会把同一行搬上千遍。一篇公开工程博客在 TPU v7 上量到:为取不到 2048 个不同行,物化出约 419 万行,稀疏路径 96.3% 的设备时间花在 gather 上。

改法是不搬:把每行挑中的位置写成一张位图(在 SparseCore 上做),整块做稠密注意力,没挑中的掩掉,结果与稀疏等价。这正对上面那句:prefill 吃的是算力,矩阵单元最擅长整块算。4K 输入的首 token 时延 1338.81 → 729.04 ms。KV 太长时稠密不划算,按成本模型在设备上选路,原文的分界是 KV ≤ 9216。

位图还能跨层共用。挑位置不必每层都做:Hy4 的 78 层里只有 21 层算 top-k,其余层沿用前面算好的。位图跟着复用,高并发混合步里单这一项吞吐 +5.6%。

布局:窄维被补成整块。TPU 的显存按 tile(图里的「标准箱」)存:最内层(内存里连续排的那一维)和次内层都要补齐,fp8 的次内层补到 32 行。

KV 头只有 1–2 个,若头这一维落在这两维上,就可能被补成整块,多出的全是空位。

布局像装箱:一双袜子装进标准箱,空的也占地方 —— FP8 可能一个字节都没省 要装的:一个 token、一层的 K+V(2 个头 × 128 维,bf16,共 1 KiB)。TPU 显存按「标准箱」存:一箱 4 KiB,横 128 格 × 竖 16 行,装不满也算一整箱 真数据(袜子) 一只 4 KiB 的标准箱 A 头数占了「横 128 格」那一维 每行 128 格只用 2 格 16 箱 · 64 KiB 是真数据的 64 倍 B 头数占了「竖着凑行」那一维 每箱 16 行只用 2 行 K V 换成 FP8:还是 2 箱、8 KiB 一个字节都没省 2 箱 · 8 KiB 是真数据的 8 倍 C K、V 并起来,换小箱 小箱正好装满 小箱 = 标准箱的 1/8 2 只小箱 · 1 KiB 一点不浪费
同一份 KV,看三种摆法各占多大地方。
按默认 tile 推导;编译器对极窄的数组有时改用更小的 tile,见出处。
出处与口径

📌 tile 规则:openxla.org/xla/tiled_layout —— TPU 最常见的 tile 是 8×128,对应 8×128 个 32 位的向量寄存器;16 位类型沿次内层把两个值拼进一个 32 位,8 位类型拼四个。于是默认 tile 的次内层 bf16 是 16 行、fp8 是 32 行,每块都是 8×128×4 = 4,096 字节(本课推导)。图里「标准箱」就是这块默认 tile。

窄头数被补齐、加 packing 维逼 XLA 选最小 tile T(packing,128)、把 K 和 V 沿头维并起来:Ragged Paged Attention,arXiv 2604.15464,sec. 2.1.2、3.1.1、3.1.3、3.5。

本课推导:占用 = ⌈次内层 ÷ 每块行数⌉ × 每块行数 × ⌈最内层 ÷ 128⌉ × 128 × 每元素字节。A:头数在最内层(128 格),⌈128÷16⌉=8 块 ×2(K、V);B:头数在次内层,K、V 各 1 块;C:4 行 ÷ 每块 2 行。FP8 时:A 32 KiB(仍 64 倍)、B 8 KiB(16 倍)、C 512 B。

XLA 对次内层只有 1–2 的数组有时会改用 2×128 的小 tile(同一份 openxla 文档的 Compact 2nd Minor Layout),具体选哪种由 XLA 的 layout assignment 决定;进到 kernel 里,向量寄存器仍是固定的 8×128×32 位。本图按默认 tile 画。

RPA 的解法是加一个打包维、把 K 和 V 沿头维并起来,逼编译器选最小的 tile(论文 3.1 节)。

5.2 V3 专用:MLA 一个阶段一套算法,MoE 全算比排序便宜

专题三 §5.2 推过「吸收」:把投影并进查询,所有头直接对同一条压缩后的潜向量算,K/V 不展开。那是 decode 用的,prefill 呢?

MLA 的两种算法:一条大家共读,还是先复制 128 份 —— decode 用吸收,prefill 用展开 DeepSeek-V3,一层、一个缓存 token。右边的大数:每从显存读 1 字节,做几次运算 吸收:压缩 KV 不展开 展开:还原成每个头一份 吸收:一条压缩 KV,128 个头一起读 缓存里的 1 个 token 576 维 同一条,读一次 … 共 128 个头 242 次运算 / 每读 1 字节 → decode 用它 展开:先复制成 128 份,每个头读自己那份 缓存里的 1 个 token 576 维 复制、还原 320 维 320 维 320 维 320 维 320 维 320 维 128 份 … 共 128 个头 1 次运算 / 每读 1 字节 → prefill 用它
上下两栏的头一样多,差别只在箭头从哪条数据出发。
乘加按 2 次运算计,bf16;没算把查询吸收进去、把输出投影回来的那两次矩阵乘。
出处与口径

📌 DeepSeek-V3 config.json:128 头、kv_lora_rank 512、qk_nope_head_dim 128、qk_rope_head_dim 64、v_head_dim 128、num_key_value_heads 128。吸收的做法与「只在 decode 划算」出自 DeepSeek-V2 arXiv 2405.04434 §2.1.2;专题三第五章讲过推导。

本课推导(只数注意力本身的乘加,乘加算 2 次运算,bf16):吸收 = 2 × 128 × (576 + 512) = 278,528 次,读 576 × 2 = 1,152 字节,比值约 242;展开 = 2 × 128 × (192 + 128) = 81,920 次,读 128 × 320 × 2 = 81,920 字节,比值 1。prefill 里每对(查询,历史 token)吸收的运算是展开的 3.4 倍。没算把查询吸收进去、把输出投影回来的那两次矩阵乘(每个查询做一次,跟历史长度无关),也没算 prefill 展开 K/V 的一次性开销(每个历史 token 一次,被所有查询分摊)。

画法:576 维画成一条,展开后每份 K+V 共 320 维按同一比例;128 个头只画 6 个。

decode 缺带宽,用吸收;prefill 缺算力,要的是少算。每个头对每个历史 token,吸收要和 576 维的潜向量做点积、再按其中 512 维加权求和,共 1,088 次乘加;展开后每头 K 192 维、V 128 维,共 320 次,吸收是展开的 3.4 倍(V3 config 推导)。展开多读的字节,prefill 有富余带宽兜着。

decode 的 MoE:全算比排序便宜。1.2 算过,decode 时每个专家平均只分到几行;与其按专家把 token 排序分组,不如让所有 token 都过一遍,没选中的乘 0。

decode 的 MoE:多算一遍比读一遍权重还便宜 —— 那就别排序了,全算 DeepSeek-V3 的一个路由专家(3 块 7168×2048),TPU v7 单 device。条长 = 微秒,同一把尺子;一批 256 个 token,平均每个专家只分到 8 个 从显存读一遍这个专家的权重 256 个 token 全过一遍(没路由到的乘 0) 只算路由到的 8 个 一个专家、一步 decode BF16 读权重 23.9 µs 全算 19.5 µs 只算 8 个 0.61 µs FP8 读权重 11.95 µs 全算 9.77 µs 只算 8 个 0.31 µs 两种精度下「全算 ÷ 读权重」都是 256 ÷ 313 ≈ 0.82:一批不到 313 个 token,全算就藏在读权重的时间里 排序、搬行省掉了,代价是乘 0 每个专家只分到几行时,按专家排序、把行搬过去再搬回来,比这点矩阵乘还贵;全算把这些步骤换成一次规整的大矩阵乘。 0 × NaN 仍是 NaN:没路由到的 token 要是算出了 NaN 或 inf,乘 0 盖不住,会混进结果。要用选择(where)清掉,不能只靠乘权重 0。
比两根条:全算短于读权重,就藏得住。
DeepSeek-V3 一个路由专家,TPU v7 单 device,按峰值带宽和峰值算力推导。
出处与口径

📌 DeepSeek-V3 config.json:hidden 7168、moe_intermediate_size 2048、256 个路由专家、每 token 选 8 个;权重原生 FP8(e4m3,128×128 分块缩放,缩放因子每专家约 1 万字节,忽略)。

TPU v7 每芯片 7.37 TB/s、FP8 4,614 TFLOP/s(Google Cloud 公开规格),一芯片对软件是 2 个 device,单 device 按一半算:3.685 TB/s、BF16 1,153.5、FP8 2,307 TFLOP/s。

本课推导:一个专家 3 × 7168 × 2048 = 44,040,192 个参数;全算 = 2 × 256 × 44,040,192 次运算。两边都按峰值算,没算排序和搬行本身的耗时(取决于实现,没有公开的同口径数据)。均匀路由时 256 个 token 下每个专家被至少一个 token 选中的概率 > 99.9%,所以权重本来就要读。

FP8 那一组假设激活值也量化成 FP8 一起乘;只有权重是 FP8、激活值是 BF16 时,算力按 BF16 算,全算 19.5 µs 对读权重 11.95 µs,就不划算了。

搬行本身也能这样换:tpu-inference 2026 年 5 月合入的一项改动,在 batch 小时把排序和还原换成「one-hot 矩阵 × 隐状态」,一次规整的矩阵乘代替按下标取行。Qwen3.5 并发 64 实测总吞吐 +14.5%(1K 进 8K 出)、+7.3%(8K 进 1K 出);合入后默认关,要用环境变量开(出处见第十六节台账)。

5.3 小 AllReduce 是延迟问题

小 decode 的 AllReduce:搬数据只占一根头发丝 —— 它是延迟问题 对数时间轴,每一格 10 倍。4 张 GB200,NVLink 域内。灰条是本课按带宽算的;其余三条是论文实测或论文算出的下限 按带宽算(本课推导) 硬件下限 实测 一次 AllReduce 要多久 10 ns 100 ns 1 µs 10 µs 100 µs 按带宽算:14 KiB,环形 24 ns 硬件下限(论文推算) 1.404 µs 低延迟实现(论文) 2.37 µs NCCL 环形(论文实测) 11.0 µs 实测 11.0 µs 是带宽项的约 460 倍:多给带宽几乎没用,要省的是同步的次数 decode 的 AllReduce 比的是步数,不是带宽 batch 1 时每层一次只有 hidden × 2 字节(V3 是 14 KiB),时间几乎全花在启动和互相等待上。 所以小 batch 下 TP 切得越细、每层的同步越多,加带宽也救不回来;这条账留到第六节比 TEP 和 DEP。
比灰条和红条:就算做到硬件下限,带宽项也只是零头。
4 张 GB200,小消息平均延迟(论文实测);带宽项为本课推导,对数轴。
出处与口径

📌 Shen 等,Every Microsecond Matters: Achieving Near Speed-of-Light Latency in GPU Collectives,arXiv 2607.16100(2026-07):4 张 GB200 上小消息平均延迟 NCCL 环形 11.0 µs → 低延迟实现 2.37 µs,Llama-3.1-70B 的 inter-token latency 降 8.7%;AllReduce 的 SoL 下限 1.404 µs。论文没给「小消息」的确切字节范围。

NVLink 5:每 GPU 1.8 TB/s(NVIDIA GB200 NVL72 公开规格,双向合计)。

本课推导:消息 = 7168 × 2 字节 = 14,336 字节(V3、batch 1、bf16);环形 AllReduce 每卡发出 2(n−1)/n 份(NCCL PERFORMANCE.md,专题五第一节),n=4 时 1.5 份,按单向 900 GB/s = 约 24 ns。只算带宽项,没算任何启动和同步。

TPU 的 ICI 上同口径的小消息延迟,没有找到公开数据。

消息小,时间几乎全是固定延迟,加带宽救不回来(arXiv 2607.16100)。

⭐ 从 2022 年的 FlashAttention 到 2025 年进 vLLM 的 RPA,单卡 kernel 一直在做一件事:「少搬」从布局开始。补齐的空位、展开的 K/V、搬来搬去的行都是没人要的字节,先去掉它们,再谈量化和加卡。留下的问题:一张卡上每个专家只分到几行,batch 攒得再大也喂不饱(第六节)。

第 六 节

切专家与注意力:TEP 和 DEP

专家要多凑几行,就得铺到更多卡上,何况 V3 一张卡本来就装不下。切多卡时专家都用 EP,分歧在注意力:几张卡合算一批请求,还是各算各的。 选哪个,看模型有几个 KV 头、要多大 batch。

6.1 TEP 还是 DEP:注意力怎么切

专题五 §4.4 讲过:同一批卡进注意力和进专家时可用两套切法。 TEP 是注意力用 TP、专家用 EP;DEP 是注意力用数据并行、专家用 EP。

注意力和专家,各配各的切法 —— 同一批卡,两套映射 8 张卡的示意。同一张卡在注意力层里是某个 TP 组的一员,到了专家层就换一个身份 第一组:管请求 A 第二组:管请求 B 一个小方块 = 一个专家 一层 Transformer 里,同一张卡换两次身份 注意力层:4 张卡一组切一份注意力,两组各管一批请求 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 请求 A 请求 B AllToAll 专家层:8 张卡各放 32 个专家,所有请求的 token 都往这儿送 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 注意力是一块大矩阵,专家是一堆小矩阵:各切各的 注意力那块大矩阵切成条,4 张卡一组合起来算;两组各管一批请求。专家本来就是 256 个小块,整个分出去就行。 训练里 Megatron 叫它 Parallel Folding;推理里注意力用 TP 的叫 TEP,用数据并行的叫 DEP,图里这种一半一半的也有。
同样 8 张卡:注意力按 TP 组算,专家层每卡管 32 个专家。
专题五原图,以 V3 为例。
出处与口径

📌 Megatron-Core moe/README.md(MoE Parallel Folding,例子 TP4·CP2·DP8·PP4 → ETP1·EP64·EDP1);论文 arXiv 2504.14960。TEP / DEP 定义:TensorRT-LLM tech blog 26。

TEP 和 DEP:注意力那一半怎么切 —— 一起算同一批,还是各算各的一批 同样 4 张卡、同样 4 批请求(颜色 = 哪一批);专家那一半两边一样:8 个专家铺在 4 张卡上,每卡 2 个 请求 1 请求 2 请求 3 请求 4 TEP4:注意力用 TP,四张卡一起算同一批 请求 注意力 KV 笔记 专家 卡 0 1/4 的头 全部 KV(整份) 专0 专1 卡 1 1/4 的头 全部 KV(整份) 专2 专3 卡 2 1/4 的头 全部 KV(整份) 专4 专5 卡 3 1/4 的头 全部 KV(整份) 专6 专7 注意力出口 AllReduce:四份部分结果加起来 专家那一步 token 本来人人都有,各算本卡专家,再 AllReduce 好处 每个请求四张卡一起算,单个请求更快 坑 KV 切不开,每张卡存一整份:TEP4 白存 3 份 DEP4:注意力用数据并行,各算各的一批 请求 注意力 KV 笔记 专家 卡 0 全部的头 只存自己的 专0 专1 卡 1 全部的头 只存自己的 专2 专3 卡 2 全部的头 只存自己的 专4 专5 卡 3 全部的头 只存自己的 专6 专7 注意力 各算各的,不用通信 专家那一步 AllToAll 派发到专家所在的卡,算完合并回来 好处 KV 不重复,装得下更多请求,吞吐大 坑 各卡请求长短不一、忙闲不均;没请求的卡也得陪跑 差别全在注意力那一半:一起算同一批,还是各算各的一批 TEP:同一批请求四张卡一起算,单个请求快;可 MLA 这类只有一个 KV 头的模型,KV 在每张卡上都得存一整份。 DEP:每张卡只管自己那批请求,KV 不重复、batch 能开大;代价是专家那一步换成 AllToAll,还要防各卡忙闲不均。
只看注意力那一半。
专题五原图。
出处与口径

📌 TensorRT-LLM 定义:TEP<N> shards both attention (TP) and experts (EP) across N ranks;DEP<N> keeps attention data-parallel (ADP) while distributing experts across N ranks。

⚠️ 专家那一步的通信按常见实现画:attention 用 TP 时各卡 token 相同,专家输出用 AllReduce 合并;attention 用数据并行时各卡 token 不同,走 AllToAll。示意 4 张卡、8 个专家。

判据:KV 头数和 batch。TP 按头切注意力。KV 头只有 1 个时切不开,TP 开几路,每个请求的 KV 就存几份,每步也读几遍。DEP 各存各的、各读各的。

DeepSeek-V4-Pro 不是 MLA,但每层同样只存一条所有头共享的 KV(num_key_value_heads: 1)。 我们自己在 GB300 上用 SGLang 搭的一套部署,prefill 和 decode 两头都用 DEP,最后跑到官方目标的 95.6%:14 台 prefill 各跑 dep4,decode 跑 dep8(TP1 + 注意力 DP8 + EP8);输入 4096,端到端每张 decode 卡 10,704 对 11,200 tok/s。

容量和速度分开看。容量看 KV 池装满时能放几批人,速度看同样负载下一步要多久。这套部署记了每卡在跑几个请求,容量那条轴看得见:

TEP 换 DEP:容量和速度分开看 —— SGLang 两头都用 DEP,座位坐满就换来吞吐 上半张容量轴(示意,每卡 KV 池装满);下半张 SGLang 实测(14 台 prefill 各 dep4 → decode dep8) 一批不同请求的 KV 同一批 KV 的副本 ① 容量轴:KV 池装满时,存的是几批不同的请求(示意) TEP4 4 张卡合算一批 卡 0 批 A 卡 1 批 A 的副本 卡 2 批 A 的副本 卡 3 批 A 的副本 4 张卡只放 1 批 1 个 KV 头切不开, 每张卡各存一整份 DEP8 各算各的 卡 0 批 1 卡 1 批 2 卡 2 批 3 卡 3 批 4 卡 4 批 5 卡 5 批 6 卡 6 批 7 卡 7 批 8 8 张卡放 8 批:每卡上限 4 倍 4 = TP 路数 4 ÷ KV 头数 1 这是天花板:同时在跑的请求多到坐满 TEP4 的池子,多出的座位才换得来吞吐;光是上下文长没用。 ② SGLang 实测:14 台 prefill 各 dep4 → decode dep8,输入 4096,座位多少换多少吞吐 prefill × 14 台,每台 dep4(注意力 DP4 + EP4) decode dep8(跨 2 台,DP8 + EP8) 16 台 GB300,同一 NVL72 域 每卡同时在跑 两个 KV 池占用 端到端每张 decode 卡 出字间隔 池子划错(ratio 0.20) 727 0.93 / 0.63 6,887 58.0 ms 划平(ratio 0.15) 886 0.92 / 0.89 10,614 77.7 ms 再多 13% 显存 999 0.92 / 0.67 10,704 85.3 ms +54% → +0.8% 座位换吞吐要两个前提:有人来坐,每一步别跟着拖长 727 → 886:池子划平、座位多了,有 14 台 prefill 喂着,座位坐得满,端到端涨 54%。 886 → 999:再多 13% 座位,只涨 0.8%:一步从 77.7 拖到 85.3 ms,多坐的人被抵掉。
上半张是容量上限(示意);下半张是 SGLang 实测:座位从 727 坐到 886,吞吐跟着涨,再往上就不涨了。
实测为 GB300、两头 DEP、输入 4096;上半张是示意,不是实测占用。
出处与口径

SGLang 部署:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:33-34(14 prefill 各 dep4 + dep8 decode、16 节点同一 NVL72 域)、scripts/prefill-dep4.sh、decode-dep8.sh(--enable-dp-attention,EP 4/8);三行实测 :851-858(ISL 4096,14 路 × 并发 1050,#1/#3/#7)。

旁证:VLLM-V4PRO-RUNBOOK.md:298-302(num_key_value_heads 1)、:464-465、:476(并发 512:TP4 decode 输出 4,220、出字间隔 46.8 ms;dep8 为 11,031、11.8 ms;GPU 16 与 20)。

本课推导:容量上限倍数 = TP ÷ min(TP, KV 头数),上半张是示意,条长不按实测请求数画;+54% = 10,614 ÷ 6,887,+0.8% = 10,704 ÷ 10,614;2.09 倍 = (55,153 ÷ 20) ÷ (21,100 ÷ 16),55,153、21,100 是同表的总吞吐(输入+输出,4K 进 1K 出,所以约是输出的 5 倍),1.31 倍 = (11,031 ÷ 8) ÷ (4,220 ÷ 4)。

两个 KV 池怎么划见 3.3。速度那条轴只有一组 TP 对 DEP 的实测当旁证:vLLM 同样并发 512,decode 从 TP4 换 dep8,出字间隔缩到约四分之一(这组 V4-Pro 两边都开着 DSpark、每步猜 7 个,没跑关掉 DSpark 的对照,投机在总吞吐里占多少说不出;两边接受率接近,2.09 倍不是投机变好带来的)(46.8 → 11.8 ms)。每卡吞吐先看分母:那次 decode 卡数也翻了一倍,按全部卡是 2.09 倍,只算 decode 卡就只有 1.31 倍。

换模型:MLA 开 TEP8,KV 存 8 份;Qwen3.5-397B 全注意力层 32 个查询头共用 2 个 KV 头,存 4 份;8 个 KV 头的 GQA 每卡正好一个头,DEP 在 KV 上不占便宜。

DEP 的代价:每个 rank 都得自己备一份。DEP 下每个 rank 是台小推理机,注意力权重、调度器、状态各一份。按请求开、又不随 DP 切的状态,DEP 一宽就成倍涨。

KDA 状态按头存:DEP 每个 rank 复制一整池,TP 每卡只存自己的头 Kimi K3:69 层 KDA,每个请求一块固定状态。一格 = 一个请求槽在一个头上的状态;头数、槽数是示意,不按实际 KDA 状态 加载时 OOM 的卡 DEP8:8 个 rank 各开一整池 rank 0 rank 1 rank 2 rank 3 rank 4 rank 5 rank 6 rank 7 每个 rank 都要装下全部头的状态:两次加载都 OOM TP8:一池按头切给 8 张卡 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡只亮自己那几列,8 张卡拼起来才是一整池 TP 按头切这一维;DP、EP、DCP 都不动它 所以 DEP 开得再宽,每个 rank 还是一整池;本课推导,与官方说法一致。
比同一位置的两张卡:左边格子全满,右边每卡只亮两列。
格子是示意,头数、槽数不按实际;「切头只有 TP」为本课推导。
出处与口径

K3 共 93 层、69 层 KDA,DEP8 两次加载 OOM、官方改推 TP 与 DCP:SGLANG-K3-RUNBOOK.md(见第六、七节与文末台账)。

「DP、EP、DCP 都不切」状态池、attention-TP 8 时「状态池 8 路切分」为 runbook 引的官方说法;「按头切」为本课推导;格子数只表示整池与按头切的对比。

DEP 吃得快了,就得有人喂。同样 16 台机器,我们把 decode 从 dep8 宽到 dep16:一步快了将近一倍,可 prefill 只剩 12 台喂不饱,每张 decode 卡的输出反掉四成多。14 台 prefill 才刚好喂饱 dep8(9.1)。

同样 16 台机器decode dep8decode dep16(prefill 剩 12 台)
出字间隔60 ms33 ms
首字45 s54 s
每张 decode 卡输出9,032 tok/s5,270 tok/s(总输出只多 17%)

拓扑一换,瓶颈换边,P:D 配比要重扫。

6.2 TPU 上也一样,先读懂参数名

tpu-inference 一个公开 PR 给带线性注意力的混合模型接上了 DP 注意力。 Qwen3.5-397B 在 v7x-8 上比了 DP=8 和 TP=8:

TPU 上同一个模型:并发越高,DP 注意力比 TP 赢得越多 —— 512 并发 +62% tpu-inference PR #2577 · Qwen3.5-397B-A17B-FP8 · TPU v7x-8(4 颗芯片、8 个 device)· TP=8 对 DP=8,专家都走 EP。纵轴:DP 的输出吞吐比 TP 多多少 1K 进 8K 出(decode 为主) 8K 进 1K 出(prefill 为主) 并发 → DP 注意力相对 TP 的输出吞吐(端点标的是输出 tok/s,TP → DP) 打平 +20% +40% +60% 64 128 256 512 并发 +14% +22% +62% 4,266 → 6,914 打平 1,964 → 1,973 +23% +36% +40% 1,490 → 2,090 +14% 1,097 → 1,247 PR 同时改了调度:prefill 攒在一起派,免得一条长 prefill 混进 DP 批里拖慢所有 rank
两条线在 256 到 512 之间交叉:decode 为主的那条后来居上。
输出吞吐;折线两端标 TP → DP 的绝对值。专家都走 EP,只换注意力的切法。
出处与口径

github.com/vllm-project/tpu-inference/pull/2577「Enable correct DP attention for hybrid attention+mamba models」,2026-05-15 合入;PR 正文表格给输出/总吞吐两个数,本图用输出吞吐现算百分比,与 PR 的「DP Advantage」一列一致。正确性:mmlu_pro DP=8 0.8129 对 TP=8 0.8271(PR 原话:limit=50 时在 1σ 内)。

v7x 一颗芯片对软件显示成 2 个 device,TP=8、DP=8 按 device 数。KV 头数取自 HF Qwen/Qwen3.5-397B-A17B-FP8 config.json(num_key_value_heads 2,60 层里每 4 层一层全注意力)。「复制 4 份卡住 batch」是本课解读,PR 没有单独归因。

decode 为主那条在 512 猛涨,原因可能是 8 路 TP 把全注意力层的 KV 复制了 4 份(6.1,本课推导,PR 没归因),也可能 TP 基线撞了参数上限:TP 从并发 256 到 512 只涨 3%(4,130 → 4,266),PR 又没给 TP 的完整命令。并发 64 时 decode 为主那条打平:KV 放得下,复制无妨;prefill 为主那条已领先,长 prompt 更早挤满显存。这套切法定下之后,MoE 的通信路径还要一刀刀砍,见 14.3。

tpu-inference 跑 DeepSeek-R1 的命令写着 --tensor-parallel-size 8, 那其实是总 device 数;真正的切法在 additional-config 里:TP=1、开 DP 注意力、EP=8,即 DEP8。

名字别照字面套。TEP/DEP 是 TRT-LLM 的叫法,不等于 Megatron(训练框架)的 ETP/EDP,后者指专家层内再分的 TP 组和 DP 组。prefill、decode 各用哪个,vLLM 部署 K3 和 TRT-LLM 的例子正好相反(专题五 §8.6)。

6.3 大 EP:是什么,为什么省

EP 是把专家分给不同的卡(专题五 §4.4)。一台 8 卡机器里分完就是 EP8,token 走机内 NVLink。出了一台机器还在分,就是大 EP;TensorRT-LLM 划的线是 EP 超过 8。注意力不跟着切专家,各卡各管自己那批请求,所以大 EP 就是放大版的 DEP。

EP 和大 EP:同样 256 个专家,铺多宽 同一个 DeepSeek-V3。左:一台 8 卡机器;右:DeepSeek 线上 decode,18 台机器、144 张卡 路由专家 共享专家 跨机器的 RDMA 网络 EP8:一台机器里铺开 一台机器 · 机内 NVLink 卡 0 32 个专家 卡 1 32 个专家 卡 2 32 个专家 卡 3 32 个专家 卡 4 32 个专家 卡 5 32 个专家 卡 6 32 个专家 卡 7 32 个专家 每张卡 32 个专家,每步都要把它们读一遍 按每参数 1 字节,V3 约 671 GB; 8 张 80 GB 的卡加起来 640 GB,放不下 大 EP(EP144):铺到 18 台机器 InfiniBand 全互连 · 每张卡一张网卡 · GPU 直接发起 RDMA 放大一张卡 路由 路由 共享 每张卡只放 2 个路由专家 + 1 个共享专家 256 个专家 + 32 份热门专家的副本 = 288 份, 288 ÷ 144 = 每卡 2 份 注意力不跟着切专家:144 张卡各管自己那批请求(数据并行) 专家铺出一台机器,就叫大 EP DeepSeek 线上:prefill 用 EP32(4 台),decode 用 EP144(18 台);注意力各卡各管自己的请求。
比右边那张放大的卡:EP8 每卡 32 个专家,EP144 每卡只剩 2 个。
机器、卡、专家份数照 DeepSeek 公开配置;机内摆法是示意。
出处与口径

DeepSeek open-infra-index Day 6「Inference System Overview」:decode EP144/DP144,每单元 18 个节点、32 个冗余专家,每卡 2 路由 + 1 共享;prefill EP32、4 个节点。DeepSeek-V3 技术报告 §3.4:机内 NVLink,全集群 IB 全互连,decode 用 IBGDA。TensorRT-LLM 博客「Scaling Expert Parallelism」:large-scale EP 指 EP > 8。

本课推导:671B 参数按 FP8 每个 1 字节约 671 GB(不含缩放因子),8 × 80 GB = 640 GB;288 ÷ 144 = 2。卡内专家格子数照实,机器内 8 张卡的摆法是示意。

大 EP 为什么省。DeepSeek 自己的说法两句话:EP 把批做大,矩阵算得更有效率;每卡只管一小撮专家,访存少,延迟低。V3 每层 256 个专家只激活 8 个,不铺大,总批凑不起来。动画把这条链拆开:

上下两条泳道比同一列:行数越多,每卡读得越少。 (24 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。专家大小、层数照 V3 配置;每卡 32 个请求、负载均匀是示意。)

实测:SGLang 2024 年 12 月先给 DeepSeek 模型开了 DP attention,decode 吞吐最多是原来的 1.9 倍;后来用 96 张 H100 复现大 EP,输出最多是同卡数纯 TP 的 5 倍,但含第八节的 PD 分离。

6.4 大 EP 的代价:网络、大批、一卡出事全组陪着

大 EP 每层传两趟:先把 token 分发到专家所在的卡(FP8),算完再汇回(BF16)。按 V3 的 7168 维、选 8 个专家,每个 token 最多发出约 57 KB、收回约 115 KB(本课推导,上限)。卡越多,每趟越慢:

大 EP 吃网络:卡越多,每趟越慢 左:DeepEP 低延迟 kernel 实测(H800,每卡一张 400 Gb InfiniBand 网卡;每批 128 个 token)。右:三种互连域 分发:token 送到专家所在的卡 汇回:专家算完送回来 每趟传送多久(微秒) 0 100 200 300 400 EP8 EP16 EP32 EP64 EP128 EP256 77 118 155 173 192 194 114 195 273 314 369 360 卡数 ×32:分发 77 → 194(×2.5),汇回 114 → 360(×3.2) 按 EP256:每层一去一回 × 58 个 MoE 层 ≈ 32 毫秒,不藏起来就全露在每一步里 (本课推导;线上把它藏进计算,靠的是双微批) 三种互连域 8 卡机器 + InfiniBand 机内 NVLink 约 160 GB/s,机间每卡约 50 GB/s DeepSeek 的 EP144 就跑在这上面:跨 18 台 GB200 NVL72 72 张卡在同一个 NVLink 域里 SGLang:延迟低到可以关掉双微批 TPU Ironwood 64 颗一组,ICI 直连成 3D 环面,每颗连 6 个邻居 光交换连到 9,216 颗,再往外走数据中心网络 不是非 NVL72 不可 普通 8 卡机器,只要每张卡一张 RDMA 网卡、全互连、GPU 能直接发起传送,就跑得起;域越大,每趟越快,越不用藏。
看左图横轴:卡数涨 32 倍,延迟只涨两到三倍,但每层都要付。
32 ms 为本课推导的不重叠上限;三张卡片的规格来自各家公开资料。
出处与口径

左:DeepEP v1.2.1 README 低延迟 kernel 表(H800 NVLink 约 160 GB/s;CX7 400 Gb/s IB 约 50 GB/s;128 token/批、hidden 7168、top-8、FP8 分发、BF16 汇回)。右:DeepSeek-V3 技术报告 §3.4;LMSYS 2025-06-16「GB200 NVL72 Part I」(pure-NVLink … allows two-batch overlap to be disabled);Google Cloud「Inside the Ironwood TPU codesigned AI stack」(64-chip cube、3D torus、9,216 颗、DCN)。

本课推导:(194 + 360) µs × 58 层 ≈ 32 ms,是不重叠时的上限;V3 61 层中前 3 层稠密,MoE 58 层(config.json first_k_dense_replace 3)。NVL72、ICI 的带宽没写数字。

TPU:Ironwood 64 颗一组,用 ICI 直连成 3D 环面,每颗只连 6 个邻居,远处的芯片要经中间芯片转发(本课推导);组之间靠光交换拼成最多 9,216 颗的系统,更大就得走 DCN。MaxText 有 dcn_expert_parallelism 这个配置项,但跨 DCN 推荐的只有数据并行。

公开的 TPU 推理目前是 DEP8,专家那步用 all-gather 加 reduce-scatter,不是 all-to-all;跨切片的大 EP 推理还没有公开结果。

代价:要大批,要藏通信,一张卡出事全组陪着。

整柜当一个 EP 域:SGLang 在 GB200 NVL72 上怎么还这几笔账。两篇博客跑的都是 DeepSeek V3/R1、2K 输入,PD 分离(第八节)。decode 用 48 张卡,命令写 --tp-size 48 --dp-size 48 --enable-dp-attention,其实是 48 路 DP 注意力加 EP48,和 6.2 一样别照字面读。

换来多少(每卡,对 H100 上的大 EP 部署):decode 第一篇将近 3 倍,第二篇换上低精度将近 5 倍。明细:第一篇 decode 7,583 tok/s(2.7 倍);第二篇 FP8 注意力加 NVFP4 专家,prefill 26,156、decode 13,386 tok/s(3.8 倍、4.8 倍),原精度也有 18,471 和 9,087。

这些倍数混着显存、精度、kernel、PD 分离,不全是大 EP 的功劳;decode 是先压慢、攒满请求再放开测的。H100 基线有一组开了模拟 MTP、GB200 没开;原文还说许多 kernel 没吃满带宽和算力。

6.5 双微批:一批拆两半,一个传、一个算

大 EP 每层要传两趟:先把 token 分发到专家所在的卡,算完再汇回。传的时候,计算单元空等。DeepSeek 把一批拆成两个微批:A 在传,B 就在算。SGLang 叫它 TBO,vLLM 叫 DBO,都是这一招。

双微批:传的时候,别让算力干等 两层 MoE 的一趟前向。每层四步:算注意力 → 分发给专家 → 算专家 → 汇回。时长是示意,不按实测 计算 卡间通信(all-to-all) 不拆:传的时候,计算单元空等 算 传 注意力 分发 专家 汇回 注意力 分发 专家 汇回 结束 拆成 A、B 两半:A 传的时候 B 在算,计算那一行排满 算 传 A 注意力 A 分发 B 注意力 B 分发 A 专家 A 汇回 B 专家 B 汇回 A 注意力 A 分发 B 注意力 B 分发 A 专家 A 汇回 B 专家 B 汇回 结束 省下的这段 前提:每半批还得够大 拆开后每半批更难把计算喂饱。SGLang 实测 decode 每卡 32 个 token 时反而慢 27%,256 个时快 25.5%。
看「算」那一行:上面有空档,下面排满。
时长是示意,省下的比例不按实测;实测 prefill 快 27%~35%。
出处与口径

做法:DeepSeek open-infra-index 第六天(Inference System Overview):prefill 两个微批交替,一个的通信藏进另一个的计算;decode 各步时长不均,把注意力拆成两段,走 5 段流水。

数字:LMSYS 博客 2025-05-05(大规模 EP)的 TBO 消融;vLLM vllm/config/parallel.py 的 enable_dbo、dbo_decode_token_threshold(默认 32)。时长比例是示意,本课自定。

6.6 EPLB:热门专家多备几份

哪个专家热门,要等路由算完才知道(专题五 §4.3)。专家那一步等最慢的卡,热门专家所在的卡拖住所有人。EPLB(专家并行负载均衡器,DeepSeek 开源)按过去一段的负载统计,把热门专家多复制几份放到别的卡上,再重新排座位。

EPLB:热门专家多备一份,再重新排座位 8 个专家、4 张卡。柱高 = 这张卡这一步要算的 token,一段一个专家;数字是示意 热门专家(及其副本) 其他专家 所有卡等到这条线 开 EPLB 之前:按编号放 专家 0 · 60 专家 1 · 10 卡 0:70 专家 2 · 15 专家 3 · 15 卡 1:30 专家 4 · 20 专家 5 · 20 卡 2:40 专家 6 · 25 专家 7 · 35 卡 3:60 最慢的卡 70,平均 50 开 EPLB 之后:每卡多一个空位,热门的复制一份 专家 0 · 30 专家 4 · 20 卡 0:50 专家 0′ · 30 专家 5 · 20 卡 1:50 专家 6 · 25 专家 7 · 17.5 专家 1 · 10 卡 2:52.5 专家 7′ · 17.5 专家 2 · 15 专家 3 · 15 卡 3:47.5 最慢的卡 52.5,平均还是 50 加的是空位,换的是等待 副本占显存;token 怎么分给两份、多久重排一次,各家实现不同。
看红虚线:从 70 降到 52.5,总量没变。
8 个专家、4 张卡,负载数字是示意,不按实测。
出处与口径

做法:DeepSeek EPLB 仓库 README(按负载估计算出复制与摆放方案;负载估计常用历史统计的滑动平均,不在仓库范围内);DeepSeek-V3 技术报告 sec. 3.4。

负载数字与「token 平分给两份」均为示意,本课自定;8 专家 4 卡只为画得下。

回到主线 DEP 省下重复的 KV,大 EP 把专家那趟车坐满。留下的问题:每个 rank 自备一份状态,K3 这类模型 DEP 起不来,退回 TP 后 KV 又被复制(第七节)。
考考自己:一个模型有 4 个 KV 头,8 张卡开 TEP8,换 DEP8 后 KV 容量最多是原来的几倍?什么情况下涨了也没用?

8 ÷ 4 = 2,是 TEP8 的 2 倍。prefill 喂不上、或 batch 大到算力先到顶时,放得下也换不来吞吐。

第 七 节

切序列:DCP 和 PCP

第六节切的是头和请求,一条序列变长时还剩两件事。DEP 起不来时(如 6.1 的 K3)只能用 TP,上下文一长,KV 被复制几份,卡很快就满;prompt 一长,第一个字就要等很久。 DCP 管前一件,PCP 管后一件,两者都是沿序列切。

7.1 DCP:只在长上下文赚,开之前先知道坑

专题五 §5.4 讲过:KV 头比 TP 路数少时,DCP 把 KV 按 token 轮流存到这几张卡上,合并时再统一除 softmax 的分母。轮流放而不是前一半后一半,是因为新字不停写进来,轮流放各卡才能一直一样多(本课的解释)。

推理时切序列:KV cache 被 TP 复制了几份 —— DCP 把复制变回容量 DeepSeek-V3,一个 128K 上下文的请求。每 token 的 KV = (512 + 64) × 61 层 × 2 字节 = 70,272 字节 重复存的那几份 真正需要的那一份 8 张卡上,这一个请求的 KV 各占多少 TP 8 路 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 8.58 GiB 合计 68.6 GiB(8 份一样的) TP 8 + DCP 8 卡 0 卡 1 卡 2 卡 3 卡 4 卡 5 卡 6 卡 7 每卡 1.07 GiB 合计 8.58 GiB(刚好一份) TP 超过 KV 头数,多出来的全是复制 MLA 的 KV 只有一个头。TP 8 路时每张卡都存完整的一份,7 份是白存的。 DCP 让 KV 按 token 轮流落到 8 张卡上,每卡只剩 1/8;它不增加卡,直接复用 TP 那几张。
同一个请求,TP8 存 8 份,DCP8 合起来只存 1 份。
专题五原图,以 V3 一个 128K 请求为例。
出处与口径

📌 vLLM context parallel 部署文档:KV cache 会被复制 tp_size / H 次;DeepSeek-R1 在 MLA 下只有 1 个 KV 头,-tp 8 就是 8 倍复制,可加 -dcp 8。KV 尺寸取自 V3 config.json,本脚本现算。

分块算注意力,合并时先别除 —— 分子加分子,分母加分母,最后只除一次 注意力 = 按分数加权平均。三个 token:分数取指数后是 2、1、1,值是 10、4、20。卡 0 拿前两个,卡 1 拿第三个 卡 0 卡 1 错 对 两张卡各自算自己那份笔记 卡 0:2×10 + 1×4 分子 24 分母 3 卡 1:1×20 分子 20 分母 1 分子 = Σ 权重×值,分母 = Σ 权重 (分母取个对数,就是常说的 LSE) 各除各的,再平均 卡 0:24 ÷ 3 = 8 卡 1:20 ÷ 1 = 20 平均:(8 + 20) ÷ 2 = 14 ✗ 卡 1 只有一个 token,却占了一半的票 先别除:最后只除一次 分子:24 + 20 = 44 分母:3 + 1 = 4 44 ÷ 4 = 11 ✓ 跟三个 token 放在一张卡上算的一样 所以每张卡除了结果,还得交出自己的分母 跟合并两个班的平均分一样:得带上各班人数,不能把两个平均数再平均。 Ring 在路上一段一段这样合并,DCP 在终点这样合并,是同一招。
分块算注意力,合并时先别除。
每张卡除了结果,还要交出自己的分母。
出处与口径

📌 讲法:Ring Attention(Liu 等,arXiv 2310.01889)附录实现按分子、分母分别累加;分块 softmax 的数值稳定写法见 FlashAttention(arXiv 2205.14135)。

⚠️ 本课示例:数字是随手取的,按定义现算并断言。

代价是每层多几次通信(vLLM 默认后端每层 3 次),度数(切成几份,DCP8 就是 8 份)最多开到 TP ÷ KV 头数。

每层那 3 次是什么(vLLM 默认 ag_rs 后端)
  • ① all-gather 提问:权重按头切,每卡只投影出自己那几个头,可本地那段 KV 所有头都要查,先收齐全部头。
  • ② all-gather LSE:kernel 在本地已经除过分母,只留下 log-sum-exp(每人每头一个数),收齐后各卡算出自己该占的比例。所以「先别除」是课堂说法,实现是「除了,但把分母记着」。
  • ③ reduce-scatter 输出:相加得完整结果,按头分回各卡,接上按头切的输出投影。

代价主要是等不是量:V3 61 层 MLA × 3 = 每 token 多 183 次集合通信,K3 24 层 × 3 = 72 次(本课按层数乘)。a2a 后端把 ②③ 并成一次 all-to-all(源码注释:MLA 每层 3 次降到 2 次);dcp_q_replicate 每卡放一整份提问投影省掉 ①,代价是重复算。两者没有公开实测。

DCP 只在长上下文赚。Kimi K3 在 GB300 上,128K 输入时 DCP8 大赚;输入 4K 时各档并发都亏。

DCP 只在长上下文赚 —— 128K、8 并发:365 对 108,+237% Kimi K3 · GB300 · SGLang · TP8 跨 2 节点,输出 1K。纵轴:DCP8 ÷ TP8 的输出吞吐(对数刻度),一条线一个并发 并发 8 并发 1 并发 32 并发 64 输入长度 → DCP8 相对 TP8 0.6× 0.8× 1× 1.5× 2× 3× 4× DCP 赚 DCP 亏 4K 8K 32K 128K 输入长度(token) 4K:四档并发全亏 并发 64:−7% 并发 8:−9% 并发 32:−11% 并发 1:−26% 并发 32:+24% −11% −17% 并发 1:+12% 并发 1 的 8K、32K 没测,虚线只连两端 +237% 365 vs 108 tok/s
看突出画的并发 8 那条在哪个长度翻上去。
输出吞吐,取预热后那轮;TP8 取调过参的最好一档。纵轴为对数刻度。
出处与口径

gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md §11.0.3(:1010-1023,八个工作点)、§11.0.0 宽表(:921-938,4K c8/c32 本脚本取 symm-mem 开着时 TP8 最好的一档现算)、:721-723(逻辑 KV 1.5M → 12.2M token)、:1024-1026(−26% = 关 symm-mem 的损失)、:962(symm-mem 在 DCP 下用不了)。

各点比值:4K c1 −26%、c8 −9%、c32 −11%、c64 −7%;8K c8 −11%、c32 +24%;32K c8 −17%、c32 +7%;128K c1 +12%、c8 +237%。

吞吐是输出 tok/s,热轮;32K c32 按 §11.0.3 取 TP8 408.2(宽表 ratio 0.4 那行是 420,比值变 1.04,不改结论)。K3 的 MLA 层只有一个 KV 头,它的 69 层 KDA 状态池 DCP 不切(同文件 :725-726)。横轴没换成「KV 总量」:原表只给输入长度和并发,没有实测的 KV 占用。

多长时注意力算得比专家多?拿 Qwen3.5-397B 算一笔(本课推导):

名字按阶段起。DCP/PCP 是推理框架里的叫法。Meta 论文(arXiv 2411.01783)按传什么叫 pass-KV/pass-Q:完整 prefill 用 pass-KV,decode 和缓存命中高的 partial prefill 用 pass-Q。NVIDIA Helix 论文(arXiv 2507.07120)管 decode 时按序列切 KV 的那一派叫 KV 并行(KVP)。

开 DCP 之前要知道的坑。

7.2 PCP:超长 prompt 的首字延迟

PCP 在 prefill 阶段沿序列切,让几台机器合算同一个 prompt(专题五 §5.5)。

PCP 和 DCP:先按行切,行切到只剩一行,再把这一行切开 —— DCP 不是跟 PCP 对等的另一种切法,是行切到头以后的下一步 注意力是一张「提问 × 笔记」表:一行 = 一个新 token 的提问(Q),一列 = 前面一个 token 的笔记(K、V);只看前面,所以是三角 卡 0 卡 1 卡 2 卡 3 PCP(prefill):Q 有几千个,按行切(例:4,000 行 → 每卡 1,000 行) 笔记(K、V)→ 提问 卡 0 卡 1 卡 2 卡 3 prefill:几千个提问一起来 表又高又宽,活很多 按行切给 4 张卡: 每一行在一张卡上算完, 结果不用合 可卡 3 那两行(红框) 要看左边全部笔记: 得先把前面的 KV 收齐 为了 算得快:第一个字早出来 卡 在 TP 之外再加一维,要加卡 多出的通信 收齐前面几段的 KV DCP(decode):只剩 1 个 Q,没行可切了,再把这一行按列切开 这一步:每个请求只有 1 个新提问(表只有一行),前面存了一长串笔记 笔记按 token 轮流存:第 0 条卡 0、第 1 条卡 1……(原来那 4 张 TP 卡,不加卡) 卡 0 → 这一行的一部分:分子 + 分母 卡 1 → 这一行的一部分:分子 + 分母 卡 2 → 这一行的一部分:分子 + 分母 卡 3 → 这一行的一部分:分子 + 分母 四份部分结果 → 先别除:分子加分子、分母加分母,最后除一次 实际是一批:1,000 个请求 = 1,000 行,每行都这样拆,每张卡存每个请求四分之一的笔记 为了 装得下、读得少:每卡 KV 只剩 1/4,每步只读 1/4 卡 用原来那几张 TP 卡,不加卡 多出的通信 收齐提问、交换分母、合并结果 先切行;行切到只剩一行,再切这一行 PCP:prefill 一次有几千个 Q,按行切开,每行在一张卡上算完、结果不用合,但要收齐前面的笔记;为了第一个字早出来,另外加卡。 DCP:decode 每步只剩 1 个 Q,没行可切,只能进一步把这一行按列(笔记)切开,各算一段再按先别除合起来;为了装得下,用原来的卡。
PCP 切 prefill 的计算,DCP 切 decode 的 KV。
专题五原图。

Meta 2024 年 11 月的论文把训练侧的切法搬到推理 prefill:一百多张卡合算一个 prompt,一百万 token 一分多钟算完(128 张 H100、Llama3 405B,1M token 77 s,128K 3.8 s,并行效率 93%)。用的是 Ring(2023-10):各卡拿一段,别人那段沿环一站站传来,边传边算。整段 prefill 传 K、V(GQA 下它小),新 token 很少时改传 Q,结果都和不切一样。 为了让因果三角各卡活一样多,Meta 把序列切成 2N 块、首尾配对分给 N 张卡;DCP 则按 token 轮流放。

同一篇里,1 到 8 台之间机器数翻倍,prefill 延迟约减半;再翻到 16 台就打了折扣,只降约 35%(8 台做 128K 5.85 s,16 台 3.8 s,降幅本课推导)。跨机切 TP 就不行:2 台时 TP16 比 CP2 慢约 15%,8 台慢约 100%。原文的解释:TP 每层都要走跨机带宽,而它比机内低得多。

另有 Ulysses(DeepSpeed,2023-09)用 AllToAll(每张卡给其余每张卡各发一份)把按序列切换成按头切,切的份数不能超过头数。

PCP 的两个正确性陷阱。PCP 出错往往不报错,形状全对、数不对。

线性注意力切序列,每段从零开始会静默算错 —— 状态要接力,不能各扫各的 玩具递推:状态 S ← 0.9 × S + 1,从 0 起。16 个 token 切给 4 个 rank,每段 4 个(本课自造的数) 一口气扫(对) 每个 rank 从 0 扫(错) 第几个 token → 状态 S 0 3 6 9 rank 0 rank 1 rank 2 rank 3 token 1 → 16 3.439 5.695 7.176 8.147 又从 0 起步 3.439(差 58%)
各扫各的,锯齿;接力扫,平滑。
本课自造的玩具递推,真实的状态是矩阵、带门控,递推形状相同。
出处与口径

本课自造的玩具递推,数值由本脚本现算并断言;真实 GDN/KDA 的状态是矩阵、带门控,递推形状一样都是「乘上一步状态再加新东西」。

状态可结合合并的思路见线性注意力/状态空间模型的并行扫描写法(如 Mamba、GLA 的 chunkwise 算法)。

修法是把前一段的末状态传过来;或者利用结合律:各段并行算好自己对状态的映射,再从头合并出每段的起始状态。

7.3 并排看:副本让出来,多放 token

把第六、七节的切法摆进同一本账:V3,8 颗 v7(16 个 device,v7x-16),上下文 128K。每格按 device 算,口径同 4.1、10.2:每 device 可用 94.75 GiB,留一成给激活值,剩 85.3 GiB;权重 FP8 每参数 1 字节,KV 按 bf16,一条 128K 是 8.58 GiB。

本课推导,纸面账。非专家权重 = 总参数 671.0B 减去 58 层 × 256 个路由专家(653.9B)= 17.1B;每层参数分项见 0.2 的图。实测 FP8 专家比均摊更占地方(10.2),真机余量只会更少。
切法权重/device剩给 KV一条 128K 在每 device 占16 个 device 装几条
DP:整套复制625 GiB放不下—(一份权重就超了)0
TP16:注意力、专家都切 16 片39.1 GiB(全切)46.2 GiB8.58 GiB(每 device 一整份)5
TEP16:注意力 TP、专家 EP39.1 GiB(全切)46.2 GiB8.58 GiB(每 device 一整份)5
DEP16:注意力 DP、专家 EP54.0 GiB(非专家整份 15.9 + 路由专家 1/16 是 38.1)31.3 GiB8.58 GiB(只在自己那个 device)每 device 3 条,共 48
TEP16 + DCP1639.1 GiB(全切)46.2 GiB0.54 GiB(按 token 切 16 份)86

读的一侧取装满时的 batch,每层碰到几个专家按 1.2 的均匀路由算;只算从 HBM 读的字节,下限按每 device 3.685 TB/s(每芯片 7.37 ÷ 2)。

本课推导。读权重取 MoE 层(第 4 到 61 层),每 device 每层;一步下限含 61 层与输出层,不含通信和计算。通信次数:TP 前向每层 2 次 AllReduce(Megatron-LM,arXiv 1909.08053);TEP 同 2 次(专题五 §4.4 的图);DEP 专家前后各 1 次 all-to-all(6.4);DCP 另加每层 3 次(vLLM 默认后端,7.1)。
切法整套 batch每层读权重每层读 KV一步读完下限每层通信代价/适用
TP165118 MB:注意力 1/16 + 碰到的 37.6 个路由专家和共享专家各 1/16755 MB:5 条全读14.4 ms2 次 AllReduce单人出字快;KV 复制 16 份,长上下文装不下人
TEP165118 MB(平均):注意力 1/16 + 本卡被碰到的整块专家755 MB:5 条全读14.4 ms2 次 AllReduce同 TP16;专家整块,热门专家那张卡要多读,大家等它
DEP1648784 MB:整份注意力 187 + 本卡 12.5 个路由专家 + 共享专家453 MB:只读自己 3 条20.6 ms2 次 all-to-all(前 3 层不用)KV 不复制,人多时最省;每 rank 一份状态,K3 这类起不来(6.1)
TEP16 + DCP1686673 MB:注意力 1/16 + 本卡 15 个整块专家812 MB:86 条各读 1/1624.1 ms2 次 AllReduce + 3 次装得最多;通信最勤,只在长上下文划算(7.1)

落点:副本让出来,多放 token。DCP 让出 KV 副本,同样的显存多放 token,这一趟就分给了更多 token;PCP 买的是首字延迟。留下的问题:一张卡上同时出字的人越多,长 prompt 进门那一步耽误的人也越多(第八节)。

考考自己:4K 输入、并发 8 的线上服务,要不要开 DCP8?换成 128K 的 agent 长对话呢?

4K 不开:KV 放得下,DCP 只剩代价(7.1)。128K 开:TP8 放不下,只能少收请求、排长队。

第 八 节

拆工作:PD 分离与那一趟 KV

第六、七节把每张卡的批撑大了,一次 prefill 波及的人也跟着变多。分块 prefill(3.2)只能把打扰摊平:两段还挤在同一批卡上,长 prompt 一来,正在出字的人照样要等。PD 分离把两段拆到两批机器上。 难的是 KV 从 prefill 机传到 decode 机的那一趟。

8.1 为什么要拆,那一趟要多久

专题五 §6.1 讲过:decode 每步只出一个字却要读一遍权重,所以要凑大 batch。batch 越大,一次 prefill 卡住的人越多。

decode 为什么非要把一批做大 —— 读一遍权重,只够这一批用一次 横轴:一步里一起出字的请求数 b(对数刻度)。纵轴:从显存读 1 字节权重,换来多少次计算(本课推导,只算读权重) 稠密层:= b MoE 的一个专家:= b ÷ 32(V3 挑 8/256) v7 显存线 ≈ 313 1 4 16 64 256 1,024 4,096 16,384 一步里一起出字的请求数 b 1/16 1 16 256 显存线 ≈ 313 稠密:b ≈ 313 才吃饱 MoE:b ≈ 10,000 才吃饱 线上:卡算得过来 线下:卡在等显存把权重读出来 所以 decode 的各种做法,都在凑一个大 batch PD 分离让 decode 机器只管出字,一批能攒得更大;DEP 让注意力各管各的请求,专家那边收齐所有卡的 token。 Wide-EP 把专家铺到更多卡上、每张卡只放几个,AFD 干脆让一组专家机器同时接好几组注意力机器的 token。
batch 越大,读一遍权重换来的计算越多。
专题五原图。
出处与口径

⚠️ 推导:稠密层一步读 2P 字节(bf16)、算 2Pb 次,每字节 = b;MoE 每个专家平均分到 b × 8 ÷ 256 个 token。只算读权重,读 KV 会让门槛更高。

📌 v7:每芯片 bf16 2,307 TFLOP/s;HBM 每 TensorCore 3,433 GiB/s、每芯片两个(wiki entities/tpu-v7)。V3 的 8/256 取自 config.json。

这时插进来一个长 prompt:

看红框:混部时整批人都在等 prefill;拆开后只多出那支「传 KV」。 (22 秒无声循环,Manim 渲染。示意:时间格只表相对长短,不是实测毫秒;传 KV 画得比 prefill 短,量级见 8.1。)

Splitwise(2023)、DistServe(2024)先后提出它:前者报同成本同功耗下,吞吐最多是现有不拆集群的 2.35 倍;后者报九成以上请求守住延迟要求时,每卡能接的请求率最多是 vLLM、DeepSpeed-MII(都不拆)的 7.4 倍。

Kimi 的线上系统 Mooncake 连同 KV 池(4.4)把它做进了生产,FAST'25 正式版报比此前系统多接 115%(A800)、107%(H800)请求。NVIDIA 的 Dynamo(搬 KV 的那层叫 NIXL)2026 年 3 月出 1.0 正式版,PD 分离成了标准件。

拆开换来 TPOT 稳,两边还能各挑切法(第六、七节);代价是一趟 KV 传输、两套机器和一份要调的配比(第九节)。

那一趟要多久。专题五 §6.2 算过 Qwen3-Coder-480B 一个 8K prompt 的 KV 走一趟要多久:

一趟 KV 传输,只占一次 prefill 的 5–10% —— 网络不是瓶颈 我们在 TPU v7x 上的 1P1D(Qwen3-Coder-480B),8K token 的 prompt。KV 传输是按带宽估算,不是计时实测 prefill(1–2 秒) ① ② ③ 同一把时间尺:0 到 2 秒 0 500 ms 1000 ms 1500 ms 2000 ms 一次 prefill 1–2 秒 一趟 KV 传输 10 + 83 + 10 ≈ 100 ms 放大 10 倍: 10 ms ① 显存 → 本机内存(PCIe) 83 ms ② 本机 → 对方(数据中心网络 100 Gb/s) 10 ms ③ 对方内存 → 显存(PCIe) 敢走慢线,是因为一个请求只传这一次 这个模型 KV 头少(8 个)又用 FP8 存,8K prompt 的 KV 约 1.04 GB;换一个 KV 大得多的模型、换网络,要重算。 对比 TP:它每一层都要通信,只能待在最快那一圈;这里一个请求就一趟,跨机器也藏得住。
三色细条就是代价。
专题五原图;KV 用时按带宽估算,不是计时。
出处与口径

📌 我们的 TPU v7x 1P1D 记录(wiki qwen3-coder-480b-pd-disagg-tpuv7x-20260425):三段按带宽估算约 10 / 80 / 10 ms、合计约 100 ms、占 prefill 5–10%(prefill 1–2 s 由此反推)。

⚠️ 本课推导:KV = 2 × 62 层 × 8 个 KV 头 × 128 × 8,192 × 1 字节 ≈ 1.04 GB;100 Gb/s = 12.5 GB/s → 约 83 ms。

100 Gbps 还是保守算:A4X(Google Cloud 的 GB200 机型)每张 GPU 配 400 Gbps 网卡,GB300 是 800 Gbps,一趟约 21 ms、10 ms(按单卡单网卡算;本课推导)。

前提有两个:网络跑在设计带宽上(8.2),KV 不大得离谱(8.4)。

8.2 三层软件:谁搬、谁派、谁存

那一趟 KV 像一次搬家 —— 路和车、路口调度、路边仓库各是一层 小字是各层常见的公开组件:蓝字 GPU,青字 TPU 搬运层 调度层 存储层 车上运的 KV prefill 机 → decode 机 prefill 机 decode 机 搬运层 = 路和车 NIXL · Mooncake 搬运库(Transfer Engine) TPU Sync · JAX transfer server 新请求 调度层 = 路口调度员 Dynamo · vllm-router · 引擎里的 connector tpu-inference 的代理 · TPUConnector 存储层 = 路边仓库 Mooncake Store(KV 池) LMCache · Dynamo KVBM TPU Sync 的主机内存层 放主机内存、SSD 或远端
先认层,再认组件。
只列公开组件;横跨两层的按主要角色放。
出处与口径

📌 NIXL:github.com/ai-dynamo/nixl(插件 UCX、GDS、Mooncake 搬运库、POSIX 等)。Mooncake 开源仓库:github.com/kvcache-ai/Mooncake(含 Transfer Engine 搬运库 + Store KV 池)。

📌 LMCache:arXiv 2510.09665。Dynamo KVBM:docs.nvidia.com/dynamo 的 KVBM 页(GPU、主机、SSD、远端存储,经 NIXL)。

📌 TPU Sync:github.com/google/tpu-sync(C++,零拷贝 PJRT buffer,约 200 GB/s 双向 PCIe,支持 v7x / v6e,not yet recommended for general use)。

📌 tpu-inference:vllm-project/tpu-inference 的 kv_transfer 目录(TPUConnector 用 jax.experimental.transfer,decode 端去拉;HMA 版按 MambaSpec 分组)。

⚠️ 同一个组件可能横跨两层(例如 NIXL 也给 KVBM 当搬运层),图上按它最主要的角色放;路和车只是比方,不代表真实拓扑。

TPU 上能直接用的是 TPUConnector;TPU Sync 刚开源,自称还不宜通用。

排查按层找:带宽掉到几百 MB/s 是搬运层没走对通道;请求接不上、握手失败多半在调度层;前缀命中率低看存储层。

GPU 实战:配错一个开关,慢两个数量级。vLLM 在 GB300 上跑 DeepSeek-V4-Pro 的 PD,起初 KV 传输慢得离谱:

配错一个开关,搬一趟要 prefill 本身的 2.6–5.2 倍时间 —— 是配对时的 35–835 倍 横轴是对数时间。每根条是同一份 1.04 GB 的 KV(专题五那个 8K prompt)按这一档带宽搬一趟;灰带是这个 prompt 的 prefill 本身 配错:实测 200 MB/s 专题五:100 Gb/s = 12.5 GB/s 配对:实测 7–167 GB/s 搬一趟 1.04 GB 要多久(本课推导,带宽是实测) 1 ms 10 ms 100 ms 1 s 10 s prefill 1–2 s 配错(cuda_copy) 200 MB/s 5,201 ms 专题五:数据中心网络 100 Gb/s = 12.5 GB/s 83 ms 配对,低端 7 GB/s 149 ms 配对,高端 167 GB/s 6.23 ms
红条比灰带还长。
带宽是 GB300 实测,时间是本课用 1.04 GB 统一换算的。
出处与口径

📌 带宽和单次传输时间:gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:194(GB300,vLLM,NixlConnector):单次传输 200–800 ms 降到 2–10 ms。

⚠️ 本课推导:1.04 GB = 2 × 62 × 8 × 128 × 8,192 × 1 字节(Qwen3-Coder-480B,FP8),只当一把统一的尺子,不是 V4-Pro 的 KV。时间 = 1.04 GB ÷ 带宽;没算握手和排队。prefill 1–2 s 与 100 Gb/s 取自专题五 §6.2。

原因是 NIXL 没走 cuda_ipc(直接读对端 GPU 的显存),退回了 cuda_copy(经主机内存中转);补上三样配置就回到绿条。配错不报错,只是 TTFT 慢,上线前先量一次 KV 传输带宽。

那三样配置:vLLM + NIXL 在 GB300 上走 NVLink
  • UCX_TLS=cuda_copy,cuda_ipc,tcp:只留 cuda_ipc(NVLink)和必要的拷贝、控制通道,去掉 RDMA。
  • UCX_CUDA_IPC_ENABLE_MNNVL=y:允许跨节点的 cuda_ipc(MNNVL 即跨机箱的 NVLink)。
  • --enable-cumem-allocator:显存用 cuMem 分配,cuda_ipc 才认得出来。

prefill 和 decode 还必须在同一个 NVLink 域(GKE 上用 subblock 标签做 podAffinity)。出处:gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:106、180–194。

同一个库在两个引擎上结论相反(表里的 Mooncake 指它开源的搬运库 Transfer Engine):

引擎 · 场景试了什么结果
vLLM · V4-Pro · GB300NIXL 走 NVLink cuda_ipc能用,唯一活路
vLLM · V4-Pro · GB300Mooncake 走 NVLink + 简易代理KV 快了,整体更慢:并发 64 输出 1,333 对 NIXL 的 1,693 tok/s
vLLM · V4-Pro · GB300Dynamo + vLLM + MooncakeConnector接不上:Dynamo 的 vLLM 集成没有传 Mooncake 握手地址的通路
SGLang · DeepSeek-R1 · GB300NIXL 走 RoCE(以太网上的 RDMA,4.4)GKE 上调不通,请求 60 s 超时
SGLang · R1 / Kimi K3 · GB300Mooncake 走 NVLinkR1 上能用;K3 的 PD 尝试也选了这条

别问 NIXL 和 Mooncake 哪个好,要问这个引擎、这张网上哪条路通。共同点只有一个:同一个 NVLink 域里,KV 别出域。

8.3 混合模型的尾巴与 PD 坑清单

KV 按块存(4.2)。老的 connector 只传填满的整块,不满一块的尾巴让 decode 端补算。

混合模型不能「传整块、尾巴自己算」 —— GDN 的状态会把尾巴记两遍 示意,不按真实大小。Qwen3.5-397B 的 60 层里 45 层 GDN、15 层注意力 注意力层的 KV GDN 层的状态 decode 端补算的尾巴 老办法:只传整块,尾巴让 decode 端补算 注意力层(15 层)= 逐格账本 GDN 层(45 层)= 存折余额 prefill 端传来 prefill 端传来 尾巴 decode 端补算尾巴后 decode 端补算尾巴后 尾巴 重复入账 空格填上,账不变 尾巴那格空着 混合模型版(TPUConnectorHMA):7 格连同余额全传,decode 端一个 token 都不补算
先看格子,再看存折:补算尾巴伤的是哪一层。
示意,层数取自 Qwen3.5-397B。
出处与口径

📌 tpu-inference tpu_connector_hma.py 注释原文:No trim, no block-alignment rounding … Required for Mamba correctness. P's Mamba state is a recurrent summary of all prompt tokens. If D re-prefilled any tail tokens locally, they would be fed through the Mamba recurrence a second time on D.

📌 非 HMA 版把 prompt 长度按 block 向下取整,尾巴由 D 端重算。存折、账本只是比方:GDN 状态是固定大小的递归摘要,「多一截」指多喂了一遍,不是状态变大。

📌 45 GDN + 15 注意力与开关:tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:375–389;PrFaaS(arXiv 2604.15039)写 Qwen3.5-397B 线性对全注意力 3:1,一致。

📌 Kimi K3(GPU):gpu/inference/kimi-k3/SGLANG-K3-RUNBOOK.md:1319(PD decode 的状态池一请求一 slot,--mamba-radix-cache-strategy 在 PD 下失效)。

混合模型(4.1)里 GDN、Mamba 这类层的递归状态已吃下整段 prompt,再补算尾巴,这几个 token 就喂了两遍,输出偏了也不报错。

Qwen3.5 PD 的启动要点:tpu-inference

connector 选 TPUConnectorHMA,并显式加 --no-disable-hybrid-kv-cache-manager。出处:tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:375–389;吞吐表见同目录 README-TPU-VM.md:859–867(XLA 缓存已热的第二轮)。

PD 坑清单。

出处:三条坑和 8.2 表第三行

上下文长度:SGLang V4-Pro runbook:941。失败策略:vLLM V4-Pro runbook:760。core dump 驱逐:vLLM V4-Pro runbook 12.4 节。Dynamo 握手:vLLM V4-Pro runbook:703。两份 runbook 都在 gpu/inference/a4x-max/deepseek-v4/。

8.4 拆了以后先比字,KV 够薄才敢走远路

正确性:拆了以后先比字。PD 出错最常见的样子是能跑、通顺,但和不拆时不同。上线前先比字,再比速度。

后一种靠批不变的 kernel 消掉,前一种必须修;分不清时把并发降到 1 再比。

跨数据中心:KV 够薄才敢走远路。「网络不是瓶颈」只在同一个机房成立。Moonshot AI 和清华的 PrFaaS 论文敢把 prefill 放到另一个数据中心的另一种卡上,靠的是混合模型的 KV 薄。

KV 变薄,PD 才敢跨数据中心 —— 混合模型要送的字节降到全注意力的 1/4 到 1/13 PrFaaS 论文 Table 3:32K 输入,一台 8×H200(SGLang v0.5.9)做 prefill 时每秒要外送的 KV,单位 Gb/s 全注意力 混合(线性或滑窗 + 少量全注意力) 每台 prefill 每秒要外送的 KV(Gb/s,32K 输入) 0 20 40 60 80 100 案例:整个 prefill 集群平均出口 13 Gb/s = 专线的 13% Qwen3-235B 全注意力 33.35 够并 2 台 Qwen3.5-397B 每 4 层里 3 层线性 8.25 够并 12 台 MiniMax-M2.5 全注意力 59.93 够并 1 台 MiMo-V2-Flash 每 6 层里 5 层只看近处 4.66 够并 21 台 整条跨集群专线约 100 Gb/s(集群共用)
同一条专线:橙柱只够并 1–2 台,绿柱能并 12–21 台。
每根柱是一台 prefill 每秒外送的量;红虚线是整个集群共用的专线,绿虚线是案例里整个集群的平均出口。
出处与口径

📌 PrFaaS,arXiv 2604.15039(Moonshot AI + 清华):Table 3 的 Φ_kv;案例吞吐 +54%、P90 TTFT −64%、同成本约 +15%、比不调度的朴素异构 +32%;长度阈值 19.4K,约一半请求外送;平均出口 13 Gb/s,占整条以太网的 13%(§4.3.1,故专线约 100 Gb/s)。「够并几台」= ⌊100 ÷ 每台外送⌋,本课推导。

📌 案例:内部 1T 混合模型,32 张 H200 做 prefill + 64 张 H20 做本地 PD,对比 96 张 H20 同构 PD。「每 4 层里 3 层线性」即论文的混合 3:1;「每 6 层里 5 层只看近处」即 5:1 滑窗注意力(SWA)。

⚠️ 那 4 倍、13 倍是论文拿规模相近的模型两两对比(原话 dense models of similar size),不是同一参数量下的严格对照。

8.5 一柜 NVL72 怎么拆:SGLang 的两次实测

SGLang 2025 年在 GB200 NVL72 上把这些零件拼成了一套:DeepSeek-V3/R1(671B),PD 分离加大 EP(第六节)。一柜 18 个计算节点、每节点 4 张 GPU,同在一个 NVLink 域;KV 用 Mooncake 走 NVLink,守住 8.2 那条「KV 别出域」。

输入 2,000 token。H100 基线是 SGLang 2025 年 5 月 96 张 H100 的大 EP 实验,原数照抄;Part I 的 H100 柱开了模拟 MTP、GB200 柱没开,原文说同条件下倍数还会更高。并行配置取自两篇的复现命令。出处:lmsys.org/blog/2025-06-16-gb200-part-1、2025-09-25-gb200-part-2。
Part I(2025-06)Part II(2025-09)
decode12 节点 48 卡,DP attention + EP48同样 48 卡;batch 1,408(按每卡读;KV 基本占满;4K 输入时 768)
prefill剩下 2 节点 8 卡,一个实例每实例 4 卡(BF16 注意力+FP8 MoE)或 2 卡(FP8 注意力+NVFP4 MoE)
每卡吞吐decode 7,583 output tok/s,H100 的 2.7 倍低精度:prefill 26,156 input、decode 13,386 output tok/s,H100 的 3.8、4.8 倍;原精度 18,471/9,087

两边是分开量的。测哪一边,就假设另一边资源无限。量 decode 时先让 decode 每步故意睡一会儿(slow-down 接口),请求堆满再放开,测的是 decode 吃饱时的吞吐。所以 Part I 的 2 节点对 12 节点只是测试配法;原文说真实部署更像 18 节点里 6 个 prefill、12 个 decode。

两个每卡数拼不成一套集群。代 Part II 的数(本课推导):2,000 进 100 出,一个请求在 prefill 上花约 2,000 ÷ 26,156 ≈ 0.076 卡·秒,在 decode 上约 100 ÷ 13,386 ≈ 0.0075 卡·秒,prefill 卡要是 decode 的约 10 倍。输出 1,000 字才约 1:1,还没算上下文变长后 decode 每卡会降。配比跟着输出长度走(第九节)。

prefill 的 3.8 倍从哪来。Part I 只优化了 decode,prefill 写在待办里。Part II 补的招,机制第六节都讲过:EP 反着缩到每实例 2–4 卡、放不下的权重卸到主机内存(6.4),NVFP4 让分发流量减半(6.4),双微批换成细粒度重叠(6.5)。

另外两招是降精度和换 Blackwell 版 kernel:原文一个典型案例里,注意力 kernel 快 1.8 倍,GEMM 最多快 1.9 倍。原文也提醒,高低精度两条路径的差距不全来自精度,辅助 kernel 和专家负载都不一样。

回到主线 PD 分离不改变 decode 每一趟搬多少,只保证它不被 prefill 打断,才敢把 batch 攒满。 留下的问题:每个请求多一趟 KV 传输,还多一批机器要配,P:D 比例得自己量(第九节)。
考考自己:PD 上线后 TTFT 比不拆时还高,TPOT 倒是稳了。先查哪一层?

先量 KV 传输带宽。只有几百 MB/s,多半是退回了 cuda_copy 或跨出了 NVLink 域;带宽正常再看调度层有没有排队。

第 九 节

配几台、拆不拆:P:D 配比、AFD、EPD

拆开以后多出一个旋钮:P、D 各配几台。在它前面还有一问:这个负载该不该拆。 都要拿自己的负载去量,别照搬别人的配比。

9.1 配比:先算一个起点

专题五 §6.3 用 DistServe 的例子讲过:两边按各自上限配。

拆开以后,3 张卡顶混着做的 7 张 —— 各干各的,谁也不拖谁 同一套延迟要求下,一张卡每秒接得住几个请求(DistServe 论文的例子,13B 模型、单张 A100) 两样都做 只做 prefill 只做 decode 每张卡每秒接得住几个请求 混着做 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 两样都做 1.6 个/秒 7 张 ≈ 11.2 个/秒 拆开 prefill 5.6 个/秒 prefill 5.6 个/秒 decode 10 个/秒 3 张 = min(2 × 5.6, 10) = 10 个/秒 每张卡接的请求翻了一倍多,配比就是这么算出来的 两边各有各的上限:prefill 一张接 5.6 个,decode 一张接 10 个,所以配 2 比 1,两边差不多同时忙满。 长 prompt 的业务 prefill 更累,就多配 prefill;长回答的业务多配 decode。
两边按上限配,谁也不等谁。
专题五原图,DistServe 论文的 OPT 例子。
出处与口径

📌 DistServe(Zhong 等,arXiv 2401.09670)sec. 1 与图 1 的例子(13B 模型、单张 A100,90% 请求达标):同一 SLO 下单卡 goodput 1.6/5.6/10 rps,2P1D 每卡 3.3 rps、2.1 倍;作者博客「Throughput is Not All You Need」用同一组数讲了一遍。

⚠️ 本课推导:2P1D 每秒 min(2 × 5.6, 10) = 10 个,每卡约 3.3 个;混着做接 10 个要 ⌈10 ÷ 1.6⌉ = 7 张卡。

混着做为什么一张卡每秒只接 1.6 个请求:DistServe 的延迟要求是两条,首字(TTFT)和字距(TPOT)。两段混在一起互相干扰,要求卡得紧时只能顾一头,要么多堆卡才能两头都守住。

真实部署要把「一张接几个」换成量出来的吞吐。

配比公式:先算一个起点。prefill 个数 ≈ decode 每秒完成的请求数 × 输入长度 ÷ 一个 prefill 每秒能吞的 token。

DeepSeek-V4-Pro,SGLang,GB300,8K 进 1K 出,每张 decode 卡 11,200 output tok/s 的官方点(分母按 output ÷ decode 卡读,见 2.1;若是全部卡,此表不成立);推导见 gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:1082–1091。
步骤算式结果
decode 每秒完成8 卡 × 11,200 ÷ 1,024 个输出 token约 87.5 个请求
prefill 要供的料87.5 × 8,192 个输入 token约 71.7 万 tok/s
一个 prefill(4 卡)4 × 每卡 18,200 input tok/s(官方的 prefill 单卡吞吐)约 7.28 万 tok/s
要几个71.7 ÷ 7.28约 9.8

同一个部署有三个 prefill 个数:

公式定起点,上下扫,取每卡输出不再涨的那一档。

线上流量一直在变,配比也不能定死。DeepSeek V4.1-Flash 线上让两边各自扩缩:prefill 按没命中缓存的 token 数算要几个实例,相当于把公式里的输入长度换成没命中的那部分;decode 按正在算的请求数算。都设上下界和限速;配额占用高于 0.8 不许缩容,池里另留空闲机器当扩容库存。

多一台 prefill,换来的是首字。一份 B200 上的 DeepSeek-V3 报告,在 1P1D(1 台 prefill 配 1 台 decode)上加一台 prefill。

多一台 prefill,买的是首字快,不是吞吐 —— 每张卡反而少了三成 DeepSeek-V3,B200(每台 8 卡),SGLang + NIXL;1P1D(16 卡)→ 2P1D(24 卡);输入 3,000–4,000、输出 400–600,并发 128 1P1D 2P1D 按机器看:花的卡换来多少字 总输出(tok/s) 1,118.8 1,159.0 +3.6% 每张卡输出(tok/s) 69.9 48.3 −31% 按用户看:等第一个字等多久 平均 TTFT(s) 2.40 1.73 −28% P99 TTFT(s) 12.07 6.23 −48% 加 prefill 前先问:缺的是首字速度,还是每秒出的字 这台 prefill 让排队的请求更快开始,总输出几乎没动。拿每卡吞吐评估 2P1D 一定吃亏,该拿 TTFT 的 SLO 来评。
左边一高一低,右边两组都在降。
B200,并发 128;每卡 = 总输出 ÷ 全部卡数。
出处与口径

📌 gpu/inference/a4/deepseek-v3/REPORT-2P1D-DeepSeek-V3.md:表在 :69、:85,对比在 :100–142(每卡 = 总输出 ÷ 卡数,报告原算法,脚本复算)。c256:1,798.1 → 1,775.6。

⚠️ TTFT 是客户端测的,含排队。两边都开了 --disable-cuda-graph(REPORT-1P1D :129),所以没画 TPOT。

同一组数,按每卡吞吐看是亏,按 TTFT 看是赚。

9.2 换个分母,不拆反而更好的时候

vLLM 跑 V4-Pro,decode 固定 8 张卡,prefill 从 1 个加到 14 个。

只除 decode 卡,加 prefill 像白捡;全部卡都算上,到 12 个就到顶 同一组实测(vLLM,DeepSeek-V4-Pro,GB300;decode = dep8 共 8 卡,每个 prefill TP4 共 4 卡;8K 输入 1K 输出,并发 1,024)。纵轴是每卡 output tok/s ÷ decode 卡(runbook 原口径) ÷ 全部卡(本课推导) 每卡 output tok/s 随 prefill 个数 0 1,000 2,000 3,000 1 2 4 6 8 10 12 14 prefill 个数 307 12 个时 3,187 204 12 个时 455,到顶 415 ×10.4 1 → 12 个 ×2.2 1 → 12 个 两条线都说加 prefill 是杠杆,只是长短不同:×10.4 对 ×2.2,差约五倍 蓝线的分母里没有 prefill 的卡:喂一个小 decode 的 prefill 越多,它越好看。算整机成本要看橙线。 橙线在 12 个 prefill 时到顶,再加就开始稀释每卡产出,配比到这里就够了。
同一组实测,两条线。
蓝线是 runbook 原口径,橙线是本课换了分母重算的。
出处与口径

📌 gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md §12.3(2026-07-24 实测,runbook 注明本文未重测;12 个时取原表的 3,187,25,500 ÷ 8 = 3,187.5);prefill 为 TP4 见同文件 §0。

⚠️ 本课推导:橙线 = output ÷(4 × prefill 个数 + 8)。16 个 prefill 那档撞上失效模式 B、只跑出部分结果,没画。同一 runbook 的 4K 输入重扫显示每个 prefill 喂料约翻倍(1 个 prefill 时 2.06 倍),曲线形状随输入长度变。

蓝线只除 decode 卡,是不少 PD 报告的默认口径(2.1);橙线把 prefill 的卡也算进分母,12 个以后就不涨了。曲线是 2026-07-24 的历史实测,只看趋势。

不拆反而更好的时候。prefill 和 decode 本来没怎么打架时,拆开是白付代价。图是 MiMo-V2-Flash 在 TPU 上的三种摆法:

按 pod 算拆不拆 —— 总量最高的 2P1D,按 pod 算成了同组最矮 MiMo-V2-Flash · TPU v7x(每 pod 4 芯片)· 16K 进 4K 出;单位 K tok/s(total,含输入) 不拆(2 pod) 1P1D(2 pod) 2P1D(3 pod) 总吞吐(README 原值) 11.70K 2 pod 10.55K 2 pod 10.83K 3 pod batch 64 12.78K 2 pod 13.64K 2 pod 15.31K 3 pod batch 128 每 pod 吞吐(本课推导:总吞吐 ÷ pod 数) 推导 5.85 2 pod 推导 5.28 2 pod 推导 3.61 3 pod batch 64 推导 6.39 2 pod 推导 6.82 +6.7% 2 pod 推导 5.10 −20% 3 pod batch 128 2P1D 多出来的总量,是多一个 pod 换来的 batch 64 时,拆了不管按总量还是按 pod 都亏。
总量看 2P1D 最高;按 pod 算,只有 batch 128 的 1P1D 赢一点。
README 原值;每 pod 吞吐为本课推导(总吞吐 ÷ pod 数)。
出处与口径

📌 tpu/sglang-jax/mimo/README.md:8-12、81-88(总体结果表;request_rate=inf,total tok/s 含输入;README 自注只看趋势、未考虑 SLO)。

本课推导:每 pod = total ÷ pod 数;+6.7% = 6.82 ÷ 6.39 − 1(README 写约 6.8%,按表算 6.7%);−20% = 5.10 ÷ 6.39 − 1。

Qwen3-Coder(两台 v7x-8,1K 进 1K 出)单并发拆成 1P1D,首字中位数 95 → 281 ms,输出只多 12%:单并发时两段本不抢资源。

出处与口径:两组 TPU 例子

MiMo:tpu/sglang-jax/mimo/README.md:8–12、81–88,每 pod 4 颗芯片,request_rate=inf,total tok/s 含输入。README 写 1P1D 比不拆高「约 6.8%」,按表算是 6.7%;2P1D 每 pod 5.10K 对不拆的 6.39K(本课推导)。

Qwen3-Coder:tpu/tpu-inference/Qwen3-Coder-480B/README.md:1005–1021,TTFT 与 TPOT 都是中位数。两组都是单点测量。

9.3 决策树:三个问题

答「否」就停。分块 prefill 见第三节,KV 薄不薄见 8.4。

拆不拆,看负载,不看潮流 —— 先试分块,压不住再拆 先做一步,再问三个问题,答否就停。多长算长、多严算严没有通用阈值,要拿自己的负载量 先做的动作(不是问题) 问题 拆 不拆或停 先做一步:开分块 prefill 长 prompt 切成小块,夹在 decode 步之间 ① 开了分块,TPOT 还有 prefill 尖峰吗? 长 prompt 一进来,别人出字仍卡一下 否 → 停:不拆,分块就够 拆了多一趟传输、多一套机器,换不回东西 是 → 才拆,接着问怎么拆 ② KV 能走快线吗? 同一个 NVLink 域 / 同一个 TPU 切片 否 → 停:除非 KV 够薄,或只把长 prompt 外送 出了快线,KV 越厚越慢 是 ③ 拆完,SLO 还有缺口吗? 看哪个 SLO 先破 否 → 停:配比够了 不缺就别再加机器 是 缺首字 → 加 prefill;缺吞吐 → 加 decode 配比先用公式起个头,再往先破的那边加
灰框是先做的一步,蓝框才是那三问。
阈值没画,要拿自己的负载量。
出处与口径

📌 MiMo:tpu/sglang-jax/mimo/README.md:8–12、81–88(TPU v7x 每 pod 4 芯片,16K 进 4K 出,request_rate=inf,total tok/s)。Qwen3-Coder-480B:tpu/tpu-inference/Qwen3-Coder-480B/README.md:1005–1021(两台 v7x-8,TTFT 中位数)。

📌 配比公式:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md §12.2(8 × 11,200 ÷ 1,024 ≈ 87.5 req/s,× 8,192 ≈ 71.7 万 tok/s,÷ 7.28 万 ≈ 9.8)。跨域退化:同文件 :63。PrFaaS:arXiv 2604.15039。

⚠️ 两组 TPU 例子都是单点测量,不是扫描。

9.4 再拆一层:AFD 与 EPD

专题五 §6.5 讲过:decode 里的注意力和专家也能拆到两批机器上,多台注意力机喂同一批专家,专家那边就凑得出大 batch。

再拆一层:注意力和专家也分开 —— 专家那边一次接好几家的 token AFD(Attention-FFN 分离)。示意:M 台注意力机器、N 台专家机器,三个小批轮着跑 注意力机器 专家机器 小批 A(盯着它看) 小批 B 小批 C 每一层都要跑一趟 M → N → M 注意力机器 1 注意力机器 2 注意力机器 3 专家机器 1 专家机器 2 去(M → N):token 发给专家 回(N → M):算完送回来 三个小批轮着跑:去、回各占半格 注意力 A A A B B B C C 去 A A A B B C C 专家 A A A B B C C 回 A A B B C C 0 1 2 3 4 5 6 7 8 看 A:第 0 格算注意力,去半格,专家一格,回半格,第 3 格又轮到它。 单程通信超过半格,一圈就超过 3 格,得四个小批(MegaScale-Infer)。 拆得越细,每一边越能挑适合自己的机器和切法 专家那边同时接几台注意力机器的 token,凑出来的 batch 比单台大得多;两边的机器数也能分开调。 代价是每一层都有一趟来回,得靠几个小批轮着跑藏住(论文里要三四个才藏得住);两边之间的网络要够快。
一层里的两种活,分到两批机器。
专题五原图,机器数是示意。
出处与口径

📌 MegaScale-Infer arXiv 2504.02263(disaggregated expert parallelism、ping-pong pipeline、每 GPU 吞吐最高 1.90×);Step-3 arXiv 2507.19427;vLLM 于 2026-07 发布实验性 AFD 插件。

字节 2025 年的 MegaScale-Infer 报告每卡吞吐最多是对照系统的 1.90 倍;阶跃星辰的 Step-3 在 Hopper 上、50 ms TPOT、4K 上下文的约束下,峰值每卡 4,039 tok/s;论文拿来对照的 DeepSeek-V3 是 2,324,那是 DeepSeek 自己公开的 H800 profile 峰值,不是 Step-3 重测的。模型不同,Step-3 这档还用了 FP8 注意力,差距不能全记给 AFD。TPU 上本课没找到公开的 AFD 实现。

开源实现没这么顺:vLLM 的 AFD 是外部插件,主仓库的提案(RFC)已因不活跃被关闭;插件博客在 Ascend 910C 上的数,配比一错就比不拆还慢。

AFD 拆开不保证更快 —— 算注意力的给少了,算专家的就在等 vLLM AFD 插件,昇腾 910C,DeepSeek-V3.2(权重和激活值都压成 8 位),decode 跑满。die 是芯片上的一块计算单元,这里当一张卡数 小人:算注意力的 die 小人:算专家(FFN)的 die 小人:两样都干 / 柱:不拆 柱:比不拆慢 柱:比不拆快 每块 die 每秒出多少 token = 总输出 ÷ 该行全部 die(左:怎么分工;右:16K 和 32K 输入两种长度) 不拆:共 64 块,每块两样都干 16K 输入 232.6 32K 输入 168.2 拆开:48 块算注意力 + 16 块算专家 = 共 64 块 专家这边吃不饱 16K 输入 220.3(-5.3%) 32K 输入 151.4(-10.0%) 拆开:64 块算注意力 + 16 块算专家 = 共 80 块 专家更忙,仍有余力 16K 输入 258.9(+11.3%) 32K 输入 183.3(+9.0%)
同样拆开,橙柱亏、绿柱赚。
每 die 吞吐的分母是部署的全部 die。
出处与口径

📌 vllm.ai/blog/2026-07-23-vllm-afd-plugin / github.com/vllm-project/afd-plugin:AFD 是外部插件,不是 vLLM 原生功能;vLLM 的 AFD RFC #22799 于 2026-05-31 被机器人以长期不活跃关闭,没有合入。博客原话:只拆开,不保证吞吐提升;测过的配比下 FFN 还有余力,没测更高的 attention 比例。

⚠️ 48A16F / 64A16F 模拟的是逻辑上的 192A64F / 256A64F(博客原文);专家路由换成了强制均衡(输出会变)。只能看趋势。「专家这边吃不饱」是按博客「FFN 还有余力」的定性说法画的,没有利用率数字。

出处:AFD 的几个数

MegaScale-Infer:arXiv 2504.02263(对照的是当时最好的方案)。Step-3:arXiv 2507.19427 表 8(4K 上下文、FP8、不开 MTP;4,039 是峰值那一分钟,长期平均 3,910)。vLLM AFD 插件:vllm.ai/blog/2026-07-23-vllm-afd-plugin、github.com/vllm-project/afd-plugin;RFC #22799 于 2026-05-31 被机器人关闭。

EPD:多模态把编码也拆出去。多模态模型在 prefill 前要把图片、视频编码成 token,图一多就和 prefill 抢资源。

回到主线 AFD 让每个专家一趟分到更多 token。拆不拆、怎么配,看负载,不看潮流。 留下的问题:DEP、PD、AFD 摆在一起,先定哪种拓扑、再调哪些参数(第十节)?
第 十 节

先选拓扑,再调参数

第六到九节给出了一串拓扑,每换一个,调好的参数就得重找。换一次拓扑,抵得上把参数调遍。

10.1 切法先定:先看分母,拓扑是硬约束

专题五 §7.1 讲过:通信勤的切法要放在快线里,懒的才能跨慢线。

每种切法多久说一次话 —— 说得勤的放快线,说得少的才走慢线 每步通信次数(按实际比例,本课推导)。示意配置:60 层、8 个 micro-batch、每层都是 MoE 放在最快的那一层线上 可以跨到慢线上 一步里的通信次数 TP 1,920 次 每层 4 次 all-reduce EP 1,920 次 每个 MoE 层 4 次 all-to-all FSDP 1,440 次 每层拼一次、反向再拼一次、再散一次 PP 16 次 每个 micro-batch 过段边界一来一回 DP 1 次 每步一次梯度 all-reduce 0 500 1,000 1,500 两种线差多少(GB300 NVL72,每块 GPU,双向) 一柜之内:NVLink 1,800 GB/s 出了这一柜:网卡 200 GB/s ← 差 9 倍 上下两张图一对,摆法就出来了 TP 每一层都要通信又藏不住,必须待在 NVLink 域里(GB300 是一整柜 72 块);EP、FSDP 能边算边传时才敢跨出去。 PP 一步十几次、DP 一步一次,跨到慢线上也吃得消。TPU 上同理:切片里走 ICI,跨切片走数据中心网络。
通信越勤的切法,越要放在快线里。
专题五原图,复用。这是训练口径;推理只有前向,FSDP 和梯度那几行不适用。
出处与口径

📌 次数为本课推导:TP 每层前反向各 2 次 all-reduce(arXiv 1909.08053 sec. 3);FSDP 每层 3 次(ZeRO 的 3Ψ,arXiv 1910.02054 sec. 7);EP、PP、DP 按调度数出;叠上 PP 时 TP 的次数要除以 PP 段数,开重算时 TP 每层是 6 次。链路:GB300 NVLink 5 每 GPU 1.8 TB/s;A4X Max 每节点 4 块 GPU、4 × CX-8 800 Gb/s。

「+45% 对 +347%」:先看分母。这两个数出自 V4-Pro 的部署记录,都是总吞吐,可图里三档配置用的卡数各不相同。

同一组数,换个分母结论就变 —— 「调参 +45%」按每卡算是 -28% GB300 · DeepSeek-V4-Pro · vLLM · 4K 进 1K 出。吞吐 = prompt + 输出 token 每秒。柱下每个小方块是一张卡(空心 prefill,实心 decode),柱里是并发 1p1d 起点 3p1d:加 prefill、调并发 换 decode 拓扑:dep8 总吞吐(tok/s) 0 20K 40K 60K 14,563 并发 256 8 卡 16,459 并发 256 16 卡 21,100 并发 512 16 卡 55,153 并发 512 20 卡 65,132 并发 1536 20 卡 调参:14,563 → 21,100,+45%(8 卡 → 16 卡) 换拓扑:14,563 → 65,132,+347%(8 卡 → 20 卡) 只调并发 +28% 每卡吞吐(tok/s/GPU,本课现算 = 总吞吐 ÷ 卡数) 0 1,000 2,000 3,000 1,820 并发 256 8 卡 1,029 并发 256 16 卡 1,319 并发 512 16 卡 2,758 并发 512 20 卡 3,257 并发 1536 20 卡 调参那一步:1,820 → 1,319,每卡 -28% 换拓扑:3,257 = 3p1d 最好的 2.47×,1p1d 起点的 1.79×
左右两栏只换了分母,看「调参」那一步。
卡数含 prefill 与 decode。
出处与口径

📌 gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:446(1p1d 并发 256,14,563)、:448(3p1d 并发 256,16,459)、:449(3p1d 并发 512,21,100)、:465(3p + dep8 并发 512,55,153)、:468(并发 1,536,65,132)。「+45% / +347%」原话见 :489;「每卡 2.47×」见 :476;「256→512 涨 28%」见 :487。

⚠️ 本课推导:每卡数 = 总吞吐 ÷ GPU 数(1p1d 8 卡、3p1d 16 卡、3p + dep8 20 卡,后两个数见 :476);-28% 与 1.79× 是现算,原文没有。吞吐口径是 prompt 加输出的总 token,sa-bench、temperature=0。

拆开看,+45% 里大半是加卡:prefill 从 1 台加到 3 台,卡数翻倍,每卡反而变少。卡数不变、只调并发的那一步才是纯调参。

换拓扑在两种口径下都赢:按每卡算,换 DEP 是 TP4 的 2.09 倍(第六节),只调并发是 +28%。dep8 再拉高并发时每卡最高,但首字 95 s,已出了交互档。

拓扑约束是硬的。16 个 device 跑 TP16,机间走 DCN 还是 ICI,结果差出一截。即便走 ICI,两台的总输出 513.8 tok/s 也不如单机 602。

卡数一样,线不一样 —— TP16 跨 DCN 最多慢 63%,同一 ICI 切片只慢 15–21% Qwen3-Coder-480B · TPU v7 · vLLM(tpu-inference)。纵轴:多机 TP16 的输出吞吐相对单机 v7x-8 TP8 差多少 两台 v7x-8 走 DCN 两台编进同一个 ICI 切片 多机 TP16 对单机 TP8(输出 tok/s) 打平 -20% -40% -60% -22% -21% 1K/1K c=1 -44% -19% 1K/1K c=4 -63% -15% 1K/1K c=16 -17% -16% 8K/1K c=4 -54% 未测 8K/1K c=16 柱子往下长:越长越慢 两台 v7x-8,两种连法 两台各自一片,中间走 DCN v7x-8:4 颗芯片 v7x-8:4 颗芯片 机内粗管 ICI,机间只有细管 DCN 两台编进同一个 ICI 切片 机间也接上粗管 ICI
device 数相同时,决定快慢的是那条线。
口径:只数输出 token;负数是比单台机器慢多少。右图:同样两台 v7x-8,机间走 DCN 还是编进同一个 ICI 切片。
出处与口径

📌 跨 DCN:tpu/tpu-inference/Qwen3-Coder-480B/README-multinode.md:441-445(单机 v7x-8 TP8 对多机 v7x-16 TP16,输出 tok/s);原因与 DP 建议见同文件 :457 起。

📌 ICI 切片:tpu/tpu-inference/Qwen3-Coder-480B/README-TPU-VM.md:1000-1009(Workload Policy 把两台编进 2x2x2 切片,表中 Aggregate tok/s;8K/1K c=16 没测,记作「未测」)。

⚠️ 右栏是示意:只画「机内粗、机间细」和「编进同一切片后机间也是 ICI」,不按真实链路条数和 3D torus 布局。

📌 NVL72:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:34(必须同一 NVL72 域)、:63(跨域退化到 RDMA)。

TP 每层都要把各卡的部分和加起来,跨慢线就层层要等;原记录建议开两份单机做 DP。

GPU 上同理。V4-Pro 的 SGLang 部署要求 16 个节点都在同一个 NVL72 域:PD 之间传 KV 走 NVLink,跨域退化成 RDMA,原文只说「显著变慢」。

TPU 上,device 编号就是拓扑。JAX 的 mesh 是一张 device 列表排成的网格。列表怎么排,决定了沿哪一轴通信时哪几个 device 一组。

TPU 上的 device 顺序就是拓扑 —— 顺序错了,数据发给错的对端 示意:4 颗芯片连成环,每颗 2 个 device(chip ≠ device)。方块里的数字是 mesh 里的编号,灰色粗线是芯片之间的物理链路 一跳到邻居 绕远路 互相等,卡死 按物理相邻编号 芯片 0 芯片 1 芯片 2 芯片 3 0 1 2 3 4 5 6 7 1→2 3→4 5→6 7→0 「下一个」都在隔壁:每步一跳 顺序打乱(同样 8 个 device) 芯片 0 芯片 1 芯片 2 芯片 3 0 4 2 6 1 5 3 7 第 1 段 第 2 段 0 的「下一个」1 在对角:绕两段 各进程算出的顺序不一致 进程 A 进程 B 进程 C 都在等对方先发 第一次集合通信就卡住,不报错
看编号顺序怎么决定环的走法。
真实 v7 是 3D torus。
出处与口径

📌 JAX 文档 jax.experimental.mesh_utils:create_device_mesh「creates a performant device mesh」,create_hybrid_device_mesh 分 ICI 与 DCN 两层。

📌 v7x-8 = 4 chips / 8 devices:tpu/tpu-inference/README.md:41。

⚠️ 本课示意:只画「顺序决定邻居」的机制;真实 v7 是 3D torus,环的画法和 device 编号都是简化。卡死那一栏是机制推演,不对应某次公开事故。

所以 mesh 交给 mesh_utils.create_device_mesh 按物理位置生成,跨切片用 create_hybrid_device_mesh 把 ICI 和 DCN 分成两层。

10.2 最小切片、容量与对照实验

最小切片怎么定。一个引擎最少几个 device,先算纸面账:权重 + KV + 激活值(中间结果)的显存。拿 DeepSeek-V3 在 TPU v7 上算(口径同 4.1):一颗芯片是两个 device,各管各的 94.75 GiB,账按 device 记,最后再换回芯片数。

DeepSeek-V3 在 TPU v7 上最少几个 device —— 权重是地板,KV 决定往上加多少 本课推导:FP8 权重 625 GiB + KV(每 token 70,272 B)÷ 每 device 85.275 GiB(可用 94.75 GiB,预留一成给激活值;一颗芯片=两个 device),向上取到切片档位 FP8 权重 625 GiB KV = 上下文 × 并发 × 70,272 B 竖虚线:这一档 device 能放多少 要多少 HBM(GiB),取几个 device 8 dev(4 颗) 16 dev(8 颗) 32 dev(16 颗) 64 dev(32 颗) 4K × 64 642 7.53 → 8 dev 4K × 256 694 8.13 → 16 dev 32K × 64 762 8.94 → 16 dev 32K × 256 1,174 13.77 → 16 dev 128K × 64 1,174 13.77 → 16 dev 128K × 256 2,821 33.08 → 64 dev 纸面 device → 取档 切片只有 8 / 16 / 32 / 64 个 device 这几档:纸面 8.13 个也只能取 16 个(8 颗),33.08 个就得取 64 个(32 颗)
六种配置里四种落在 16 个 device(8 颗);最长最满那行跳过 32 个,要取 64 个(32 颗)。
KV 按 bf16 计;纸面下限。
出处与口径

📌 DeepSeek-V3 结构(671B、61 层、MLA kv_lora_rank 512 + rope 64、256 专家):topic06_numbers.py,来自 HF config.json。每 token KV 70,272 B = (512 + 64) × 2 B × 61 层。

📌 每 device 可用 94.75 GiB(README 写 GB,运行日志为 GiB;v7 每芯片物理 192 GiB)、FP8 MoE 实测约 101.8/device 超 HBM 所以用 FP4:tpu/tpu-inference/DeepSeek-R1-671B-FP4/README.md:59、:72-73(R1 与 V3 同架构)。

⚠️ 本课推导与假设:FP8 每参数 1 字节、不计 block scale;激活值预留 10% 是假设;KV 不重复(DP 注意力或 EP),没算 DP 注意力在每个 device 上各放一份约 17B 非专家权重的开销;切片档位取 8/16/32/64 个 device(v7x-8/16/32/64,= 4/8/16/32 颗芯片)。纸面 MoE 76.1 GiB/device = 256 × 58 层 × 3 × 7168 × 2048 字节 ÷ 8 device。

到 128K、256 并发,KV 约 2,196 GiB,是权重的 3.5 倍。要装下只有三条路:加芯片;KV 存 FP8(第十二节末尾);冷 KV 下放主机内存(4.4)。DCP 帮不上:这里 KV 本就只存一份(DP 注意力),DCP 只把一条序列摊开,而一条 128K 才 8.58 GiB。

纸面最少 8 个 device(4 颗),实测却放不下:光 FP8 专家就顶到上限,v7x-8 上实际用 FP4(12.2)。(R1 和 V3 同结构:FP8 专家每个 device 约 101.8 GB,上限 94.75 GiB ≈ 101.7 GB;再加注意力约 9 GB,本课推导:FP4 连同注意力 70 − 专家 60.9。比按 8 份均摊多约 20 GB,原记录没拆原因。)

本课推导的边界纸面账只给下限,激活值预留 10% 也是假设;用一次真实启动看实测的 HBM 峰值。

容量别拿小并发估。R1 在 GB300 上的部署记录先估了这套 DEP8 decode 的容量,起初却只拿并发 8 去量。

拿 conc=8 的数估容量,只看到了 3% —— 峰值是它的 12.5 倍 GB300 · DeepSeek-R1 · SGLang · 3P2D(20 卡)· 1024 进 512 出。纵轴:总吞吐(prompt + 输出 token 每秒) conc=8:只用到估算容量的约 3% 往上扫,直到见顶 估算容量约 288 并发 并发 → 总吞吐 0 4,000 8,000 12,000 估算容量 ~288 8 32 64 128 192 256 384 512 并发(压测端发的) 854 10,390(甜点,TTFT 12 s) 10,715(峰值,TTFT 30 s) 容量要扫出来:一直加并发,直到吞吐不涨、延迟开始爆 conc=8 时 decode 每一趟只分给 8 个请求,测到的是「这套机器闲着时多快」,不是它能扛多少。 过了 256 吞吐只再涨 3%,首字延迟从 12 s 涨到 30 s。甜点由延迟目标定,不由吞吐峰值定。
看红点离灰虚线多远,再看虚线右边那段线有多平。
口径:并发是压测客户端同时挂着的请求数,不是服务端实际批大小。
出处与口径

📌 gpu/inference/a4x-max/deepseek-v3/sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md:401(「conc=8 只用到 DEP8 decode 容量的 ~3%,GB300 DEP8 理论可扛 ~288 并发」,是估算不是实测)、:405-413(并发扫描表:总吞吐、TTFT median)、:415(峰值是 conc8 的 12.5×)。

⚠️ 横轴是压测端设的并发;表中「实际并发」更低(512 时实测 416),原因是开环压测里有请求在排队。8 ÷ 288 = 2.8%,原文写约 3%。

对照实验的纪律。

10.3 五步选法落到两个例子

专题五 §7.4 的五关,推理时照样走一遍。PP 是流水线并行:按层切给几组卡。

同样五关,两台机器走出两套配置 —— 五关里只有一关答案相同 从上往下逐关回答;左列 DeepSeek-V3 跑在 TPU v7 上,右列 DeepSeek-V4-Pro 跑在 GB300 上 TPU 列 GPU 列 ≠ 两边答案不同 DeepSeek-V3 · TPU v7 DeepSeek-V4-Pro · GB300 ① 装得下 纸面 4 颗(v7x-8)够 实测 FP8 放不下:用 8 颗,或专家换 FP4 约 800 GB 权重 一个 4 卡节点放得下(TP4 跑通过) ≠ ② 快线多大 一个 ICI 切片 TP 不跨 DCN 一个 NVL72 域,72 卡 SGLang 部署要求全部节点同域 ≠ ③ 序列 KV 总量大,但单条装得下 DCP 帮不上 只有 1 个 KV 头,TP 只会复制 KV 改用 DEP(第六节) ≠ ④ PP 不用:一个切片放得下 不用 = ⑤ DP 剩下的卡开副本 每份留在自己的切片里 先定 P:D(第九节) 再按目标用户数加 decode 副本 ≠
没有哪列更对:同一道关,硬件和模型变了,答案跟着变。
每格是本课按部署记录归纳的结论。
出处与口径

📌 TPU 列:见本节正文;4 颗/8 颗/FP4 见台账「V3 FP8 切片表」与 R1 FP4 README:59、72-73(R1 与 V3 同结构)。

📌 GPU 列:806 GB 见 gpu/inference/a4x-max/deepseek-v4/README.md:55;TP4 跑通见 VLLM-V4PRO-RUNBOOK.md:449(vLLM 用的是 832 GB FP8 版,:127);同一 NVL72 域见 SGLANG-V4PRO-RUNBOOK.md:34、63;只有一个 KV 头见第六节。

⚠️ 本课归纳:五关顺序取自专题五 §7.4,每格是本课按上述记录填的结论,不是某份 runbook 的原表。

⭐ 拓扑定了那一趟搬运走哪条线、能分给多少人,参数只在这个上限底下挪动。先选拓扑,再调参数;比较时先看分母。留下的问题:这些都靠把 batch 做大,交互档压住 batch 时,一趟还是只出一个字(第十一节)。

第 十一 节

投机解码:搬一趟,出好几个字

第三到十节大多在做大 batch;可交互档限住了 batch,推理模型又一答几千字(0.1),「搬一趟权重只出一个字」就成了硬上限。 投机解码先便宜地猜几个字,再让大模型搬一趟验完,猜对几个就出几个。

11.1 先猜后验:收益账

大模型把草稿当一段输入,一步算出每个位置该写的字,逐个对照。

先猜后验 —— 大模型读一遍权重,验掉一整串草稿 横轴是时间(示意,不按比例)。每一格字:绿 = 草稿猜对、被收下;红 = 猜错、连同后面的全扔掉;蓝 = 大模型自己给的字(第一个错的位置补上;全对时白送下一个) 大模型读一遍权重 草稿猜一个字 收下 扔掉 大模型补的字 同样长的时间,两种走法 普通 decode 一步一个字 读一遍权重 1 读一遍权重 2 读一遍权重 3 投机解码 猜 4 个,验 1 次 猜 猜 猜 猜 读一遍权重,验 4 个 ✓ ✓ ✕ ✕ 补 这一轮前进 3 个(收下 2 + 补 1) 猜 猜 猜 猜 读一遍权重,验 4 个 ✓ ✓ ✓ ✓ 送 这一轮前进 5 个(收下 4 + 白送 1) 同一段时间 时间 → 普通 decode 出 3 个字,投机解码出 8 个字 接受到第几个,就前进几个 草稿便宜,贵的是大模型读权重那一下;只要那一下没变慢多少,猜对几个就白赚几个字。 猜错只浪费草稿那点功夫:第一个错的位置大模型本来就算出来了,所以每轮至少前进 1 个,不会比不开更少出字。
对齐上下两行的灰条:投机这行少读一遍权重,出的字反而多。
示意时间线,格子长短不按比例。
出处与口径

⚠️ 示意:格子长度(普通一步 10 格、草稿每个 1 格、验证一步 11 格)和接受个数都是举例,不是实测。

机制:Leviathan 等 arXiv 2211.17192;Chen 等 arXiv 2302.01318。收下第 i 个草稿的概率是 min(1, p/q),被拒时从 max(0, p − q) 归一化后重新抽,输出分布与大模型逐个生成相同。

注:「不会比不开更少出字」只说字数;如果验证一步明显变慢、草稿又总猜错,墙钟时间照样可能变长(见并发那张图)。

看碰到第一个错字之后,大模型怎么接手。 (23 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。示意,按温度 0 贪心比对。)

用标准拒绝采样(按概率决定每个草稿字收不收)时,投机解码只改速度,不改输出分布。为什么不直接比两边抽的是不是同一个字:两边都按同一个均匀分布从一百个数里抽,想法完全一样,也要一百次才对上一次(Google 投机解码回顾博客的示意反例)。所以比的是把握:收下的概率是 min(1, 大模型概率 ÷ 草稿概率)。

收益账:接受长度 ÷ 一步变慢了多少。每步平均出几个字叫接受长度。小 batch 时一步主要在读权重,多验几个 token 本该几乎不加时间。

多验证几个 token 贵不贵 —— 稠密部分白送,MoE 专家不白送 左:V3 验证一步要读的权重(本课推导,FP8)。右:Kimi K3 实测,搬一趟变慢了,但一趟带回的字多得多 每个 token 都经过的部分 路由专家(各挑各的) 开投机后的一趟 V3 验证 n 个 token,一步读多少 GB 0 60 120 180 GB 1 37.5 2 3 4 5 6 7 8 163.8 一步验证的 token 数 n 验证 8 个 = 验证 1 个的 4.4 倍 浅蓝 17.1 GB 不随 n 变 Kimi K3 实测:搬一趟,带回几个字 不开投机 搬一趟 11.1 ms 带回 1 个字 开投机 搬一趟 16.1 ms 平均带回 6.96 个字 用时 1.45×,对不开 摊到每个字 11.1 ms → 2.31 ms,降到 1/4.81 一趟慢一点不要紧,带回的字多得多
看左边:稠密部分验几个都只读一遍,专家却越验越多。
左为本课推导(FP8、均匀路由);右为 K3 在 GB300 上 bs=1 的实测时间账。
出处与口径

V3 结构取自 HF deepseek-ai/DeepSeek-V3 config.json:hidden 7,168、moe_intermediate 2,048、61 层中前 3 层稠密、256 个路由专家挑 8 个。每个专家 3 × 7,168 × 2,048 ≈ 4,404 万参数。

⚠️ 本课推导:其余部分 = 671B − 256 × 58 × 专家大小 ≈ 17.1B;由此推出每 token 激活 ≈ 37.5B,与技术报告的 37B 差 2% 以内(外部锚点)。

⚠️ 本课推导:n 个 token 独立、均匀地挑专家时,一层平均碰到 256 × (1 − (1 − 8/256)^n) 个;实际路由不均匀、相邻 token 常挑同一批专家,所以深蓝那段是偏高的估计。

K3:gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md:1089(GB300 TP8 跨两节点,ISL 4096/OSL 1024,temperature 0,bs=1,TPOT 11.1 → 2.31 ms)、:979(accept len 6.96,block 7)。

⚠️ 本课推导:开投机后一趟耗时 = 2.31 ms × 6.96 ≈ 16.1 ms;每字间隔降到 1/4.81(11.1 ÷ 2.31 ≈ 4.81)。runbook 报的端到端 4.22× 含首字时间,所以比 4.81 小。右图第 7 个方块代表平均值里的 0.96 个,示意。

注:K3 是 8 张卡跑 bs=1,一步里除了读权重还有通信和 kernel 之间的空转,所以「用时 1.45×」不能全归给多读的专家。

MoE 不白送:每个 token 挑自己的专家,验得越多读的专家越多(图左;估算,偏高)。

图右是 K3 在 GB300 上的实测:一步慢了一截,接受长度却大得多,相除仍是好几倍。

11.2 收益会缩,温度会骗人

收益会缩:并发、上下文、DEP。并发一高算力先满,草稿里每个 token 都得真算。 K3 输出吞吐对不投机的倍数,并发从 1 加到 64 一路往下缩。并发 1 的倍数也低于 11.1 的每字提速,因为端到端含不受加速的 prefill。

投机解码的收益会缩 —— 人一多、上下文一长,白送的那部分就变少 Kimi K3 · GB300 · SGLang TP8。柱高 = 开投机后的输出吞吐 ÷ 不开;虚线 = 1,不赚不赔 4K 上下文,并发 1 → 64 32K 上下文,并发 1 开投机后的吞吐是不开的几倍 1× 4.22× 并发 1 2.86× 并发 8 1.89× 并发 32 1.74× 并发 64 1.32× 32K · 并发 1 同样并发 1, 上下文 4K → 32K: 4.22× → 1.32×
看柱子往右怎么缩。
K3 输出 tok/s 总量;B200 与 V4-Pro 的对照见出处。
出处与口径

K3:gpu/inference/a4x-max/kimi-k3/SGLANG-K3-RUNBOOK.md:1089-1092(GB300,TP8 跨两节点,ISL 4096/OSL 1024,random,temperature 0,开环,只报热轮;输出 tok/s 总量)、:1057-1058(32K,只测了并发 1;8/32 没测,集群已删)。

注:K3 并发 64 时开投机的 TPOT 仍只有不开的 40%,这一档吞吐和延迟同时变好。

另两组相关实测的出处 —— B200:gpu/inference/a4/deepseek-v4/README.vllm.md:265-277(DeepSeek-V4-Flash,8× B200,vLLM v0.20.0,EP+DP=8,MTP num_speculative_tokens=2;接受率约 54%;十档并发 −3% 到 −37%)。

V4-Pro:gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md:900-911(steps 1/draft 2 → steps 2/draft 3;接受长度 1.88 → 2.36(+26%),反推单步耗时 115.3 → 162.5 ms(+41%);decode 峰值 −13%、端到端 +28%)。B200 那套是 EP+DP 高吞吐配置,结论不能搬到 TP-only 低延迟配置。

上下文变长也会缩(图最右柱)。 验证本不该因此变贵:不开投机时每字间隔只从 11.1 涨到 11.4 ms,多验的位置又共用同一份 KV。 更可能是接受长度掉了,或草稿读长 KV 变慢(没实测,本课推导)。

DEP(第六节)本为大 batch 而设,高并发时算力已满,投机成了纯开销:B200 上 DeepSeek-V4-Flash 用 vLLM、DEP8 开 MTP,十档并发全变慢(−3% 到 −37%),并发 1 也慢 12%。

峰值和端到端还可能反向:GB300 上 V4-Pro 把 MTP 从 1 步加到 2 步,decode 峰值掉 13%,端到端反涨 28%。真实负载 batch 多半没那么大,白送的那部分还在。

温度:压测怎么发,结果就怎么变。草稿的抽样要和请求的温度对上。贪心草稿(相当于温度 0)遇上温度 1.0 的随机采样,理论接受率就是大模型给这个 token 的概率,会降但不归零。

温度:大模型出答案时掷不掷骰子 —— 草稿总写最可能的字,骰子一掷就对不上 题目:「今天天气真_」,最可能填「好」。草稿是贪心的,永远交「好」;大模型按温度决定标准答案(示意) 草稿交的答案 对不上,扔掉 对上,收下 温度 1.0 · 服务端默认 草稿交 「好」 对 掷骰子 五道各自独立的题(举例;不是同一步的五个位置,格子数也不是比例) 「不错」 ✕ 扔掉 「热」 ✕ 扔掉 「好」 ✓ 收下 「晴」 ✕ 扔掉 「冷」 ✕ 扔掉 V4-Pro 实测接受率 1.16% 944 tok/s 温度 0 · 请求里写明 草稿交 「好」 对 只认最可能那个 同样是五道独立的题(举例) 「好」 ✓ 收下 「好」 ✓ 收下 「好」 ✓ 收下 「好」 ✓ 收下 「好」 ✓ 收下 V4-Pro 实测接受率 34% 2,911 tok/s 温度 0 的实测吞吐是温度 1.0 的 3.1 倍 温度 0 那行也没全收:实测接受率 34%,其余是草稿自己没猜中大模型最可能的那个字。
看温度 1.0 那侧:草稿猜对也常被判错。
V4-Pro 为 4K/1K 并发 256 实测;五个候选字是举例。
出处与口径

⚠️ 示意:「今天天气真_」和温度 1.0 那行掷出的五个字是举例,不是实测分布。

V4-Pro:gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:398-410(GB300,vLLM,4K/1K,并发 256)。generation_config 默认 temperature 1.0;DSpark 草稿 draft_sample_method 为 greedy,num_speculative_tokens=7。vllm bench serve 不发 temperature;sa-bench 硬编码 0.0。

正文里 K3 的数(接受长度:代码类约 4.73、创作类约 2.61):gpu/inference/a4x-max/kimi-k3/VLLM-K3-RUNBOOK.md:226-237(官方压测 temperature 1.0、top-p 0.95;DSpark 用 probabilistic 草稿,草稿自己也掷骰子,所以温度 1.0 也对得上;接受长度为官方参考值,本仓库未复测)。

告警:gpu/inference/a4x-max/kimi-k3/PD-BACKLOG.md:175。

GB300 上 V4-Pro 用的 DSpark 草稿(11.3)是贪心的,服务端默认温度 1.0。 压测工具不发温度,就按 1.0 采样。 实测接受率(图)远低于理论值:它是收下的 ÷ 猜的,每步猜 7 个,第 1 个被拒,后 6 个跟着作废(本课推导)。

接受率掉了不会报错 它只让 TPOT 慢慢变差。线上要把接受率和接受长度当一级指标告警;跨框架比先对齐两边发不发 temperature。

11.3 草稿从哪来

各家报的倍数口径不同,不能横比。

草稿从哪来 —— 一步步长进大模型身上,或者干脆不要模型 横轴是首次公开的时间:论文按 arXiv 首版,Prompt Lookup 没有论文,按 GitHub 仓库。每张卡只写草稿从哪来 主线:要训练的草稿(小模型/头/层) 侧枝:不用草稿模型 草稿越来越贴着大模型自己长 2022-11 投机解码 另放一个独立小模型 打草稿 2024-01 Medusa 大模型头上 加几个解码头 2024-01 EAGLE 小模型读大模型的 隐状态来猜 2024-12 MTP · DeepSeek-V3 预训练时就多带一层, 共享输出头 2025-03 EAGLE-3 把大模型几层的隐状态 拼在一起来猜 2026-07 DSpark 半自回归一次出一小段, 按置信度定验几个 2022 2023 2024 2025 2026 2023-11 Prompt Lookup 不用草稿模型: 直接从 prompt 里抄
看草稿从哪来。
出处与口径

时间取 arXiv 首版(2026-10-15 逐个核过摘要页):投机解码 Leviathan 等 2211.17192;Chen 等 2302.01318;Medusa 2401.10774;EAGLE 2401.15077、EAGLE-2 2406.16858;MTP · DeepSeek-V3 2412.19437;EAGLE-3 2503.01840;DSpark 2607.05147。Prompt Lookup 没有论文,年份按 GitHub 仓库 apoorvumang/prompt-lookup-decoding 的创建时间(2023-11,GitHub API 核过;已集成进 vLLM 与 transformers)。Medusa 与 EAGLE 都是 2024-01,轴上两点挨着。

没画进图的:SpecInfer 2305.09781 把草稿排成树;SuffixDecoding 2411.04975 从历史输出里抄;扩散草稿 DiffuSpec 2510.02358、DFlash 2602.06036;Lookahead 2402.02057。P-EAGLE、PARD、LayerSkip 等也没画。

注:各家倍数都是原作者在自己的模型和负载上测的,口径不同,不横比,所以图上不画。

还有一支不要草稿模型:n-gram(也叫 Prompt Lookup)拿已经写出的最后几个字,到提示词里找一样的片段,把后面几个字照抄成草稿。

n-gram 草稿:不用草稿模型,从提示词里照抄 用户:「把下面代码里的 3.14 换成 math.pi」。一格一个 token;示例自拟 和末尾对上的片段 照抄来的草稿 大模型自己出的字 被拒 一次前向,前进 3 个字 ① 提示词里 def area (r ): return 3.14 * r * r ② 已经写出 def area (r ← 末尾两个字在 ① 里找到了 ③ 草稿:照抄后面 4 个 ): return 3.14 * ④ 大模型一次验完 ): return 3.14 math.pi ✓ ✓ ✗ 第一个被拒的位置,大模型自己出字 提示词里重复越多,抄中越多 改代码、摘要、按文档回答这类「答案大段来自输入」的活最赚;闲聊几乎抄不中,白验一遍。
顺着 ① 到 ④:橙色对上,绿色照抄,红色被拒处换成蓝色。
示例自拟,只说明机制。
出处与口径

做法:prompt-lookup-decoding 仓库 README(用提示词里的字符串匹配代替草稿模型,输入依赖型任务 2–4 倍);vLLM vllm/config/speculative.py 的 method="ngram"、prompt_lookup_min/max(都不填时默认取 5);SGLang --speculative-algorithm NGRAM。

示例代码、匹配两个字、抄 4 个、验出 ✓✓✗ 都是自拟,只为说明机制;真实实现按 prompt_lookup_min~max 个 token 匹配。

vLLM 在 4 张 H100 上跑 Llama 3 70B、每秒 1 个请求,摘要数据集上最多快 2.8 倍;同条件换小草稿模型跑 ShareGPT 对话是 1.5 倍。开法:vLLM 的 speculative_config 里 method 写 ngram,SGLang 是 --speculative-algorithm NGRAM。

EAGLE 也要训,只是训得很少。大模型冻住,嵌入层和 LM head 直接借,只训中间一个 FC 加一层 decoder;给 70B 配的这块,用 6.8 万条 ShareGPT 对话就训得出来(EAGLE 论文)。

EAGLE-3 改了两处(图第二块)。第二处 training-time test 让训练和推理时草稿吃到的输入对上了;论文说正因为这样,加训练数据才能接着涨,原版 EAGLE 加数据提升有限。

MTP 的骨架跟 EAGLE 几乎一样(图第三块),区别在谁训。带 MTP 的不止 DeepSeek:Qwen3-Next 专门按多步推理来训;Nemotron 3 Super 训两层共用权重的 MTP,可反复套用猜两个以上(Raschka 架构图鉴)。

一层 MTP 也能连猜,但原版只练过往前一步(图右下)。FastMTP 冻住主模型,用主模型自己生成的数据,把 MiMo-7B 那一层 MTP(2.1 亿参数)按连猜微调,平均速度是不投机的 2.03 倍。

EAGLE 和 MTP 长什么样 —— 头尾借大模型,只训中间一小块 方框里橙色是要训的,蓝色是直接借大模型、不训的 要训 借大模型,冻住不训 数据怎么拼 EAGLE(2024-01):大模型冻住,草稿是外挂的一小块 大模型出字前那层的向量 大模型本来就算出来了 抽中的字 已定下的下一个 嵌入层 借 拼起来 2 倍宽 FC 压回 1 倍 一层 decoder 猜下一位的向量 LM head 借:向量变成字 草稿字 猜出的向量 + 刚抽中的字,再喂回去猜下一个:猜几个跑几趟 为什么要喂抽中的字: 光看向量,不知道 上一步按概率抽中了谁 70B 配的这块: 可训 0.99B 参数, A100 服务器 1–2 天 EAGLE-3(2025-03):改两处 改动一:三层拼起来,直接猜字 浅层向量 中层向量 深层向量 拼起来 3 倍宽 FC 压回 1 倍 不再猜向量,decoder 出来直接借 LM head 出字 改动二:第 2 个字起,拿草稿自己的输出顶替 第 1 步 大模型给的 how 大模型给的 can + 字 I do 第 2 步 大模型给的 how 大模型给的 can 草稿自己的 I + 字 do it I 大模型还没验,拿不到它的向量,只能用草稿上一步的输出顶上。 所以训练时就让草稿把自己的输出喂回来练:training-time test。 MTP(DeepSeek-V3 起):骨架几乎一样,差在谁训 DeepSeek-V3 的 MTP 模块 主干向量 + 下一个字的嵌入 归一化、投影 transformer block 输出头 与主模型共用 什么时候训 大模型动不动 EAGLE 模型发布以后,谁都能外挂上去训 冻住 MTP 厂家预训练时一起训,随模型发布 一起训 带 MTP 的还有 Qwen3-Next、GLM-4.5、小米 MiMo;Step 3.5 Flash 挂 3 个模块(MTP-3) 一层 MTP 连猜:输出喂回自己再跑一趟 MiMo-7B,第 1/2/3 个草稿字的接受率 70% 81% 第 1 个 10% 56% 第 2 个 2% 36% 第 3 个 原样连猜(只练过往前一步) 按连猜微调后(FastMTP) 长相差不多,差在谁训、练没练过连猜 EAGLE 不是免训练,只是训得少;MTP 能多猜几步,但草稿得按连猜练过,改个参数不够。
先看颜色:橙色要训,蓝色借大模型。三块的橙色都只有中间一小段。
结构按论文正文;how/can/I/do/it 是 EAGLE-3 论文的例子。
出处与口径

EAGLE:arXiv 2401.15077 v3 §3(Figure 6 说明:嵌入层、LM head 用目标模型参数不训;FC+一层 decoder;特征与提前一位的 token 嵌入拼 2 倍宽)、§4 Training(70B 可训 0.99B,A100 40G 服务器 1–2 天)。EAGLE-3:arXiv 2503.01840 v3 §3.1–3.2(低/中/高特征拼 3k 经 FC 压回 k;第 2 步起用草稿输出 a 顶替;training-time test);how/can/I/do/it 是论文 Figure 5 的例子。

MTP:DeepSeek-V3 技术报告 MTP 一节;各家采用见 sebastianraschka.com 架构图鉴 MTP 页、FastMTP 引言。接受率:FastMTP arXiv 2509.18362(MiMo-7B 单层 MTP,冻结主模型、自蒸馏数据微调 MTP 头;原样第 2 位约 10%,第 3 位约 2%)。

MTP、DFlash、DSpark 是一条线上的三步。三者都是贴着大模型隐状态猜字的小草稿,差在怎么出字。MTP 和 EAGLE 一个字一个字猜,猜 5 个跑 5 趟;DFlash 一趟出整块,猜 5 个和猜 1 个差不多贵。

三种草稿:怎么出字,验几个 一格一个草稿字。三种都贴着大模型的隐状态猜;差在出字方式和每步验多少 草稿跑一趟 能被收下 被拒 跟着作废 MTP、EAGLE:一个字一个字猜 草稿 跑 5 趟 跑一趟 of 跑一趟 course 跑一趟 , 跑一趟 I 跑一趟 can 每趟都看得见前面猜了啥, 所以越往后也不太掉; 代价:猜几个就跑几趟。 MTP 是训进主模型的那一层。 DFlash:一趟出一整块 草稿 跑 1 趟 跑一趟,5 个位置并行出(大模型隐状态注入草稿每一层) of problem is fine . ✗ 拼成了 of problem 各位各猜各的,看不到 同块前一位选了哪个字: 两种说法拼了串。 越往块尾,接受率掉得越快。 DSpark:DFlash 当骨干,补两刀 第一刀 顺序小头补依赖 第二刀 按把握和负载定验几个 同样跑一趟出整块 小头 小头 小头 小头 小头 of 活到这 95% course 活到这 86% , 活到这 60% I 活到这 24% can 活到这 5% 负载重:只验前 2 个 负载轻:验到第 4 个 前一位选了 of, 就把下一位的 course 抬起来。 绿柱:草稿活到这一位的概率, 越往后越矮。截在哪, 看这一刻机器忙不忙。 DSpark = DFlash 的出字速度 + 补回块内依赖 + 按把握验 从上往下:第二行换来速度,第三行把第一行的前后照应补回来,再把验几个交给调度。
从上往下三行:串行猜、一趟出整块、一趟出整块再补两刀。
例句和概率是示意。
出处与口径

⚠️ 示意:例句、各行猜 5 个、存活概率 95/86/60/24/5% 和两条截断位置都是举例;of course/no problem 的例子出自 DSpark 论文 §3。

DFlash:arXiv 2602.06036;KV 注入与 EAGLE-3 对比见 LMSYS 博客 2026-06-15。DSpark:arXiv 2607.05147(Markov 顺序头、置信度头、前缀存活概率、全批贪心调度;MTP-3/5 高并发拉低吞吐);vLLM dspark.py 从 mtp.{0,1,2}.* 读权重。

DFlash 还挪了喂隐状态的位置:EAGLE-3 只在草稿入口喂,草稿一深信号就淡;DFlash 注入草稿每一层的 KV(LMSYS 博客)。2026 年已上 vLLM、SGLang,B300 上单并发速度是不投机的 3.0–5.8 倍(Gemma-4 31B,NVIDIA 博客)。

一整块里是什么:一张填空卷。Qwen3 上一块 16 格(LLaMA 3.1 是 10 格):第一格是上一轮刚确认的字,后面 15 格都放同一个 mask 占位符。草稿只有 5 层(Qwen3 Coder 是 8 层),embedding 和输出头借大模型的、冻住不训;大模型从浅到深挑 5 层隐状态,拼起来投影成一份,塞进草稿每一层当额外的 KV。块内双向注意力,跑一次前向,15 个空同时填满。

训练照这个来:在真实回答里随机挑一个位置当第一格,盖住后面的格子让它填(DFlash 论文 §4、§5)。

一趟出整块的病:越往块尾越不准。每个位置各猜各的,看不到同块前一位到底选了哪个字。上文既能接「of course」又能接「no problem」时,它会拼出「of problem」。DSpark 论文里,EAGLE-3 的逐位接受率持平,DFlash 一路往下掉。

DSpark 论文实测:开头靠深度,往后靠前后照应 左:每一位单看准不准;右:一轮平均收下几个字 EAGLE-3(一个个猜) DFlash(一趟出整块) DSpark ① 逐位接受率:第 1 位 → 块里往后 Qwen3-4B 0.5 0.6 0.7 0.8 0.9 1.0 闲聊 EAGLE-3 0.53 0.74 闲聊 DFlash 0.72 0.63 代码 DFlash 0.87 0.78 数学 只看第 1 位 EAGLE-3 0.81 DFlash 0.88 DSpark 0.93 箭头从第 1 位指向块里往后。一个个猜的越往后越稳, 一趟出整块的越往后越掉;第 1 位反而是浅草稿最弱。 ② 每轮平均收下几个字 Qwen3-8B,含大模型补的 1 个 0 1 2 3 4 5 6 4.66 4.77 5.65 数学 4.15 4.46 5.28 代码 2.58 2.97 3.50 闲聊 同一个草稿,闲聊比数学少收约两个字: 每次验几个,该看内容,也该看机器忙不忙。 开头靠草稿够深,往后靠前后照应;DSpark 两头都要 一趟出整块的草稿能叠得更深,第 1 位更准;DSpark 再用顺序小头把往后的下滑补回来。闲聊收得少,就是第二刀按把握定验几个的理由。
左边看箭头方向,右边看闲聊那组有多矮。
全部是 DSpark 论文实测;右图每类取三个基准的平均。
出处与口径

DSpark:arXiv 2607.05147。左:§4.3.1 正文给出的数(Figure 2 全曲线未逐点公开,图上只画正文写明的;右端是正文说的「块里更靠后」处,没写明是第几位)。右:表 1 Qwen3-8B,数学=GSM8K/MATH500/AIME25、代码=MBPP/HumanEval/LiveCodeBench、闲聊=MT-Bench/Alpaca/Arena-Hard,每类取三个基准的平均(本课计算)。

核对:九个基准的平均算出来 DSpark 比 EAGLE-3 高 26.7%、比 DFlash 高 18.4%,与论文正文一致。温度 1.0、块长 7、草稿 5 层(EAGLE-3 为 1 层)。

DSpark 第一刀补草稿。DFlash 照旧一趟出整块,上面加一个很轻的顺序小头,按前一位选的字调下一位的分数:选了「of」,就抬高「course」。Qwen3 4B–14B 上平均接受长度比 DFlash 高 16–18%,比 EAGLE-3 高 27–31%;batch 128 时,草稿长度从 4 个到 16 个,整轮都只比 DFlash 慢 0.2–1.3%。

看第 2 格的分数条:同一个骨干,加了小头之后跟着第 1 格变。 (24 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。分数是示意;0.2–1.3% 与 16–18% 是论文实测。)

第二刀补验证,这才是它线上好用的主因。另一个小头估每一位被收下的概率,连乘成前缀存活概率。调度器把整批请求的候选前缀按存活概率排队,再查引擎吞吐表,定这一步总共验多少。负载轻多验,负载重少验,没把握的字不占名额。

看同一批草稿,闲时放进 14 个、忙时只放 7 个。 (26 秒,Manim 渲染;默认连续播放;取消勾选「连续播放」、点「⟲ 重来」,再点「开始」一步一步看。把握和吞吐表是示意,排队和停止规则照论文 Algorithm 1。)

线上又改了两处(论文 §5.2):真实吞吐表是锯齿形的,一碰到下降就停会卡在小坑里,所以去掉「降了就停」,在整张表上找最高点;总数改用两步之前的把握来定,这样下一步验多少在这一步算完前就能定下来,引擎不用停下来等。这么做仍然不改输出分布:名额多少不再取决于这一轮刚猜出的字。

这正好解了 11.2 的坑:固定猜 3 个、5 个的 MTP 在高并发下验证太贵、拉低总吞吐,所以 DeepSeek 线上一直只开 MTP-1(每次验 2 个字)。换成最多猜 5 个的 DSpark,V4-Flash 并发不到 200(V4-Pro 不到 150)时,每请求验到约 4–6 个;V4 预览版上线两周后,它替下了 MTP-1。

它在 V4 上占的正是 MTP 的位子:vLLM 按 mtp.0–2 的名字从主模型 checkpoint 读它的权重。所以说 DSpark 是 DeepSeek 线上 MTP 的接班人,出字方法却走 DFlash 那一路。

11.4 接进系统的代价

回到主线 投机解码让搬一趟权重换来好几个字。batch 小时赚得最多;batch 一大算力吃满,收益就缩,甚至倒亏(11.2)。 留下的问题:batch 大时投机帮不上,那还能省什么(第十二节)?
第 十二 节

少搬字节:量化与 kernel 融合

大 batch 下投机不灵了,剩下的办法是让每趟少搬、少停。 量化让权重和 KV 占更少字节,kernel 融合去掉交接时的空等。

12.1 位数减半,下限减半

小 batch 时一步几乎全在读权重,字节少一半,下限就少一半。这条路走了三步。2022 年底的 GPTQ 只压权重、算时还原:3 bit 的 OPT-175B 在 1 张 A100 上逐字速度是 5 张卡跑 FP16 的 3.25 倍。同年 Hopper 的张量核(GPU 里做矩阵乘的单元)直接算 FP8,DeepSeek-V3 连训练都用 FP8;到 Blackwell,4 bit 浮点(NVFP4)也进了张量核。

落到本课的例子上:8 颗 TPU v7 分着读 V3 的激活参数,FP8 的下限正是 1.1 节单芯片 5 毫秒的八分之一(本课推导,只算权重)。

位数减半,一步的搬运下限就减半 —— FP4 只要 BF16 的四分之一多一点 DeepSeek-V3 · 8 颗 TPU v7 · batch 1 · 只算权重(本课推导) BF16 FP8 MXFP4 NVFP4 每 token 要读的权重(37B 激活参数) BF16 16 bit 74.00 GB → 至少 1.26 ms FP8 8 bit 37.00 GB → 至少 0.63 ms MXFP4 4.25 bit 19.66 GB → 至少 0.33 ms NVFP4 4.5 bit 20.81 GB → 至少 0.35 ms 整个模型放得下吗(671B,按 HBM 裸容量) BF16 1,342 GB FP8 671 GB MXFP4 356 GB NVFP4 377 GB 8 颗合计 1,649 GB
看下限随位数怎么缩。
本课推导:V3 激活参数、8 颗 v7、batch 1、带宽跑满,不含 KV 与通信。
出处与口径

V3:技术报告 arXiv 2412.19437 摘要,总参数 671B、每 token 激活 37B。TPU v7:Google Cloud 公开规格,每芯片 HBM 192 GiB、带宽 7.37 TB/s。右图统一用十进制 GB:8 × 192 GiB = 1,536 GiB ≈ 1,649 GB(本课推导)。

MXFP4:OCP Microscaling Formats (MX) Specification v1.0。NVFP4:NVIDIA 技术博客「Introducing NVFP4 for Efficient and Accurate Low-Precision Inference」。

⚠️ 本课推导:下限 = 激活参数 × 每参数位数 ÷ 8 ÷ (8 × 7.37 TB/s)。假设权重均匀摊开、带宽跑满;不含 KV、激活值和通信,实际一步更慢。

注:真实部署很少整模型都降到 FP4:DeepSeek-V4 只把专家放 FP4、其余多为 FP8(HF 模型卡)。

实测接近这个比例:vLLM 2024 年 7 月接入 FP8 权重,2 张 H100 上,稠密的 Llama 3 70B 每字间隔最多降到未量化(16 位)的 1/2,MoE 的 Mixtral 8x7B 最多降到 1/1.6。MoE 赚得少,原文没给原因;本课推测是只读选中的专家,读权重在一步里占比本就低。

再减一半到 4 bit:AWQ(2023)在 RTX 4090、batch 1 上跑 Llama-2-7B,比已经融合过 kernel 的 FP16 再快 3.1 倍。精度看 WikiText-2 困惑度(越低越好):FP16 是 5.47,AWQ 5.60,直接四舍五入取整是 5.73。

省下的显存多放 KV、多接请求(4.1),一趟搬运分给更多人。

同叫 4 bit,差在缩放。4 bit 只有 16 个编码,必须几个数共用一个缩放倍数;MXFP4 和 NVFP4 差在块大小和缩放格式。

同叫 4 bit —— 差在几个数共用一个缩放 每个小格是一个 4 bit 的数;橙色大格是这一块共用的缩放(8 bit) MXFP4 的元素 NVFP4 的元素 块缩放(8 bit) 一块的位布局 MXFP4 32 个一块 E8M0 4 + 8 ÷ 32 = 4.25 bit/数 E8M0 = 指数 8 位、尾数 0 位:只能表示 2 的幂(½、1、2、4…) NVFP4 16 个一块 E4M3 4 + 8 ÷ 16 = 4.50 bit/数 E4M3 = 指数 4 位、尾数 3 位:一个小号的浮点数
差在块大小和缩放格式。
出自 OCP MX v1.0 规范与 NVIDIA NVFP4 博客。
出处与口径

OCP Microscaling Formats (MX) Specification v1.0:块大小 32,共享缩放为 E8M0(8 bit,只有指数)。

NVIDIA「Introducing NVFP4」:每 16 个 FP4 (E2M1) 共享一个 FP8 E4M3 缩放,另有每张量 FP32 二级缩放。

⚠️ 本课推导:平均位数 = 4 + 缩放位数 ÷ 块大小,FP32 二级缩放摊到百万级元素上不计。

块越小越贴合局部数值,精度越好,字节越多。格式细节见专题九 §2。

差多少有一组同条件的数:NVIDIA 2025-09 用 8B 的 Mamba 与 Transformer 混合模型训 1T token,MXFP4 要多训 36% 的 token,loss 才追平 NVFP4(训练 loss 比 BF16 高的幅度:MXFP4 约 2.5%,NVFP4 约 1.5%)。

推理侧,NVIDIA 博客称 DeepSeek-R1-0528 从 FP8 训后量化到 NVFP4,主要语言任务掉点在 1% 以内。同一张卡上 FP4 比 FP8 快多少,没找到官方同条件的数。

低精度直接训出来。2025 年的 Kimi K2 Thinking 在后训练做量化感知训练(QAT,训练时就模拟低精度),MoE 部分原生 INT4 权重,官方称低延迟模式生成约快 2 倍、「无损」;但没写对照的是什么精度,基准也只报 INT4 下的分。

DeepSeek-V4 模型卡写明,MoE 专家用 FP4,其余大部分用 FP8。专家占参数的绝大部分,也是 decode 读得最多的部分,压它省得最多。

12.2 专家压到 4 bit,注意力不动

先按组件数参数。gpt-oss-120b 的模型卡分开列:MoE 专家 114.71B、注意力 0.96B、嵌入和输出层 1.16B。专家约占 98%,注意力不到 1%(本课推导:114.71 ÷ 116.83)。OpenAI 只把专家压成 MXFP4,120b 就装进了一张 80 GB 的卡。

注意力不压,头一条原因是省不了多少:不到 1% 的参数,压掉一半也只省半个百分点;第二条是它更怕误差,见下面「为什么压了不掉点」第四条。各家做法一致:Kimi K2 Thinking 的配置里,注意力、共享专家、稠密层 FFN 和输出层都在不量化名单上,INT4 只给路由专家;本仓库在 TPU 上跑 R1 和 GLM-5.1,也是专家 FP4、注意力 FP8。

压专家的第一份好处是放得下:R1 的 FP8 专家在 v7x-8 上越过 HBM 上限(10.2),换成 FP4 就装下了,剩下的留给 KV。

FP4 先是被容量逼的 —— FP8 放不下,FP4 才腾出余量 每个 device 的权重占用(README 原值,单位 GB);竖虚线 = 可用上限 94.75 GiB ≈ 101.7 GB 放不下 放得下 连同注意力 DeepSeek-R1 · TPU v7x-8 · 每 device FP8 专家 按 GiB 读约 109.3 101.8 FP4 专家 60.9 FP4 连同注意力 约 70 上限 94.75 GiB ≈ 101.7 GB 哪种单位读都超(最少 0.06 GB)
看虚线右边那截淡红:换成 GiB 读,越界更多。
README 原值,每 device;两种单位都超。
出处与口径

tpu/tpu-inference/DeepSeek-R1-671B-FP4/README.md:72-73、:875-878(v7x-8 = 4 颗芯片 = 8 个 device;数为每 device,README 写 GB);上限出自运行日志 hbm=(…, 94.75) GiB(Kimi-K2.6-1T-A32B-INT4/README.md:217)。换算 94.75 GiB ≈ 101.7 GB、101.8 GiB ≈ 109.3 GB 为本课推导。

第二份是少读。decode 每一步都要把选中的专家从 HBM 读一遍,batch 不大时读权重的时间就是一步的时间,4 bit 比 8 bit 少读一半。

第三份最反直觉:v7 公开规格只列 BF16 和 FP8 峰值,没有 FP4 算力,照样能快。tpu-inference 的 MoE kernel 把 4 bit 权重块原样搬进片上,在 kernel 里和激活做点积,每块乘完再乘缩放;本课推测编译器在片上先解成更宽的格式再送进矩阵单元。贵的是从 HBM 搬,片上解一下便宜。

GPU 上早算过同一笔账:Marlin(2024)让 4 bit 权重在寄存器里解回 FP16 再进张量核,batch 16 以内的矩阵乘接近 FP16 的 4 倍,接进 vLLM 端到端最多 2.8 倍。Blackwell 的张量核能直接算 FP4,那是另一条路。

精度:本仓库在 v7x-8 上用 FP4 专家跑出 R1 的 GSM8K 94.9%(1319 题)、GLM-5.1 的 89.46%(5-shot,未调优)。两者口径不同,不横比;也都没有同条件的 FP8 分可对照,只能说跑出来了,不能说没掉点。同机 FP8 对 FP4 的吞吐也没有:R1 用 FP8 根本放不下。

我们在 TPU v7 上怎么压的:最朴素的一种,图的是装进一台机器 R1、V3.2、GLM-5.1 三个模型同一套做法,都是从官方 FP8 权重出发:
  • 只压路由专家。注意力留 FP8,其余非专家部分不动。
  • 压法三步,不用校准数据。按原来 128×128 的块缩放把 FP8 解回 FP32;每个输出通道取绝对值最大,定一把尺子;四舍五入到 FP4(E2M1)。就是下面「挑尺子」里最朴素的那种,没用 GPTQ 这类挪误差的办法。
  • 离线转一次,存盘复用。纯 CPU 十二进程并行,R1 五十八层约 28 分钟。存盘借 FP8 当中转:FP4 的 16 个值全在 FP8 里,来回不丢;numpy 和 JAX 的 FP4 内存排法对不上,这样两边都能读。
  • 换来的头一件是放得下。R1 专家 FP8 每个 device 要 101.8 GB,超过 94.75 GB;FP4 只要 60.9 GB,四颗芯片一台机器就跑起来,两千并发约 7,300 tok/s(每芯片约 1,830)。GLM-5.1 专家每 device 27.5 GB,总占 61.6%,还剩 36 GB 给 KV。
Kimi K2.6 不在此列:它出厂就是 INT4(每 32 个一组、对称),我们没量化,只做了两件事:显存里一直存打包好的 INT4、用时在片上按位重解释;加载时补上那一步「减 8」。它一万亿参数,单台 v7x-8 前向要 105 GB 放不下,上了两台(v7x-16)。

为什么压了不掉点:四条道理。扔掉四分之三的位数,模型为什么还认得路?下面四条各有出处,合起来也说明了哪里能压、哪里要护着。

一、训练停在谷底,谷底大多是平的。训到收敛,损失对权重的一阶导数接近零,权重挪一点 Δw,损失主要按二阶项 ½ΔwᵀHΔw 涨(AdaRound,2020,原文「close to 0」)。H 是损失的曲率。Sagun 等(2017)量过它的特征值:绝大多数挤在零附近,只有少数几个大。所以大多数方向挪了不疼,疼的只是少数陡方向。GPTQ(2022)用的就是这份近似二阶信息:量化一列,就调整还没量化的列,把舍入误差往平的方向上推。

二、误差是噪声,不是偏差,前提是没有离群值。四舍五入有进有舍,一层几千个数累加,误差大半互相抵消。QuIP(2023)把它写成条件:权重和曲率矩阵越「不相干」(没有哪个方向特别突出),越好量化;它先乘随机正交矩阵把数打匀,第一次让 2 bit 可用。反面是离群值:LLM.int8()(2022)发现模型变大后,少数特征维度的激活大到撑爆整组缩放,只能单独留高精度;Super Weight(2024)发现剪掉一个参数,困惑度能涨三个数量级。12.1 的小组缩放、细粒度缩放,干的都是把离群值隔开。

三、最后只看谁排前面。出一个字是取概率最高的,或在前几名里抽。小噪声让每个词的 logit 都晃一点,只有前两名本来就挨得近时才会换人,所以困惑度涨得少:12.1 里 AWQ 的 16 位 5.47、4 bit 5.60。MoQE(2023)还实测:MoE 的专家层比稠密模型的 FFN 层扛量化得多,2 bit 专家照样可用(原文没给机理)。但平均分会藏东西:Dutta 等(2024)发现准确率几乎不变时,不少题的答案翻了,对变错、错变对正好抵掉;他们建议同时看 KL 散度和翻转率。

四、softmax 是放大器,所以注意力和路由要护着。softmax 前的打分差 δ,到概率上是 eδ 倍(本课推导:指数的性质)。专家输出直接加回残差,误差按线性传;注意力的 QKᵀ 打分、MoE 路由的打分都要过 softmax 或 top-k,误差被指数放大,还可能直接换掉选中的那几个 token 或专家。

旁证三条:

注意力不是不能压:SageAttention 先把 K 的离群值平滑掉,8 bit 端到端几乎无损,只是得专门处理。

四条都有边界。Quantization Hurts Reasoning(2025)在推理模型上测:W8A8、W4A16 基本无损,再往下风险明显,模型越小、题越难掉得越多。本课推测原因之一是长思维链要连着出几千个字,每一步的小翻转会累积。所以第三条那句「只看排名」,在长输出上要打折扣。

只压专家 —— 整步字节约减半,不是减到四分之一 gpt-oss-120b · batch 1 · 每生成一个字读多少权重(GB,本课推导,不含 KV 和激活) 专家(选中的 4 个 × 36 层) 注意力 BF16 输出层 BF16 三根条只换专家的格式 专家 BF16 7.2 1.9 1.2 合计 10.2 专家占 70% 专家 FP8 3.6 1.9 1.2 合计 6.7 专家占 54% 专家 MXFP4 1.9 1.9 1.2 合计 5.0 专家占 38% BF16 → MXFP4:整步约 2.06 倍,FP8 → MXFP4 约 1.34 倍 不动的那两段(蓝、灰)三根条一样长;上下文一长,还要再加一段 KV。
从上往下看橙段变短,蓝、灰两段一动不动。
按 config 推算,batch 1,只算权重。
出处与口径

gpt-oss-120b config.json(hidden 2880、intermediate 2880、128 专家选 4、36 层、64 头、8 个 KV 头、head_dim 64、词表 201,088);模型卡 Table 1(注意力 0.96B、激活 5.13B)作核对锚点;MXFP4 每参数 4.25 bit(模型卡)。

按 config 算的注意力 0.955B、激活 5.12B(另加路由约 0.01B)对上模型卡;字节、占比、倍数为本课推导,未计 KV、激活和缩放外的开销。

压完以后,专家那段缩了,注意力和 KV 原样不动,就成了一步里读得最多的部分。所以专家压到四分之一,整步也快不到 4 倍;12.1 里 K2 Thinking 只称约快 2 倍,本课推测原因之一在这里(它没写对照的是什么精度)。KV 怎么压见 12.4。

INT4 不是另一种 FP4。R1 的 FP4(E2M1)是浮点,值在 0 附近密、远处疏,靠块缩放对齐量级;Kimi K2.6 的 INT4 是 −8 到 7 等距排开的整数。

INT4:存的时候加了 8,读的时候要减回来 —— 直接当有符号数读,每个权重都错 INT4 和 FP4 一样每个数 4 bit、16 个值;INT4 是 −8 到 7 的等距整数,FP4 是浮点(0、0.5、1、1.5、2、3、4、6 及其负值) 模型里的权重 文件里存的 读对了 读错了 跟着一个权重走一遍:−3 → 存成 5 → 读回来 模型里的权重 −8 到 7 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 存进文件:+8 文件里存的 0 到 15 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 加载时 −8 读对了 和第一行一样 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 当有符号读 差 ±8,符号位反了 0 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 -1 不减 8,按有符号解 结果:读对了模型正常;读错了,输出崩成重复的「foss foss foss」
跟着一个权重走:存时加 8,读时不减,就差 8。
示意。
出处与口径

INT4:tpu/tpu-inference/Kimi-K2.6-1T-A32B-INT4/README.md:265-266。对称 int4 [−8, 7] 以无符号 [0, 15] 存放,解包后须减 8;原文:直接 bitcast 成有符号 int4 会让符号位错位,模型崩溃,输出重复的「foss foss foss」。最下一行由脚本逐个算出(本课推导):4 bit 补码里加 8 正好翻转最高位,所以每个权重都差 8、符号位反了。

⚠️ 示意:跟着走的「−3」是随手挑的一个值。FP4 (E2M1) 的取值按 OCP MX v1.0 由脚本算出:1 位符号、2 位指数、1 位尾数。

正文里 R1 的容量数:tpu/tpu-inference/DeepSeek-R1-671B-FP4/README.md:72-73、:875-878(v7x-8 = 4 颗芯片 = 8 个 device;FP8 专家约 101.8、FP4 专家约 60.9、连同注意力约 70,均为每 device);上限 94.75 出自运行日志 hbm=(…, 94.75) GiB(Kimi-K2.6-1T-A32B-INT4/README.md:217)。94.75 GiB ≈ 101.7 GB,101.8 无论按哪个单位都不剩余量。

K2.6 的记录里,加载时漏了图里「减 8」一步,模型输出崩成重复的乱词。

12.3 CUDA Graph 与 kernel 融合:边界上不再干等

CUDA Graph:录一次,整串重放。batch 小时,GPU 算一个 kernel 很快,CPU 一个个发反倒跟不上:GPU 算完一个,就等下一个发过来。CUDA Graph 把一步要发的整串 kernel 录下来,以后每步只发一次「重放」。

CUDA Graph:录一次,以后整串重放 Fireworks 实测:A100 · LLaMA-2-7B · batch 1,每个 token 的时间线,总长按比例 CPU 发射 kernel GPU 计算 GPU 空等 逐个发:每秒 30 个 token CPU GPU 33 ms 录成 CUDA Graph:每秒 69 个 token,2.3 倍 CPU GPU 只发一次:重放整张图 14.5 ms 代价:形状写死 录的时候批多大、张量在哪个地址都定了;批大小变了,就得换一张录好的图。
比两行 GPU:上面一格一格隔着粉色空等,下面挤成一条。
总长按比例;kernel 个数是示意。
出处与口径

Fireworks「Speed, Python: Pick Two. How CUDA Graphs Enable Fast Python Code for Deep Learning」(2023-08-29):A100-SXM4-80GB、LLaMA-2-7B、batch_size=1,不开 30 tok/s、开 69 tok/s,2.3 倍,原文说提速全部来自 CPU 开销。

每 token 毫秒数 = 1000 ÷ tok/s,本课换算;GPU 实际计算时长按开图后的 14.5 ms 近似,本课推导。kernel 个数(24)、发射与计算的长短比是示意。

kernel 融合:边界上不再干等。一次前向(模型从头算到尾一遍)要发上百个 kernel。每个 kernel 收尾、下一个开场时,没人在读权重。

kernel 之间的空当 —— 每个交接处都在等,加起来很可观 Hazy Research 的算例:H100 · Llama-3.2-1B · 单条序列,一次前向的时间线,按比例 读权重 kernel 交接时空等 megakernel:边算边预取 一次前向的时间线(微秒,按比例) 一层一层发 kernel 约 770 次/秒 读 740 + 空等 560 = 1,300 微秒 放大其中一层 每层 7 个 kernel k1 k2 k3 k4 k5 k6 k7 交接空等约 5 微秒 交接时谁也不在读权重 整次前向一个 kernel 上限约 1,350 次/秒 只剩读权重 740 微秒
每次 kernel 交接都要空等,加起来四成多;megakernel 把它捡回来。
时间轴按比例画。
出处与口径

Hazy Research「Look Ma, No Bubbles! Designing a Low-Latency Megakernel for Llama-1B」(hazyresearch.stanford.edu/blog/2025-05-27-no-bubbles,2025-05-27):算例 3.35 TB/s ÷ 2.48 GB ≈ 1,350 次/秒;每层 7 个 kernel × 16 层 × 约 5 µs ≈ 770 次/秒;实测基线都开了 CUDA Graph 和 torch.compile。实测:vLLM、SGLang 最多用到 H100 带宽的 50%,megakernel 到 78%;H100 上速度约是 vLLM 的 2.5 倍、SGLang 的 1.5 倍以上(B200 上对 vLLM 超 3.5 倍);B200 上一次前向不到 680 µs。

⚠️ 示意:第一行把每层 7 个空当合成一段画,第二行才按真实位置分开;7 个 kernel 等长是简化。

正文里 TPU 那组数的出处 —— Inferact「700 TPS on Kimi K3」(https://inferact.ai/blog/tpu-megakernels,2026-09-23):16 颗 TPU v7(32 个 TensorCore)、Pallas 编写、每 TensorCore 64 MiB VMEM;一步约 8.5 ms、每步接受约 6 个;GB200 对照为 16 张卡的 vLLM 配方,452 tok/s。⚠️ 本课推导:每步接受 6 个 ÷ 8.5 ms ≈ 706 tok/s,与博客的「700 多」对得上。

CUDA Graph 省的是 CPU 那头;GPU 这头,生产里先上的是 PDL,让下一个 kernel 提前准备。 megakernel 把整次前向写成一个 kernel,下一段权重在上一段计算时就开始读。

Hazy Research(2025-05)实测,vLLM、SGLang 最多用到 H100 带宽的 50%,megakernel 到 78%。模型和 batch 越小,空等占比越大,赚得越多。同一篇在 Llama-3.2-1B、batch 1 上,比 vLLM 快近 2.5 倍,比 SGLang 快 1.5 倍以上。

模型一大,融合单拎出来就赚得少:AWQ 那组测试里,光把 FP16 kernel 融合,Llama-2-7B 只从每秒 52 到 62 token。

TPU 这边,Inferact 2026-09 用 Pallas(JAX 里手写 TPU kernel 的语言)写了 megakernel。16 颗 TPU v7 跑 Kimi K3,单用户超过每秒 700 token;16 张 GB200(vLLM)是 452 token。两个数都开了投机,按接受长度 6 换算(Inferact 博客)。

12.4 KV 也能量化

KV 存 FP8,每个数从 2 字节变 1 字节;vLLM 和 SGLang 都是一个 --kv-cache-dtype 参数。 K3 官方高吞吐配方列为必开:BF16 的 KV 装不下每副本 128 个请求。

缩放给多细看 checkpoint:vLLM 只设 fp8 不校准时,缩放全取 1.0;用 llm-compressor 拿数据校准,可以每个 K、V 张量一个,或每个 KV 头一个(后者目前只有 FlashAttention 后端支持)。开了 FP8 KV 掉精度,先查有没有校准过的缩放。

实际布局不是严格一半。V3.2 每层还多存一条索引键(indexer key,4.1 那个小打分器挑 token 时读的),它本来就存 FP8,换了也不变小,所以同显存多接的请求比只算 MLA 时少。

KV 存 FP8 不是严格减半 —— 位置编码那截没压 DeepSeek-V3.2 一个 token、一层的 KV;条长按字节数画 512 维压缩 KV 缩放(FP32) 64 维位置编码(留在 BF16) indexer key(两边都存 FP8) 每 token 每层存多少字节 BF16 512 × 2 B 64 × 2 B 128 + 4 B MLA 小计 1,152 B 1,284 B FP8 512 × 1 B 4 个 FP32 缩放 64 × 2 B 128 + 4 B MLA 小计 656 B 788 B 同显存能装的请求约是 BF16 的 1.63 倍(本课推) MLA 那截严格减半该到这里
看下面那条的 MLA 部分比红虚线多出的那截:没压的位置编码,加上缩放。
FlashMLA 给 DeepSeek-V3.2 的布局,加上 indexer key,条长按字节比例;倍数为本课推导。
出处与口径

布局:github.com/deepseek-ai/FlashMLA README,2026-09-30 提交 2e5429f 之前的版本「FP8 with scale」一节:每 token 每层 512 个 FP8 + 4 个 FP32 缩放 + 64 维 BF16 RoPE = 656 B(现版只剩 V4.1 的格式)。

indexer key:HF config index_head_dim=128;DeepSeek-V3.2-Exp inference/model.py 存 FP8 + 每 128 维一个 FP32 缩放,vLLM、SGLang 的 indexer 缓存固定 uint8,不随 --kv-cache-dtype 变。

本课推导:BF16 = (512 + 64) × 2 + 132 = 1,284 B,FP8 = 656 + 132 = 788 B;1,284 ÷ 788 ≈ 1.63。没算权重和激活占的显存。

4 bit 已经落地:NVIDIA 2025-12 在 Blackwell 上放出 NVFP4 KV,比 FP8 KV 再省约一半,基准上精度损失不到 1%(NVIDIA 博客)。算注意力前仍解回 FP8,省的是容量和读的字节。同样显存多存了前缀,Qwen3-Coder-480B 上命中率比 FP8 KV 高 20%,首字延迟最多降到其约三分之一。

2026-09 的 DeepSeek-V4.1-Flash 主 KV 原生存 FP4(每 16 个数一个缩放),FlashMLA 同时放出读它的 kernel,比原先的 FP8 KV 小 45%。不过 FlashMLA README 写这个 FP4 格式只能用于 extra_k_cache,k_cache 那份仍是 FP8,不是整份 KV 都换成了 FP4。

回到主线 量化是少搬,融合是去掉空等,两者都能和投机解码叠用:Inferact 那个数来自 megakernel 加 DSpark 投机,博客没提量化。 留下的问题:这些招都默认 KV 能按 token 截、按块搬;线性层只有一份状态时,前缀复用、切序列、拆机器都要重想(第十三节)。
第 十三 节

新架构出难题:状态没法按 token 切

前十二节都默认一件事:每个 token 留一份一样大的 KV,想截在哪就截在哪,想按块复用、按块搬都行。 混合模型(4.1)里的线性层不是这样:一条序列只有一份状态,整段压进去,截不开。

13.1 前提塌了:三种层,前缀缓存只能存快照

「能从哪儿接着算」的三分法取自 LMSYS 2026-08 的统一前缀树博客。
层存什么新请求能从哪儿接着算
全注意力每个 token 一份 KV共享前缀的任意位置
滑窗只留最近一个窗口的 KV要有完整的最后一个窗口
线性(GDN、Mamba、KDA)每条序列一份固定大小的状态,原地更新只能是正好存过状态的位置

线性层的状态每进一个 token 就改写一次,回不到更短的前缀。PyTorch 博客(2025-12)把难处归成三条:退不回去;一份比单个 token 的 KV 大几个数量级;要么整份能用,要么不能用。

前缀缓存只能改存快照。截不开,就在一些位置把整份状态拷一份存下来,叫快照。新请求沿前缀匹配,退到不超过共享前缀的最近一份快照,从那儿接着算,中间那段重算。

线性层只能退到存档点 —— 一份顶六千多个 token 的 KV,只留要紧的几份 Qwen3.5-397B · 全模型未切分 · 字节按 config 推算(本课推导) 全注意力 KV 线性层快照 要重算 新请求和老前缀共用前 600 个 token 全注意力 每 token 一份 线性层 只在存档点有 256 512 768 共享前缀到 600 退到 512:整个模型从这儿接着算,512–600 这 88 个 token 重算 → token 一份快照有多大 256 token 的 KV 7.5 MiB 一份快照 ≈183 MiB(24 倍) int8 存 ≈48 MiB 128K 前缀:快照留几份 留法 份数 快照显存 占前缀 KV 只留 prompt 末尾 1 0.18 GiB 5% 再每 32K 留一份 4 0.72 GiB 19% 每 256 个都留 512 92 GiB 24 倍,不这么做 同一段前缀的 KV 约 3.75 GiB 生产只留要紧的几份:prompt 末尾必留,长前缀隔一大段一份,共享前缀第二次撞见才存 放不下按 LRU 删快照、KV 留着;还能落到 CPU 内存和外部存储,或存成 int8。
线性层只能退到存档点;一份存档约 183 MiB,顶 6,250 个 token 的 KV;128K 前缀只留末尾一份,才占 KV 的 5%。
Qwen3.5-397B,按 config 推算(本课推导)。右下比的是 128K 前缀存几份快照;末尾必留、每 32K 一份取自 vLLM 的留存策略。
出处与口径

Qwen3.5-397B-A17B config.json;状态形状按 vLLM mamba_utils.py;留存策略取自 vLLM K3 博客(2026-07-27);int8 只压递归状态(SGLang mamba_checkpoint_pool.py)。

所有 MiB、GiB、份数、百分比为本课推导,未用实测显存核对。

命中后先把快照拷到这个请求自己的槽里再往下改:状态是原地更新的,直接在共享的那份上算,别人的就坏了。

全注意力层的 KV 还是按块存,快照只是线性层多出来的一份。两类东西的复用边界不同,SGLang 2026 年把它们挂进同一棵前缀树,各按自己的边界判命中。

13.2 生产里怎么存:两个池,只留要紧的几份

一份快照顶几千个 token。Qwen3.5-397B 一份约 183 MiB,约等于 6,250 个 token 的 KV(本课推导,按 config:15 层全注意力,每 token 的 KV 是 30 KiB;45 层 GDN,每层状态 4 MiB、fp32,加卷积状态 72 KiB;4.1 表里的 180 MiB 只算了前一项)。

K3 更大:一份快照约 430 MiB,约顶 1.6 万个 token 的 KV(本课推导,按公开 config、状态按 fp32 计:69 层 KDA,每层 96 头 × 128 × 128(config 里 KDA 的 linear_attn_config.num_heads 和 MLA 的 num_attention_heads 是两个独立字段,都填 96);24 层 MLA 每 token 只存 576 维,约 27 KiB)。

所以生产不每段都存,只留要紧的几份。vLLM 的 K3 博客明说:每个位置都存「贵得没法用」。它留三种:

SGLang 是另一种管法:decode 每 256 个 token 记一份(--mamba-track-interval),一条路径留几份默认不封顶;真正的上限是池子大小,满了按 LRU 删快照,KV 留着。新请求的 KV 命中比快照远,就在分叉处补记一份,下回直接命中。

摊到一个请求上就不吓人了:只留末尾一份,是 KV 的约 5%;每 32K 再留一份,约 19%。吓人的是每 256 个都留,是 KV 的二十几倍(本课推导,128K 前缀、Qwen3.5:KV 约 3.75 GiB,末尾一份 183 MiB,四份约 0.72 GiB,512 份约 92 GiB)。

两种东西,两种管法。KV 按 token 长、按块存;快照按请求、按份存。

滑窗还有一条路:不存,缺了只重算尾巴。DeepSeek 2026-10 开源推理框架 DeepInfer,同时公开了 V4.1-Flash 的线上做法。

跟快照对照:线性层的状态吃下了整段历史,只能存;滑窗只看最近一个窗口,重算有上限,所以可以不存。

同一个前提,前面已经撞了四次。

GPU 引擎这两年为此补了成套机制。TPU 上要把一个混合模型真正跑起来,还得一关一关过(第十四节)。

第 十四 节

落地:TPU 服务化与编排

前面十三节的招数,这一节落到一个模型、一种芯片上。主线是 Qwen3.5-397B(FP8)在一台 v7x-8 上:4 颗芯片、8 个 TensorCore;60 层里 45 层线性注意力(GDN)、15 层全注意力,每层 512 个专家选 10 个。栈是 vLLM-TorchTPU:TorchTPU 让 PyTorch 原生跑在 TPU 上,vLLM-TorchTPU 是 vLLM 在它上面的后端,连同 SGLang-TorchTPU 在 2026-10-20 一起公布。下面每一刀都注上公开 PR 号;梯子上的倍数仍以起点那天 = 1,PR 正文里的绝对数各有各的测法,单独标出。三个问题:TPU 跟 GPU 哪里不一样,这个模型哪几处要特殊处理,怎么跑快。

搬到 TPU,四条规矩变了 —— 每条都落到这个模型的一处做法上 Qwen3.5-397B(FP8),一台 v7x-8:4 颗芯片、8 个 TensorCore;右栏做法见 14.2 GPU 上 TPU 的规矩 这个模型要做的 同一个模型,换了一套硬件 GPU 上 TPU 的规矩 Qwen3.5 要做的 形状 逐个发 kernel;录图(CUDA Graph) 只是加速,档外的批照样跑 XLA 按静态形状整图编译; 没编过的档,首个请求等 60–90 s 开服前把档位编好; 长短不齐交给 RPA 一个 kernel 通信 DeepEP 点对点收发; 8 卡机内 NVLink、机间 IB 全互连 ICI 3D 环面,每颗只连 6 个邻居; XLA 未必把通信藏到你想藏的地方 注意力按请求切、MoE 按专家切; 整层 MoE 写成一个 Pallas 程序 片上与布局 现成 kernel 多:FlashAttention、 DeepEP、Marlin 每核 64 MiB VMEM、1 MiB SMEM; 显存按 tile 存,窄维补成整块 KV 序列维放最内层;GDN 状态 换视图不搬;路由表分窗流入 数据格式 Blackwell 张量核直接算 FP4 v7 公开规格只列 BF16、FP8 权重和 KV 存 FP8;线性层状态 存 BF16、算时提回 FP32
看右列:每条变了的规矩,都对应这个模型的一种写法。
GPU 一列以 Blackwell 和开源栈为参照;v7 一列依据公开规格与博客,各条出处见正文。
出处与口径

GPU 栏:本专题 5.1、6.4、12.1、12.3;TPU 栏:tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md(60–90 s)、Google Cloud 博客「Inside the Ironwood TPU codesigned AI stack」、本专题 5.1、6.4、12.1。

右栏:vLLM-TorchTPU(vllm-project/vllm-torchtpu,2026-10-20 开源),做法与 PR 号详见 14.2。

14.1 TPU 跟 GPU 哪里不一样

形状:GPU 录图只是加速,TPU 不编就不能跑。GPU 上 kernel 逐个发,CUDA Graph 录下来省发射开销,档外的批照样跑(12.3)。XLA 按静态形状整图编译(专题二「谁做决定」),一批的 token 总数补到预编译的几档;没编过的档,第一个撞上的请求要等 60–90 s,之后同形状不到 1 s。

为什么非编不可。打个比方:GPU 像现场点菜,来一单炒一单;XLA 像中央厨房,开工前把整桌菜的工序、锅位、碗碟一次排死。

分桶就是成衣尺码。不给每个总数量体裁衣,只备几个码:这一步整批拼起来 700 个 token,就补零补到 1,024 那一档去算,补的零白算。码备得越多,补得越少,可每个码都要编一次。

桶越细补零越少,编译越多 —— 按分布的形状切,不按等距切 本课推导示意:一步里整批的 token 总数按对数正态生成(中位 700,长尾到 8K),不是真实流量。桶 = 衣服尺码,总数补零到所在桶的上沿 2 的幂 √2 倍一档 等距 太粗 补出来的零 每步 token 总数的分布和 2 的幂桶边界 128 256 512 1K 2K 4K 8K 中位 700 一个桶 = 一个尺码:总数落在 512–1K 的都穿 1K 560 700 900 1,024 六种分法:桶数(= 编译次数)对补零浪费 只有 8K 一个桶 1 个桶 87.3% 4 个桶(1K 起翻倍) 4 个桶 39.1% 2 的幂(128 起) 7 个桶 29.9% √2 倍一档 13 个桶 16.0% 每 512 一档 16 个桶 19.7% 每 256 一档 32 个桶 10.8%
比绿条和第一根橙条:桶更少,浪费也更少。
本课推导示意:每步整批 token 总数取对数正态,非真实流量;浪费 = 补零 token ÷ 实算 token。
出处与口径

⚠️ 本课推导示意:2,000 步的整批 token 总数取对数正态分位点(中位 700、σ = 0.9、截到 8,192),确定性生成;√2 档取 128 × 2^(k/2) 并取整到 16 的倍数。左下角 560/700/900 三批是随手挑的例子。补齐按整批总数(RPA ragged 布局),不是每条请求各补一次。

📌 新形状首个请求编译 60–90 s、之后 <1 s:tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:794。

📌 预编译参数 --precompile-bs-paddings 1 4 8 16 32 64 128 256、--precompile-token-paddings 4096:tpu/sglang-jax/mimo/README.md:269-270。

这张图是本课推导的示意分布:只备一个 8K 码,算的 token 里 87.3% 是零;备 32 个码,降到 10.8%。按分布的形状切,13 个 √2 递增的码(16.0%)比 16 个等距的码(19.7%)还省。

长短不一的请求,不进形状。补齐只按整批总数,单条请求不补。每条多长、页在哪,是 RPA kernel 运行时读的数据(5.1):按页表取页、只搬有效长度。所以一个 kernel 吃下各种长度,不用为每种长度各编一份。

所以档位写进启动参数、开服前编好,SGLang-JAX 的写法是 --precompile-bs-paddings 加 --precompile-token-paddings。按 tpu-inference 公开 README 的配置,冷启动约 7 分钟:加载权重、MoE 重新量化、初始化 KV 池。

跨 rank 回放:一份菜谱印八份。档位一多,编译就成了开服的大头。编出来的程序只取决于图本身:形状、算子、常量,跟哪个 rank 来跑无关。八个 rank 各编一遍同一张图,是八个厨师各自试做同一道菜。

所以凡是随 rank 变的值,rank 号、每卡自己的常量,都不进图,改成运行时输入或在组内用一次通信取到;图只剩一张,回放才成立。

通信:没有全互连,XLA 也未必替你藏。GPU 机内 8 卡 NVLink 全互连、机间走 IB,MoE 收发有 DeepEP 点对点(6.4)。v7 芯片间是 ICI 直连的 3D 环面,一颗只跟 6 个邻居直连,擅长 all-gather、reduce-scatter 这类规整的集合通信。

6 个邻居是什么样。NVLink 交换机像每人桌上一部直拨电话,谁找谁都一跳。3D 环面像一个立体方阵,每人只能跟前后、左右、上下 6 个人递东西,每条边首尾相接成环;离得远的要中间的人转手(本课推导)。

为什么规整通信合它的脾气。环形 all-gather 每一步,人人同时把手上一块递给下一个邻居,所有连线同时忙、每步的量一样大,几步做完是算得出来的(通用环形算法,示意)。reduce-scatter 是同一条路反着走,边走边加。

点对点 all-to-all 难在不可预测。MoE 每步各 token 选的专家不同,谁给谁发多少每步都变;远的要转手,几路争同一条线时有的排队、有的空着。Qwen3.5 的公开博客写得直白:all-to-all 方案在负载多变时有「massive, unpredictable network routing overhead」,所以选了 all-gather 加 reduce-scatter,图的是延迟可预测。

「XLA 未必替你藏」长什么样。想要的是厨房里切菜和炒菜同时开工;XLA 是排班的大厨,它把一串算子当一整块排,有权调顺序、回收缓冲区(Inferact 博客的说法),未必排出你要的那种重叠。

片上:VMEM 和 SMEM 由 kernel 自己管。每个 TensorCore 有 64 MiB VMEM 放正在算的块,1 MiB SMEM 放标量和索引;Pallas kernel 决定什么时候把什么搬进来。

工作台、仓库、便签本。HBM 是仓库,192 GiB;VMEM 是工作台,一颗芯片两个 TensorCore 合计约为 HBM 的 1/1,500;SMEM 是便签本,记页号、专家号这类小数字,kernel 拿它算下一步去仓库哪一格取货。

PyTorch 栈怎么用上 Pallas。模型代码是 PyTorch;Pallas kernel 照旧用 JAX 写,经 jax.export 导出、包成一个 torch 算子,TorchTPU 再把导出的模块交给 XLA 编译(#543 正文)。所以下面几刀手写 kernel,在 PyTorch 栈里一样能用。

布局按 tile 存。显存里一块默认 tile 是 8 × 128 个 32 位格子,4,096 字节(5.1)。最内两维都要补齐,窄维落在那里就补出一片空位。一个 32 位格子能装 2 个 BF16 或 4 个 FP8,FP8 的次内层因此补到 32 行。

算一个补齐的例子(本课推导)。TP2 后每个 rank 1 个 KV 头,head_dim 256。RPA 把 K 和 V 沿头维并成一个打包维,每 token 每层这一维只有 2 个数,摆进 32 位格子:

数据格式:v7 公开规格只列 BF16 和 FP8。Blackwell 的张量核直接算 FP4;v7 的矩阵单元按公开规格吃 BF16 和 FP8。权重和 KV 存 FP8,更窄的格式要先在向量单元上解包、乘回缩放倍数,才能喂给矩阵单元。这笔活落在向量单元上,代价见 14.3 的 K3。

14.2 这个模型落到 TPU,哪几处要特殊处理

先认清全注意力层:GQA,不是 MLA。Qwen3.5 的全注意力层是标准 GQA:32 个查询头、2 个 KV 头、head_dim 256(公开博客)。16 个查询头共用一个 KV 头(本课推导:32 ÷ 2)。每 token 的 KV 只有 30,720 字节(本课推导:15 层 × 2 头 × 256 × K、V 两份 × 2 字节)。

复制 4 份的代价。GQA 本来就是为了让 KV 变小,复制 4 份等于把省下的又吐回去。公开博客的说法:按 TP8 跑,HBM 被重复的 KV 占掉,实际并发只到约 200,原计划是 512。

切法:注意力分请求,MoE 分专家。所以两段各切各的:注意力用 DP,MoE 用 EP 切成 8 份,中间 all-gather 收齐 token、算完 reduce-scatter 发回(6.2),正是 ICI 擅长的那类通信。prefill 用 DP8;decode 用 DP4×TP2,每个 rank 正好分到 1 个 KV 头。

切法跟着并发换。公开的参考配方(#989):并发 4–32 注意力用 TP8,64–1,024 用 DP8,MoE 全程 EP8。并发 32 换成 DP4×TP2,吞吐低 2.65%、TPOT 短 17.9%(#384),省的是每个字的延迟。

缓存:KV 和线性层状态共用一个池。KV 随上下文变长,GDN 状态每条序列一份、大小固定,约 183 MiB,顶约 6,250 个 token 的 KV(13.2)。两者的比例随请求长度大起大落(本课推导):

分两个池,总有一个闲着。像分开的小车位和大巴位:按 64K 流量把状态池定在一成,换成 1K 流量时,状态池先满,能接的请求数被它卡住,KV 池约九成八空着(本课推导:1K 请求的 KV 约 30 MiB,0.09 ÷ 183 × 30 ≈ 0.015,对 0.91)。反过来也一样。

统一池:车位可互换。两种东西共用可互换的页、按需领取,前缀缓存也走这个池。公开博客的说法是把两种状态对齐后放在一起存,少补齐、不碎片。vLLM-TorchTPU 里先在 PD 分离配置上启用(#106),再改成默认(#170)。13.2 讲过两种栈各自的写法:SGLang 两个池加比例旋钮和弹性池,vLLM 一个管理器、一种页。

GDN 状态:换视图,不搬数据。GDN kernel 按 tile 算,要的是按头排好的 128 × 128 状态方阵;池里的页按统一池的格式存,两者布局不一样。

切序列时,线性层按头切。开 PCP 把一条 prompt 摊到 8 个 device 上,全注意力层按 token 切没问题;线性层的状态要从头接力扫,按 token 切,后一段得等前一段扫完交棒(7.2),8 个 device 变成排队。

KV:序列维放最内层。上面那个补齐例子就是这一条:头维打包时,FP8 页跟 BF16 页一样大。KV 存 FP8 的本意是让每 token 的字节减半,序列维放到最内层后才兑现(5.1)。

MoE:整层一个 Pallas 程序。MoE 占 prefill 约八成时间,XLA 又不把 reduce-scatter 藏到矩阵乘后面。写成一个 Pallas 程序后,kernel 自己选专家、把每行推给持有它的 rank,通信藏到矩阵乘后面。

K3 对照①K3 的部署手册写明:69 层 KDA 的状态池,DP、EP、DCP 都不切它(DCP 只按 token 位置切 MLA 的 KV)。DEP8 下每个 rank 要存一整池 KDA 状态,装不下,所以 K3 用 TP:TP 把头分到各 rank,状态跟着头一起切小(6.1)。Qwen3.5 的统一池随 DP 切,DP=8 实测跑通。

14.3 怎么跑快

砍的理由跟前面几节一样:HBM 在空等,通信露在外面,布局把窄维补成整块。最大的几刀,都是手写 Pallas 把调度权拿回来。

prefill 四刀,全砍在 MoE。先在片上按目的地累加;再把通信切成小块,想让它跟计算叠起来(XLA 实际仍没叠上);接着整层融成一个程序;最后修剪 kernel 本身。

Qwen3.5-397B prefill 刀谱 —— 最大的一级是整层融合 私有实测指数化:单机 v7x-8、DP8 注意力 + EP8 专家,prefill 吞吐,起点那天 = 1.00。柱内大字是累计值,小字是这一刀相对上一级的倍数 起点 动通信和搬行 整层融合 同期实测 DP8 prefill 吞吐(指数) 0.0 0.5 1.0 1.5 1.00 起点 旧版合并、整块通信 1.06 本刀 ×1.06 SparseCore 合并 片上按目的地累加 1.16 本刀 ×1.09 通信切块 算完一块发一块 1.45 本刀 ×1.26 整层融合 一层 MoE 一个程序 1.58 本刀 ×1.09 修剪 kernel 砍掉多余来回 同期实测 1.59 四级连乘 1.584,差 0.5%
看绿柱比左右两根高出多少:通信藏到矩阵乘后面,是一次就顶前两刀加起来的一级。
本课据未公开的实测指数化,起点那天 = 1.00,四刀的公开 PR 见正文;只画 prefill,decode 中途换过口径,连不成一条梯子。
出处与口径

📌 本课据私有实测指数化:起点那天的 DP8 prefill 吞吐 = 1.00;四级倍数取紧邻台阶前后两次日常基准。

连乘 1.0565 × 1.0945 × 1.2553 × 1.091 ≈ 1.584,同期首尾实测之比 ≈ 1.592,均为本课推导;差的 0.5% 是台阶之间的日间漂移,与起点那段小幅回落相抵后的余数。绝对吞吐与对外对比口径不画。

第一刀,SparseCore 合并(×1.06)。瓶颈是补齐的中间张量:每 token 选 10 个专家,10 不是 2 的幂,在 TensorCore 上重排会写出大量补齐、不对齐的 HBM。

第二刀,通信切块(×1.09)。reduce-scatter 原本要等整块 [81920, 4096] 都累加完才出发;81920 就是 8 个 rank × 1,024 个 token × 选 10 个专家(本课推导)。切成 4 块,第 1 块在 SparseCore 上累加完就先发。可 XLA 排出来,通信仍没跟计算叠上(分段流水见 #529)。

第三刀,整层融合(×1.26)。整层融合是最大一级:改前 reduce-scatter 约占两成时间,切了块也没东西和它重叠,融合后才藏到矩阵乘后面。

#543 量到的是:DP8+EP、并发 256 时,reduce-scatter 每个 MoE 层 1,190 µs、占全部设备时间 22%,完全露在外面;同样 134 MB 的 all-gather 因为叠上了,只要 36 µs。PR 里端到端 A/B(并发 128,8K 入 1K 出)吞吐 10,614 → 21,297 tok/s,跟梯子上的 ×1.26 测法不同,不能直接比。

第四刀,修剪 kernel(×1.09)。四级连乘约 1.58,同期实测约 1.59,只差半个百分点。拆得这么干净,靠每刀先合进代码、默认关、用环境变量打开,开关前后天然一组 A/B(10.2)。

decode 三刀,砍布局和小 batch:decode 每步要把权重、KV 和状态各过一遍,卡的是 HBM 带宽,三刀都在少搬字节。

K3 对照②K3 只追 1 到 8 条,一步几乎全在读权重,按 config 推一个 token 读约 158 GB(本课推导,1.1)。Inferact 把 92 个 MoE 层装进一次 Pallas 调用,不分 grid,跑在 16 颗 v7 上。挑三刀:
  • 层循环搬进 kernel:一个 kernel 是「搬进来、算、写回去」,搬之外的阶段和起步、收尾时带宽都闲着,每个 kernel 来一遍。整步装进一个程序,权重搬运就不再绑在用它的那个 kernel 上,片上放得下就能提前发;第 N 层还在算 MoE,第 N+1 层的权重已在路上。12.3 那张融合图里 kernel 交接时的空等,就是这么捡回来的。
  • 为什么只能手写:权重要跨层预取,缓冲区就得活过算子边界,而 XLA 有权回收它。在一个 kernel 里自己发起、自己等的搬运,不跨 XLA 能调度的边界。
  • VMEM 分时复用:两种投影加 4 个专家槽各占一块要 90.67 MB,放不进 64 MiB(本课推导:64 MiB ≈ 67.11 MB)。三者时间上不重叠,用 run_scoped 轮流借同一块,共用 31.29 MB 就够,剩约 35.8 MB 给其余的块(本课按公开代码推导)。
  • MXFP4 换 FP8,多读反而快:MXFP4 每 32 个元素要在向量单元上解包缩放一次,FP8 每 256 个才一次,缩放活约剩 1/8。专家三块矩阵里两块换成 FP8,字节多 1.60 倍(本课推导)。可 batch 1 带宽只用到五成上下,卡住的是向量单元(12.1)。
另几刀:专家槽轮转;集合通信按 2×2×4 连线手写,换拓扑就得重写;兼做投机验证器。整个 megakernel 从零编译不到 90 s:顺序和重叠由写 kernel 的人一次排好,XLA 不用再去找。
每一刀打在哪类瓶颈上 —— 并发几百砍通信,并发个位数砍空等 行 = 一刀,列 = 它要解决的瓶颈。定性归类,不代表收益大小;K3 没有逐刀消融 Qwen3.5-397B · v7x-8 · 几百并发 Kimi K3 · 16 颗 v7 · batch 1–8 空心 = 代价 Qwen3.5-397B:前四刀在 prefill,后三刀在 decode HBM 读写 通信露出 形状不规整 向量单元 装不装得下 编译 SparseCore 合并 通信切块 整层融合 修剪 kernel KV 序列放最内层 小 batch 不排序 线性状态 BF16 Kimi K3 megakernel:整个模型一次调用 HBM 读写 通信露出 形状不规整 向量单元 装不装得下 编译 层循环进 kernel VMEM 分时复用 专家槽轮转 手写集合通信 MXFP4 换 FP8 残差流再切 兼做验证器 整块编译
看实心点扎堆在哪一列:上表在通信和形状,下表在 HBM 读写。
定性归类,点的大小不代表收益;K3 一侧依据 Inferact 公开博客与代码。
出处与口径

📌 Qwen3.5 各刀的机制归类依据私有记录,只取机制不取数。K3 依据 inferact.ai/blog/tpu-megakernels(2026-09-23)与其 Apache-2.0 公开代码 github.com/Inferact/tpu-megakernels。

「MXFP4 换 FP8」的代价与收益为本课按公开代码推导:专家每元素位数 12.75 → 20.37(三块合计),即 ×1.60;缩放从每 32 个元素一次变成每 256 个一次,向量单元上这部分活约为原来的 1/8。

拆开不一定更快。PCP8 收尾时吞吐是 DP8 的约 0.89 倍,省的是长 prompt 的首 token 延迟(本课推测,7.2);tpu-inference 上拆 PD,每请求要搬约 349 MB(KV 加线性层状态,8.3),单并发 0.95 倍。一台装得下就先别拆(8.1)。

多副本时,前缀缓存只在本副本有效,KV 感知路由把同前缀的请求送到存着它的副本;SGLang、NVIDIA Dynamo、llm-d、GKE Inference Gateway 都做了。另一条路是 DeepSeek 那样把 KV 放进全集群共享的存储,哪个副本都能命中,路由就不用管前缀(4.4)。选栈:JetStream 已停止维护;tpu-inference 是 vLLM 的 JAX 后端,SGLang-JAX 是 SGLang 的 JAX 实现;PyTorch 一侧有 vLLM-TorchTPU 和 SGLang-TorchTPU,本节主线是前者。先看模型在不在支持列表里,再看第十节的拓扑搭不搭得出来。

⭐ 同一种芯片,刀落在哪取决于 batch:Qwen3.5 并发几百,刀落在通信和形状;K3 只有 1 到 8 条,刀落在 HBM 读写。先看 batch 落在 1.1 的哪一侧,再决定刀往哪砍。接手一个服务的第一天怎么问,收成第十五节的八问。

第 十五 节

第一天的八问

接手一个推理服务,第一天先问八件事。前四问算纸上的账,后四问拨开关。

第一天的八问 —— 先定尺子和账,再挑招数 还是第零节那一趟:每一问钉在它问的那个部件上 校准尺子 / 上线 分给更多 token 少搬 拆开放对地方 八个图钉 吞 prompt KV 仓库 = 显存 权重 KV 权重 工位 = 算力 1 2 3 4 5 6 7a 8 7b 算账 1 负载长什么样? 2 用哪把尺子? 3 一步至少搬多少字节? 4 放得下几条序列? 挑招数 5 attention 怎么切? 6 拆不拆 PD,配几台? 7a 量化、 7b 投机开不开? 8 上线前跑通了吗?
八问里有四问钉在车上(车 = 每步从显存往工位搬的那一趟):3、4、7、8。
颜色对主线:灰 = 校准尺子/上线,蓝 = 分给更多 token,绿 = 少搬,橙 = 拆开放对地方。
出处与口径

⚠️ 本课归纳:顺序按「先校准、再算账、后调招数」排,各问拿什么回答、判据见正文和对应的节。

15.1 前四问:算账

15.2 后四问:挑招数

⭐ 八问归到一句话:decode 每一步都要搬一趟。前四问算清这一趟有多重、能分给多少人;后四问要么让更多人分,要么让它变轻。

15.3 回到时间轴:系统这一侧省了多少

0.1 说的降价是市场价,混着更强的小模型、硬件换代和系统招数;报告主要归给小模型,硬件那份给的是能效每年升 40%,系统那份拆不出来。

Epoch AI(2025)固定一档能力看,达到它的推理年年在便宜,2024 年以后降得更快,恰与第八到十二节那批招数进生产同期(本课观察,Epoch 没归因)。

每行基线不同,不能连乘去凑市场上的降幅;只有末行是同一硬件、同一模型上叠满软件招数的总账。

年份补的哪个洞(0.1 的环)首发节一个实测(对照谁)
2022① 整批等最长的论文三Orca 连续批:同延迟吞吐是 FasterTransformer 静态批的 36.9 倍
2022② 字节太多:权重论文十二GPTQ 3 bit:1 张 A100 跑 OPT-175B,逐字速度是 5 卡 FP16 的 3.25 倍
2022③ 一趟只出一个字论文十一投机解码:单请求速度是不投机的 2–3 倍
2023⑤ KV 预留浪费vLLM四PagedAttention:同延迟吞吐是 FasterTransformer 和复现版 Orca 的 2–4 倍
2023④ 每条 KV 太厚论文四GQA-8:T5-XXL 每条样本推理约快 5.4 倍,平均分 47.1 对 47.2(对原版 MHA,本课推导)
2023② 字节太多:权重论文十二AWQ 4 bit:Llama-2-7B 单卡 RTX 4090 再快 3.1 倍(对已融合 kernel 的 FP16)
2023⑧ 同样开头重算SGLang四RadixAttention:吞吐最多是当时其他系统的 6.4 倍
2024⑦ 两段抢同一批卡论文八DistServe:同样的延迟要求下,每卡能接的请求最多是不拆的 DeepSpeed-MII 的 7.4 倍
2024⑥ 长 prompt 插队论文三Sarathi-Serve 分块 prefill:延迟达标时可接请求是 vLLM 的 2.6–3.7 倍
2024④ 每条 KV 太厚DeepSeek四MLA:每层 KV 约是同形状 MHA 的 1/57(本课推导)
2024⑨ 前缀存不下Kimi八Mooncake KV 池:Kimi 线上可接请求比此前系统多 107%–115%
2024② 字节太多:权重vLLM十二vLLM FP8(权重和激活都 8 bit):2 张 H100 跑 Llama 3 70B,每字间隔最多降到未量化的 1/2
2024⑨ 前缀存不下DeepSeek四DeepSeek 磁盘 KV 缓存:128K prompt 首字 13 s → 0.5 s(对不用缓存)
2024③ 一趟只出一个字DeepSeek十一DeepSeek-V3 的 MTP:速度约是不开的 1.8 倍
2024⑨ 前缀存不下:副本摊薄SGLang十四SGLang v0.4 KV 感知路由:命中率 20% → 75%,吞吐是 v0.3 的 1.9 倍
2024⑩ KV 被复制、长 prompt 太慢论文七Meta 跨机切序列:Llama3 405B 在 8 台 H100 上,跨机切 TP 的 prefill 延迟和它差约 100%(TP 慢)
2025调度占着 CPUvLLM三vLLM V1 引擎重写:吞吐最多是 V0 的 1.7 倍
2025③ 一趟只出一个字论文十一EAGLE-3:单请求最多是不投机的 6.5 倍,batch 64 吞吐仍是其 1.38 倍
2025⑪ MoE 拆散 batchDeepSeek六SGLang 复现大 EP+PD 分离:输出吞吐最多是同卡数纯 TP 的 5 倍
2025④ 每条 KV 太厚DeepSeek四DeepSeek-V3.2 稀疏注意力(DSA):每字只读 2,048 个历史 token(V3.1-Terminus 全读),基准基本持平
2025② 字节太多:KVDeepSeek十二V3.2 存 FP8 KV:同显存请求容量约是 BF16 KV 的 1.63 倍(本课推导)
2025② 字节太多:权重Kimi十二Kimi K2 Thinking 原生 INT4 权重:低延迟模式生成约快 2 倍(模型卡未写对照精度)
2025② 字节太多:KVNVIDIA十二NVFP4(4 bit 格式)KV:大小约是 FP8 KV 的一半,前缀命中率最多高 20%(Qwen3-Coder-480B 上测)
2026⑨ 前缀存不下llm-d四llm-d 卸 KV 到主机内存:P90(九成请求)首字 2.1 s → 0.5 s(对不卸载)
2026-06①–⑪ 叠起来SGLang二GB300 跑 V4-Pro,硬件、模型、交互档不变,光改软件:每卡从首发日约 2,200 到约 11,200(后者开 MTP、首发日没开;PyTorch 博客)

⭐ 开场那道题的答案就是末行:5.1 倍(约 11,200 ÷ 约 2,200,本课推导;博客标题写 5 倍)。卡、模型、交互档都没换,涨出来的每个字都是软件挣的。

这 5.1 倍里 MTP 占多少,博客没拆。它只分开报了两条六月曲线各比首发日曲线涨多少:不开 MTP 的在单用户每秒 40 token 那档涨到 2.1 倍,开 MTP 的在 80 那档涨到 2.6 倍,档位不同,不能相减。

别处有一组干净的拆法,换了模型和卡,只能当量级参考:TensorRT-LLM 在 8 张 B200 上跑 DeepSeek-R1,单用户每秒 111 token,开 1 层 MTP 到 198,开 3 层到 253,开 5 层反降到 239。

2022 年以来 —— 每一步补一个洞 卡片落在首次公开的年月上;卡上是原文报告的提升或做法;右上角是本课讲它的那一节;虚线卡是模型侧的进步;顶上红、紫两条竖线是推着各泳道的两股压力:上下文变长、输出变长 2022 年中 2023 2024 2025 2026 上下文变长 128K ▼ ▼ 1M ▼ o1 ▼ R1 输出变长(推理模型) 调度 一批里谁进谁出 Orca 连续批 36.9×,吞吐 vs FasterTransformer 第三节 Sarathi-Serve 分块 2.6–3.7×,达标容量 vs vLLM 第三节 vLLM V1 重写引擎 吞吐最多 1.7×,对 V0 第三节 KV 与注意力 多装几个人,读得更快 GQA KV ÷8(64 头 8 组,推导) 第四节 模型侧 PagedAttention KV 有效占用 20–38%→96% 第四节 Flash-Decoding 解码最多 8×,对旧注意力 第五节 MLA(DeepSeek-V2) 对同形状 MHA ÷57(推导) 第四节 模型侧 DSA(DeepSeek-V3.2) 每字只读 2,048 条 KV 第四节 模型侧 复用与下放 算过的不再算 RadixAttention 吞吐最多 6.4×,对其他系统 第四节 Mooncake KV 池 多接 115%/107%,对此前系统 第八节 SGLang KV 感知路由 命中 20→75%,1.9×,对 v0.3 第十四节 llm-d 路由实测 命中 340 ms,不路由最坏 2,850 第十四节 解码提速 搬一趟出几个字 投机解码 单请求 2–3×,对不投机 第十一节 EAGLE 单请求 2.7–3.5×,对不投机 第十一节 DeepSeek-V3 MTP 约 1.8×,对不开 MTP 第十一节 EAGLE-3 单请求最多 6.5×,对不投机 第十一节 DSpark 半自回归 一次出一小段,按置信度验 第十一节 拆开放 拆阶段(PD)/拆模型(EP) 拆阶段|Splitwise 同成本吞吐 2.35×,对不拆 第八节 拆阶段|DistServe 每卡请求率 7.4×,对 DeepSpeed-MII 第八节 两样都拆|DeepSeek 每节点 decode 14.8k tok/s 第二节 两样都拆|SGLang 复现 大 EP+PD,对同卡 TP 最多 5× 第六节 少搬字节 量化、合并 kernel GPTQ 3–4 bit 3 bit 逐字 3.25×,对 5 卡 FP16 第十二节 AWQ 4 bit 按激活护住重要通道 第十二节 FP8 权重与 KV V3 连训练都用 FP8 第十二节 NVFP4/MXFP4 每数 4.25–4.5 bit 第十二节 TPU megakernel 整次前向一个 kernel 第十二节 叠起来:GB300 跑 V4-Pro,硬件模型都不换 软件栈合计,同一交互档每卡 5.1×(Day-0 → 2026-06) 第二、十五节 这些倍数不能连乘 后一个的基线已经吃掉了前一个的收益:Orca 比的是 FT,vLLM 比的是已有连续批的 Orca,Sarathi-Serve 比的是 vLLM。 口径也不同:有的是吞吐,有的是单请求延迟,有的是达标请求数,有的只是显存。
分类账:上表按年记流水,这张图把同一批招数按六类分户。
图上比表多几张卡,如 Flash-Decoding、Splitwise、TPU megakernel。
出处与口径

Orca OSDI'22;vLLM arXiv 2309.06180 图 2;GQA arXiv 2305.13245(÷8 本课推导);DeepSeek-V2 arXiv 2405.04434(论文对稠密 67B 报 KV −93.3%,混着 6 bit KV 等改动;卡上 ÷57 是第三节同形状 3,997,696 → 70,272 B,本课推导);SGLang arXiv 2312.07104;Mooncake FAST'25(Kimi 线上 A800/H800);llm-d:Red Hat Developer 2025-10-07(厂商自测);Leviathan arXiv 2211.17192;Flash-Decoding 斯坦福 CRFM 2023-10;EAGLE arXiv 2401.15077;DeepSeek-V3 arXiv 2412.19437 §5.4.3;Splitwise arXiv 2311.18677;DistServe arXiv 2401.09670;DeepSeek open-infra-index Day 6;SGLang 大 EP 博客 2025-05;Sarathi-Serve arXiv 2403.02310;GPTQ arXiv 2210.17323;AWQ arXiv 2306.00978;NVFP4 NVIDIA 博客 2025-06;上下文台阶:OpenAI DevDay 2023-11-06、Google 2024-02-15;输出变长:OpenAI 2024-09-12、DeepSeek-R1 arXiv 2501.12948;vLLM V1 博客 2025-01-27;SGLang v0.4 博客 2024-12-04;EAGLE-3 arXiv 2503.01840;DSA:DeepSeek-V3.2-Exp 技术报告 §2.1;叠加 5.1×:PyTorch 博客 2026-06-23;DSpark arXiv 2607.05147;TPU megakernel:Inferact 博客 2026-09。

落到真实账上,看 DeepSeek 公开的一天:

近八成 token 是输入,其中一半多直接命中 KV 缓存 DeepSeek 2025-03 公开的一天(2025-02-27~28),V3 / R1 线上服务;条长按 token 数 命中缓存(KV 复用) 未命中(要现算 prefill) 输出(decode) 一天 7,760 亿 token 怎么分 输入 6,080 亿(78.4%),其中 56.3% 命中缓存 3,420 亿 输入 · 命中缓存 占全天 44.1% 2,660 亿 输入 · 未命中 占全天 34.3% 1,680 亿 输出 占全天 21.6% 平均 226.75 个 H800 节点 × 8 卡 = 1,814 张卡 每卡每秒约 4,950 token 全天平均,输入输出都算
输入占大头;紫色那段就是磁盘 KV 缓存替 prefill 省下的。
出处与口径

📌 github.com/deepseek-ai/open-infra-index 202502OpenSourceWeek/day_6(2025-03-01 公布,统计 2025-02-27~28):226.75 节点、输入 6,080 亿(其中 3,420 亿命中磁盘 KV,56.3%)、输出 1,680 亿。

⚠️ 本课推导:未命中 = 6,080 − 3,420 = 2,660 亿;各段占比 = 段 ÷ 7,760 亿;1,814 = 226.75 × 8;每卡每秒 = 7,760 亿 ÷ 86,400 s ÷ 1,814 卡。分母是全部卡、全天平均,不是 decode 卡的峰值。

这套服务用的正是表里的 MLA、大 EP 加 PD 分离、磁盘 KV 缓存和 FP8。

⭐ 回到 2022 年那一批人:等最长的那个 → 每步换人,座位却不够 → 分页、压薄、复用 → 长 prompt 插队 → 切块,再拆成两批机器 → MoE 拆散 batch → 大 EP → prefill 喂不上,重配台数 → 输出变长 → 投机 → 再少搬字节。同一套硬件光改软件,每卡已是首发日的 5.1 倍。下一个洞已经露出来,就是第十三节那件事:线性层的状态截不开,前缀难复用;tpu-inference 上跑 Qwen3.5,前缀缓存至今还得关(13.2)。

第 十六 节

出处台账

正文每个数字、每句结论的来源都记在这里,供核对用,平时不必看。按「结论 ← 材料」排,顺序跟正文各节走。2026-10-15 核对。

点开出处台账(核对用,很长)
结论材料
DeepSeek-V3:总参数 6,710 亿、每 token 激活 370 亿;61 层、hidden 7168、256 个路由专家选 8、kv_lora 512 + rope 64、moe_intermediate 2048DeepSeek-V3 Technical Report(arXiv 2412.19437)摘要;形状取 Hugging Face deepseek-ai/DeepSeek-V3 的 config.json
MLA 每 token KV 70,272 字节;128K 一条序列 8.58 GiB(9.21 GB)本课推导:(512+64) × 2 B × 61 层;× 131,072
L83 · 0.2 逐层走一遍:每层注意力 187,105,280 参数(FP8 约 187 MB)、稠密前馈 396,361,728、单个专家 44,040,192(8 路由+1 共享正好 396,361,728)、路由打分 256 × 7168;前 3 层稠密、后 58 层 MoE;每层读权重约 583/585 MB,61 层合计 35.7B,加输出层 0.93B = 36.6B,取整对上激活 37B;同一套公式总参数 671.0B,对上 671B(不含 MTP 层);KV 每层每 token 512+64 = 576 个数 × 2 B = 1,152 B,1 万 token 每层 11.5 MB、全层 0.70 GB,128K 每层 151 MB;传下一层 7,168 维 × 2 B = 14,336 BHugging Face deepseek-ai/DeepSeek-V3 的 config.json(2026-10-17 读:first_k_dense_replace 3、intermediate_size 18432、moe_intermediate_size 2048、n_shared_experts 1、q_lora_rank 1536、qk_nope_head_dim 128、v_head_dim 128、vocab_size 129280、tie_word_embeddings false);本课推导:注意力 = 7168×1536 + 1536×128×192 + 7168×576 + 512×128×256 + 128×128×7168,前馈 3×7168×18432,专家 3×7168×2048,输出层 129,280×7168;输入词表查表只读一行,不计入每步读量;逐项 assert 在 topic06-fig-layerwalk.py;多人时挑中的不同专家按均匀独立路由估 256 ×(1 −(248/256)^B):64 人约 222、128 人约 252;全部 256 个专家 × 44,040,192 B ≈ 11.3 GB/层
L83 · 0.2:v7 片上 VMEM 每 TensorCore 64 MiB、每芯片 2 个 TensorCore = 128 MiB,约为 192 GiB HBM 的 1/1,500JAX jax/_src/pallas/mosaic/tpu_info.py(TPU_7X:vmem_capacity_bytes 64 MiB per core、2 个 TensorCore);inferact.ai/blog/tpu-megakernels(「64 MiB of VMEM per TensorCore」,14.7 已引);1/1,500 本课推导:192 × 1024 ÷ 128 = 1,536
TPU v7:FP8 4,614 TFLOP/s、HBM 192 GiB(≈ 206.2 GB)、7.37 TB/s,每芯片 2 个 device;BF16 2,307 TFLOP/s,屋脊点 ≈313 FLOP/字节Google Cloud TPU7x 公开规格页(写 7,380 GB/s;7.37 TB/s 取 Google 博客 Ironwood: The first Google TPU for the age of inference,2025-04,差 0.14% 不影响屋脊点);JAX jax/_src/pallas/mosaic/tpu_info.py 记每芯片 HBM 206e9 字节(≈ 191.9 GiB),即规格表的 192 GiB;BF16 与屋脊点本课推导:4,614 ÷ 2,2,307 TFLOP/s ÷ 7.37 TB/s
TTFT、TPOT/ITL 的定义vLLM 仓库 vllm/benchmarks/serve.py;NVIDIA NIM 的 LLM benchmarking 文档页(写明 ITL also known as TPOT)
decode 一步:读 37 GB 要 5.02 ms,算 74 GFLOP 只要 0.016 ms,算力用上 0.32%本课推导:37 GB ÷ 7.37 TB/s;2 × 37e9 ÷ 4,614 TFLOP/s;FP8 每参数 1 字节、每 token 2 FLOP,屋脊点 4,614 TFLOP/s ÷ 7.37 TB/s ≈ 626 FLOP/字节,2 ÷ 626 ≈ 0.32%
算术强度 M·H ÷ (H+2M):M=256 时 239,M≈343 过屋脊本课推导:H=7168 的方阵乘,bf16
256 用户、128K 时 KV 占一步字节的 78%;权重项 = 非路由部分 + 653.9B × [1 − (1 − 8/256)b]本课推导:路由专家 256 × 58 层 × 3 × 7168 × 2048 = 653.9B
decode MoE 每专家平均 8 行,MXU 一边 256,只用上 1/32本课推导:256 × 8 ÷ 256;MXU 尺寸见 JAX jax/_src/pallas/mosaic/tpu_info.py 的 mxu_column_size
Gemma4-31B 并发 1 TTFT 86 ms,并发 256 涨到 7,756 ms(多出来的是排队)本课程作者实测:gpu-tpu-pedia tpu/tpu-inference/Gemma4-31B/README.md:453-486
InferenceX 三点 68→9,759、121→3,816、173→895 tok/s/GPUgpu-tpu-pedia VLLM-V4PRO-RUNBOOK.md:683-695
V4 on GB300:交互 ~50 tok/s/user 时每卡 ~11,200(开 MTP;分母是 decode 卡还是全部卡,官方未写明),Day-0 ~2,200(未开 MTP,5.1×);每卡同时服务约 224 个用户PyTorch 博客 2026-06-23「Serving DeepSeek-V4 on GB300 with SGLang: 5x Higher Throughput at the Same Interactivity Since Day-0」;224 = 11,200 ÷ 50 本课推导
同一次跑:output÷decode 卡 5,270,(in+out)÷全部卡 11,880,换口径 1,318 到 47,520,差 36×gpu-tpu-pedia SGLANG-V4PRO-RUNBOOK.md:794-809,字段定义 :731-735;1,318、47,520、36× 本课推导
假天花板:6,887 → 10,614(+54%)→ 10,704,峰值 12,070SGLANG-V4PRO-RUNBOOK.md:611-615、849-858(§11.5 L849-896)
temperature 0 与非 0:投机接受率 1.16% 对 34%,吞吐 944 对 2,911;K3 的草稿按概率抽,官方就用温度 1.0 压测VLLM-V4PRO-RUNBOOK.md:394-420;K3 见 VLLM-K3-RUNBOOK.md:226-230
没预热:第一轮 13,585、第二轮 27,803(×2.05);闭环压测会严重低估(原文未给数)VLLM-V4PRO-RUNBOOK.md:431-433;闭环 SGLANG-V4PRO-RUNBOOK.md:478
goodput 比吞吐更能比系统:最多 7.4× 每卡请求率(对 vLLM、DeepSpeed-MII)、12.6× 更紧 SLO(摘要口径:对当时 SOTA;正文 7.4× 那组是对 DeepSpeed-MII,两段同卡,按每卡请求率)DistServe,arXiv 2401.09670
vLLM 压测工具的 goodput = 每秒达标请求数(与 DistServe 口径不同)vLLM 仓库 vllm/benchmarks/serve.py 的 --goodput 参数
DeepSeek 线上实测(2025-03-01 公布,统计 2025-02-27~28):226.75 节点、理论成本利润率 545%(全按 R1 定价收费的假设;价格口径,课件正文不引用)、decode 时每节点输出约 14,800 tok/s(原文「~14.8k tokens/s output during decoding」;故事图卡片写 14.8k,同一数)、20–22 tok/s/user;一天输入 6,080 亿、输出 1,680 亿 token,合每卡每秒约 4,950(本课推导:7,760 亿 ÷ 86,400 ÷ 1,814 卡)GitHub deepseek-ai/open-infra-index:202502OpenSourceWeek/day_6
每 token KV:MHA 3,997,696 B、GQA(Llama-3.1-70B)327,680 B、Qwen3.5 全注意力 30,720 B + 线性状态 180 MiB/序列;Qwen3.5 KV 头数 2本课推导,形状取各自 Hugging Face config.json
Qwen3.5-397B 形状:32 个查询头、2 个 KV 头、head_dim 256(32 × 256 = 8,192,hidden 只有 4,096);60 层每 4 层 1 层全注意力(共 15 层);512 个专家每 token 选 10 个,另 1 个共享专家,专家中间维 1,024huggingface.co/Qwen/Qwen3.5-397B-A17B config.json(text_config:num_attention_heads、num_key_value_heads、head_dim、full_attention_interval、layer_types、num_experts_per_tok、moe_intermediate_size、shared_expert_intermediate_size),2026-10-21 核对
7.1 交叉点:专家每 token 每层约 2.77 亿 FLOPs;注意力 32,768 × L;单层 decode 约 8.4K、prefill 约 16.9K,全模型约 34K/68K本课推导:11 × 2 × 3 × 4096 × 1024 = 276,824,064;4 × 32 × 256 = 32,768;276,824,064 ÷ 32,768 = 8,448,prefill 因果 × 2 = 16,896;全模型 × 60 ÷ 15 = 33,792/67,584。只计注意力打分与加权、专家三个矩阵,不计投影与线性注意力层
8 颗 v7(16 个 device)放 V3:KV 池 46.2 GiB/device,4K 装 172 条、32K 装 21 条、64K 装 10 条(FP8 KV 按 656 B/层约 18 条);Llama 4K 36 条本课推导:按 device 算(一颗芯片=两个 device,不当整块用),每 device 实测可用 94.75 GiB(R1 FP4 README:59)× 0.9 = 85.275 GiB,− 39.1 GiB(671 GB ÷ 16);0.9 为本课假设;先按权重全切分粗算,DP attention 下非专家权重每 device 复制,实际更小(10.2)
PagedAttention:KV 有效利用率 20.4–38.2% → 96.3%(4.2 正文照录;故事图卡片取整写 20–38%→96%,第零节、第十五节落点与故事图 alt 口语写「两到近四成 → 96%」,同一组数,正文与图只是取整不同)vLLM 论文,arXiv 2309.06180
Qwen3.5 RPA KV 页 16→256 token:并发 512 时这个 kernel 的 decode 一步 428 → 283 µs(原文称 kernel 级提速 33.8%,不是整步;原因:页小时索引开销让 VPU 停顿)原文「reduced the decode step latency under Concurrency-512 from 428µs to 283µs, achieving a 33.8% kernel-level speedup」;gpu-tpu-pedia tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/BLOG-systems-engineering-playbook.md L395-405,即 Google Developers Blog「Systems Engineering Playbook: Optimizing Qwen 3.5-397B MoE on Ironwood (TPU7x)」
V4 两个池(full/swa)预算比改 0.20 → 0.15:每 rank 请求 727 → 886,端到端每 decode 卡 6,887 → 10,614(+54%);8K 输入时 ratio 0.10 为 9,354(滑窗池 96%、全长池 78%,每 rank 588),0.15 为 9,053SGLANG-V4PRO-RUNBOOK.md:855-857(§11.5 L849-896);8K 两行 :864-865;swa_tokens 比例 L946(引 pool_configurator.py:387);sliding_window 128 见 HF config
再把 mem-fraction-static 0.85 → 0.88:每 rank 请求 886 → 999(+13%),端到端 10,614 → 10,704SGLANG-V4PRO-RUNBOOK.md:857-858、887-892
Qwen3.5 混合池的 bug 与 prefix caching 断言;越界写入被「钳回末尾」(README 记的是 dynamic_update_slice_in_dim,越界起点被 clamp 到合法范围、不报错;同为越界,x[i] 取值也是 clamp,jnp.take 默认填 NaN,.at[].set 默认丢弃)tpu/tpu-inference Qwen3.5 README:77、:95;JAX 文档「Sharp bits · Out-of-bounds indexing」与 jax.lax.dynamic_update_slice 文档,JAX 0.11.0 本机实测。2026-10-15 核对
SGLang(含 RadixAttention 前缀复用)吞吐最多 6.4×,对照是当时其他推理系统(不是「不复用」),且是整套运行时(RadixAttention + 压缩状态机等)的结果SGLang arXiv 2312.07104 摘要("up to 6.4x higher throughput compared to state-of-the-art inference systems")
Flash-Decoding:长上下文 decode 最多提速 8 倍斯坦福 CRFM 博客 2023-10「Flash-Decoding for long-context inference」
投机解码 2–3×;EAGLE 2.7–3.5×(LLaMA2-Chat 70B);V3 MTP 第 2 个 token 接受 85–90%、1.8×(均单请求延迟/TPS 口径)Leviathan 等 arXiv 2211.17192 摘要;EAGLE arXiv 2401.15077 摘要;DeepSeek-V3 报告 arXiv 2412.19437(MTP 评估一节)
KV 外存回读的盈亏带宽:V3 2.19 GB/s、Llama 5.35 GB/s,1 GB/s 的慢链路在前缀长于 ~35K 时也比重算快本课推导:重算 = (2 × 37e9 × L + 4,997,120 × L²/2) ÷ (4,614 T × 50%);Llama 激活 70.6B 取 HF 模型页
Orca 迭代级调度:同延迟下吞吐是 FasterTransformer 的 36.9×(GPT-3 175B;中位归一化延迟 190 ms/token 时 0.185 → 6.81 req/s)Orca,OSDI'22(摘要「36.9× throughput improvement at the same level of latency」;§6「to match a median normalized latency of 190ms for the 175B model … 0.185 req/s … 6.81 req/s, which is a 36.9× speedup」)
chunked prefill;Sarathi-Serve 达标容量是 vLLM 的 2.6×(Mistral-7B)–3.7×(Yi-34B),配流水线并行跑 Falcon-180B 端到端最多 5.6×(摘要未写对照);Gemma4 一次 prefill 16,384 token、切 16 块Sarathi arXiv 2308.16369;Sarathi-Serve arXiv 2403.02310;vLLM 文档 Optimization and Tuning 页;Gemma4-31B/README.md:225-226
并发 400 → 1,800:总负载 4.5×,每卡只多 11%(8,777 → 9,745 tok/s);有记录的 TTFT 从并发 600 的 45 s 涨到 1,800 的 253 sSGLANG-V4PRO-RUNBOOK.md:593-609
V4-Pro dep8 并发扫描:conc600(客户端 8,400 路)每张 decode 卡 9,168 tok/s、TPOT 59–61 ms ≈ 每用户 17 tok/s(指标图「9,168 @ 17」);conc1200 首字中位 150 s;TPOT 全程 58–63 ms(批处理图)SGLANG-V4PRO-RUNBOOK.md:591-599 并发扫描表(conc600 在 :596、conc1200 在 :598)、:604;17 = 1000 ÷ 60 本课推导
Little 定律核对:dep8 4,335(每卡约 542)、dep16 2,783;客户端并发 8,400 路(14 个 frontend × 每路 600)SGLANG-V4PRO-RUNBOOK.md:794-801;本课推导 9,032 × 8 × 0.060、84,321 × 0.033、4,335 ÷ 8;8,400 见并发扫描表 :596(conc600 那档,TTFT 同为 45 s)
多给槽位:并发 886 → 999,峰值只 12,063 → 12,070,TPOT 77.7 → 85.3 msSGLANG-V4PRO-RUNBOOK.md:849-858、885-894
SGLang-JAX 调度开销 12 ms → 38 µs;按 batch 尺寸预编译lmsys.org/blog/2025-10-29-sglang-jax
vLLM 抢占默认 RECOMPUTE;公平调度 VTC;跨实例迁移 Llumnixdocs.vllm.ai「Optimization and Tuning」页;arXiv 2401.00588;arXiv 2406.03243
Llama-3.1-70B 权重 141,107,412,992 字节;8K 一条 KV 2.68 GB;batch ≈52.6 时两者一样重HF safetensors index 的 total_size;其余本课推导
TPU 内存 tile 规则(每 KV 头补齐到整块)openxla.org/xla/tiled_layout
RPA 在 TPU7x 跑 Llama 3 8B:decode 带宽利用最多 86%、prefill 算力利用 73%arXiv 2604.15464 摘要
Ragged Paged Attention 的布局与 kernel 设计RPA,arXiv 2604.15464 §2.1.2、§3.1、§3.4、§3.5
5.3 KV 怎么搬上芯片:按页表从显存取页、拼成片上一块;Q、KV、输出都双缓冲,算第 j 块时第 j+1 块已在搬,一条序列算完接着取下一条的第一块;只搬有效长度;同组查询头摞成一个矩阵共用一块 K、V;K、V 合成一趟搬;新 KV 异步写回;decode 调块大小冲带宽、prefill 冲算力利用RPA,arXiv 2604.15464 §3.3、算法 1 第 7–13 行、§3.4 开头、§3.1.2、§3.1.3、§3.5。2026-10-18 核对
5.1 一层 decode 一步要搬约 256 万 token 的 KV(512 条 × 平均约 5,000);prefill 同一块 KV 被 G × 查询行数次复用,所以是几百倍本课推导:512 × 5,000 = 2,560,000;每块复用次数 = GQA 组大小 G × 一块里的查询行数
MLA 吸收后 decode 算术强度 242,prefill 每对运算量 3.4×DeepSeek-V2 arXiv 2405.04434 §2.1.2;本课推导 278,528 ÷ 1,152、278,528 ÷ 81,920
MLA 每 token KV 只有同形状 MHA 的约 1/57(故事图卡片 ÷57 同此)本课推导:70,272 ÷ 3,997,696(4.1 表)
故事图:GQA 卡「KV ÷8」;DeepSeek-V2 卡与脚注「KV −93.3%」(对稠密 67B)GQA arXiv 2305.13245,÷8 本课推导:64 个查询头分 8 组、每组共用一份 KV;DeepSeek-V2 arXiv 2405.04434 摘要(论文的 −93.3% 混着 6 bit KV 等改动)
单专家 44,040,192 参数;单 device 读权重 23.9 µs(bf16)/11.95 µs(fp8),稠密算 19.5/9.77 µs本课推导:3 × 7168 × 2048;3.685 TB/s = 7.37 ÷ 2,1,153.5/2,307 TFLOP/s = 每芯片 ÷ 2
decode AllReduce 11.0 → 2.37 µs,SoL 1.404 µs,ITL −8.7%arXiv 2607.16100
tpu-inference#2674:batch 小时用「one-hot 矩阵 × 隐状态」代替按下标排序/还原;Qwen3.5 并发 64 总吞吐 2,211 → 2,531(+14.5%,1K 进 8K 出)、11,269 → 12,090(+7.3%,8K 进 1K 出);合入后默认关(环境变量 ONEHOT_MOE_PERMUTE_THRESHOLD 默认 0)github.com/vllm-project/tpu-inference/pull/2674(2026-05-22 合入)正文表与 diff。2026-10-15 核对
14,336 字节消息的带宽项只要 24 ns,实测是它的 460×本课推导:7168 × 2 B = 14,336 B;× 2(n−1)/n = 1.5(4 卡 ring AllReduce);NVLink5 1.8 TB/s 双向 → 单向 900 GB/s;14,336 × 1.5 ÷ 900 GB/s ≈ 23.9 ns;11.0 µs ÷ 23.9 ns ≈ 460
V4-Pro 只有 1 个 KV 头,TP 切注意力会复制 KVVLLM-V4PRO-RUNBOOK.md:298-302
第六节主线 · SGLang 两头 DEP:14 台 prefill 各 dep4 + 1 组 decode dep8(跨 2 节点),16 节点 GB300 同一 NVL72 域;ISL 4096 端到端每 decode 卡 10,704(官方 11,200 的 95.6%);图中三行:每卡在跑 727/886/999,full/swa 占用 0.93/0.63、0.92/0.89、0.92/0.67,端到端 6,887/10,614/10,704,TPOT 58.0/77.7/85.3 ms,峰值 11,851/12,063/12,070SGLANG-V4PRO-RUNBOOK.md:33-34、:39;scripts/prefill-dep4.sh、decode-dep8.sh;三行 :851-858(#1/#3/#7,14 路 × 并发 1050)
decode 从 dep8 宽到 dep16(16 节点下 prefill 14 → 12):总输出 72,256 → 84,321(+17%),TPOT 60 → 33 ms,TTFT 45 → 54 s,每 decode 卡 9,032 → 5,270;原文判 prefill 为瓶颈SGLANG-V4PRO-RUNBOOK.md:790-806
并发 512 时 TP4 21,100(16 卡)对 DEP 55,153(20 卡):每卡 1,319 对 2,758,2.09×;DEP 并发 1,536 时 65,132、每卡 3,257、2.47×,TTFT 95 s;输出 4,220 对 11,031 tok/s、出字间隔 46.8 对 11.8 ms (步时约 ÷4;第六节只作速度轴旁证);每张 decode 卡输出 1,055 对 1,379,1.31×;投机接受率 34% 对 35.7%VLLM-V4PRO-RUNBOOK.md:449、464-468、476;每卡与 2.09× 本课推导;接受率 :480;每 decode 卡 = 输出 ÷ 4 或 8,本课推导(runbook 原文把收益归给容量,但没记 KV 池占用;本课只认实测到的步时)
DEP 每卡吞吐随 prefill 喂料 307 → 12 个 prefill 时 3,187(14 个时 3,321);TP4 停在 20,479VLLM-V4PRO-RUNBOOK.md:711-724(4k1k 重跑 :727-734)、:488,2026-07-24 记录
tpu-inference DEP:并发 512 时领先 62%(1k/8k)、40%(8k/1k);并发 64/128/256 时 1k/8k 为 0%(打平)/+14%/+22%,8k/1k 为 +14%/+23%/+36%(输出 tok/s,DP=8 对 TP=8);mmlu_pro 0.8129 对 0.8271github.com/vllm-project/tpu-inference/pull/2577(2026-05-15 合入)
大 EP:DeepSeek decode 用 EP144(18 个节点),每卡 2 个路由专家 + 1 个共享专家;EP 的两条理由(放大 batch 提高矩阵效率、每卡只读少数专家降低延迟);一批拆两个微批交替藏通信;跨节点 all-to-all 用 DeepEP;Day 6 发布于 2025-03-01(仓库 commit 2025-03-01T04:03Z)github.com/deepseek-ai/open-infra-index/blob/main/202502OpenSourceWeek/day_6_one_more_thing_deepseekV3R1_inference_system_overview.md;「空出的显存给 KV」本课推导
SGLang 在 96 张 H100 上复现 PD 分离+大 EP:输出吞吐最多是同卡数纯 TP 的 5×lmsys.org/blog/2025-05-05-large-scale-ep
TEP/DEP 的定义;Megatron 命名;Folding沿用专题五台账第 43、44、18 行
Meta 上下文并行:128 张 H100(16 节点)跑 Llama3 405B,prefill 1M token 77 s、128K 3.8 s,并行效率 93%arXiv 2411.01783 摘要
K3 DCP:128K 并发 8 吞吐 108 → 365(+237%)、并发 1 +12%;4K 并发 8 −9%;8K 并发 8 −11%、并发 32 +24%;32K 并发 8 −17%、并发 32 +7%gpu-tpu-pedia SGLANG-K3-RUNBOOK.md §11.0.3 :1010-1023、宽表 :921-938;百分比本课推导
DCP 让 KV 容量 1.5M → 12.2M token(官方逻辑容量);单流 −26% 来自丢掉 symm-mem;TP8 默认配置不开投机实测 max_total_num_tokens 787,504(约 79 万;128K 宽表 TP8 行均未开投机),开投机降到 637,504(−19%),128K × 8 = 1,048,576(100 多万)放不下SGLANG-K3-RUNBOOK.md:721-723;:1024-1026、:962;实测值 :1171、未开投机见宽表 :934-938;乘积本课推导
K3 128K 并发 8 首字中位:TP8 调优档(ratio 0.6)32.1 s、默认档 39.3 s,DCP8 2.3 s(含排队);官方 PD 吞吐:1P1D(TP8 decode)2,808 对 2P2D(DCP8 decode)2,633 tok/s/GPUSGLANG-K3-RUNBOOK.md:939(TP8 r060-isl128k)、:940(默认 0.86)、:941(dcp8-isl128k);:609-610、:707-708(官方原文引于 :1323)
69 层 KDA 的状态池 DP、EP、DCP 都不切(DCP 只按 token 位置切 MLA 的 KV);切了状态差 58%SGLANG-K3-RUNBOOK.md:725-726;58% 为本课玩具递推 St = 0.9·St−1 + 1
L83 · 7.3 并排表:8 颗 v7 = 16 个 device、128K;每 device 可用 94.75 GiB × 0.9 = 85.3 GiB;权重全切 39.1 GiB、剩 46.2 GiB;DEP 每 device 存非专家整份 17.1B(15.9 GiB)+ 路由专家 1/16(38.1 GiB)= 54.0 GiB、剩 31.3 GiB;装几条:TP16/TEP16 5、DEP16 48(每 device 3)、TEP16+DCP16 86;每层读权重(MoE 层)118/784/673 MB,读 KV 755/453/812 MB;一步读完下限 14.4/20.6/24.1 ms;碰到的路由专家 37.6/200.2/239.3 个本课推导:非专家 = 671.0B − 653.9B;一条 128K = 70,272 × 131,072 B = 8.58 GiB、每层 1,152 × 131,072 B = 151 MB;碰到的专家 256 × [1 − (1 − 8/256)b](1.2 同式);下限 = 每 device 每步字节 ÷ 3.685 TB/s(7.37 ÷ 2);94.75 GiB 与 0.9 同 4.1、10.2;逐项 assert 在 topic06_s7.py 的 _t76()。通信次数:TP 前向每层 2 次 all-reduce 见 Megatron-LM(arXiv 1909.08053);TEP 两次 AllReduce 沿用专题五 fig5-tep-dep 图注;DEP 两次 all-to-all 见 6.9 台账;DCP 每层 3 次沿用 7.1 正文(来源见下一行专题五台账);DCP 度数 ≤ TP ÷ KV 头数沿用 7.1
KV 复制;DCP 通信;PCP/DCP 分工;Ring/Ulysses/USP;pass-KV/pass-Q 按通信能否藏进注意力计算来选(10% 未命中仍选 pass-KV,低于 3.25% 才换 pass-Q)沿用专题五台账第 23、29、45、21 行;arXiv 2411.01783 §3.4、§4.2.4
KV 传输软件栈github.com/ai-dynamo/nixl;github.com/kvcache-ai/Mooncake;LMCache arXiv 2510.09665;docs.nvidia.com/dynamo 的 KVBM;github.com/google/tpu-sync(~200 GB/s,not yet recommended for general use);tpu-inference kv_transfer(jax.experimental.transfer)
PD 传输带宽从 200 MB/s 调到 7–167 GB/sVLLM-V4PRO-RUNBOOK.md:194,配置见 :106、180-194
Qwen3-Coder 一条 8K 请求 KV 1.04 GB;各链路传完要 5,201/149/6.2 ms本课推导:2 × 62 × 8 × 128 × 8192 字节(FP8);83 ms 与 PCIe 数沿用专题五台账第 25 行
scale-out 网卡:A4X(GB200)每 GPU 400 Gbps(每节点 4 GPU、4×CX-7 400G);A4X Max(GB300)每 GPU 800 Gbps(CX-8 双端口);1.04 GB KV 一趟约 21 ms/10 msgpu/a4x/01-environment-setup/README.md:35;gpu/a4x-max/05-rdma-test/README.md:197-200;时间 = 1.04 GB × 8 ÷ 400 或 800 Gbps 本课推导
Qwen3.5 混合模型 PD:45 层 GDN + 15 层注意力,每请求传输约 349 MB(未分解);单请求吞吐是单机的 0.95 倍(单并发)/0.92 倍(4 并发)tpu_connector_hma.py 注释;349 MB 见 README-TPU-VM.md:867;Qwen3.5 README:375-389;README-TPU-VM.md:859-867
PD 踩坑清单SGLANG-V4PRO-RUNBOOK.md:941、:63;VLLM-V4PRO-RUNBOOK.md:760、:106、:703、§12.4
跨数据中心 PD:链路 33.35/8.25/59.93/4.66 Gbps;案例 +54%、P90 −64%、同等成本约 +15%、比不调度的朴素异构 +32%、13 Gbps(论文吞吐模型推算)、阈值 19.4K;案例为 32 张 H200 做 prefill + 64 张 H20 做本地 PD,对比 96 张 H20 同构 PDPrFaaS,arXiv 2604.15039 Table 3 与案例节;整条跨集群以太网约 100 Gbps 为论文 §4 案例节直接给出(§4.4 亦写「13 Gbps 占 100 Gbps 以太网的 13%」)
P:D 配比公式:87.5 req/s、要 71.7 万 tok/s prefill、一台 7.28 万,约 9.8 台SGLANG-V4PRO-RUNBOOK.md §12.2 :1082-1091
runbook 实测单 prefill 卡峰值 15,196 input tok/s,是官方单卡值 18,200 的 83%;官方高并发配方 high-conc-8p1d 用 8 个 prefillSGLANG-V4PRO-RUNBOOK.md:1119(15,196 = 官方 83%)、:1091(18,200,runbook 按官方值取,未注明更原始的出处)、:1091/:1101(high-conc-8p1d);83% = 15,196 ÷ 18,200 本课推导
B200 1P1D → 2P1D:输出 1,118.8 → 1,159.0,每卡 69.9 → 48.3,TTFT 2.40 → 1.73 s(−28%),P99 12.07 → 6.23gpu-tpu-pedia gpu/inference/a4/deepseek-v3/REPORT-2P1D-DeepSeek-V3.md :69、:85、:100-142;cuda graph 说明 REPORT-1P1D :129
固定并发压测下每个请求约 65 sREPORT-2P1D-DeepSeek-V3.md 的 Avg Latency 列,并发 128:2P1D 65.5 s(:69)、1P1D 67.2 s(:85)
prefill 台数扫描(扫到 14 个 prefill):12 个时按每张 decode 卡算 307 → 3,187,10.4×;按全部卡算 204 → 455,2.2×VLLM-V4PRO-RUNBOOK.md §12.3;全卡 = output ÷ (4n+8) 本课推导
MiMo batch 128:同样 2 个 pod,1P1D 13.64K 对不分离 12.78K,+6.7%(README 写约 6.8%);2P1D 用 3 个 pod 到 15.31K,按 pod 算 5.10K 对 6.39K,低 20%;按 pod 另算 batch 64 不拆/1P1D/2P1D 5.85/5.28/3.61K、batch 128 的 1P1D 6.82K;Qwen3-Coder 1P1D TTFT 95 → 281 mstpu/sglang-jax/mimo/README.md:8-12、81-88;6.7%、按 pod 各值(总吞吐 ÷ pod 数)与 20% 本课推导;tpu/tpu-inference/Qwen3-Coder-480B/README.md:1005-1021
AFD:MegaScale-Infer 每卡吞吐 1.90×、Step-3 4,039 对 2,324;vLLM AFD 插件 16K/32K 实测;EPD 把多模态编码再拆出去(15×、22×、71%)概念沿用专题五台账第 24、51 行;arXiv 2504.02263;arXiv 2507.19427;vllm.ai/blog/2026-07-23-vllm-afd-plugin、github.com/vllm-project/afd-plugin(RFC #22799 于 2026-05-31 关闭);EPD arXiv 2501.05460;Step-3 对 V3 不是同一模型,差距含模型侧设计,正文已注明;2,324 是 DeepSeek 自己公开的 H800 profile 峰值,经 Step-3 论文表 8 引用;4,039 是峰值那一分钟、用了 FP8 注意力,长期平均 3,910
同一模型五种部署 14,563/16,459/21,100/55,153/65,132;调参 +45%,换拓扑 +347%(并发 1,536)VLLM-V4PRO-RUNBOOK.md:446、448、449、465、468;:489(另 :476 的 2.47× 为 DEP 并发 1,536,正文 2.09× 同为 512;:487 的 +28%)
每卡 1,820/1,319/3,257;对 1p1d 起点 1.79×本课推导:总吞吐 ÷ 卡数
Qwen3-Coder TP16:跨 DCN c=1 −22%、c=16 −63%;同 ICI 切片 −15~−21%(c=16 总 513.8 对单机 602)Qwen3-Coder-480B/README-multinode.md:441-445;README-TPU-VM.md:1000-1009
V4-Pro dep8 要一整柜 NVL72;拓扑与频率的一般讨论SGLANG-V4PRO-RUNBOOK.md:34、:63;沿用专题五台账第 19、26 行
v7x-8 是 4 颗芯片(名字按 device 数);mesh 构造tpu/tpu-inference/README.md:41;JAX mesh_utils 文档
v7 每 device 实测可用 94.75 GiB(每 device 物理 96 GiB);R1 FP8 MoE 每 device 101.8 放不下(README 写 GB,按 GB、GiB 读都超,最少也超 0.06 GB)tpu/tpu-inference R1 FP4 README:59、72-73;0.06 = 101.8 − 101.74(94.75 GiB 换成 GB)本课推导
路由专家 FP8 均摊到 8 个 device 只有约 81.7 GB,比 README 的 101.8 多出约 20 GB本课推导:653.9B × 1 B ÷ 8 = 81.7 GB(= 76.1 GiB,拓扑图脚注同此);101.8 − 81.7 ≈ 20
v7 切片按 4、8、16、32 颗成档(2x2x1、2x2x2、2x2x4、2x4x4),4.07 颗取 8Google Cloud TPU7x 文档 Supported configurations 表(cloud.google.com/tpu/docs/tpu7x)
V3 FP8 切片表(按 device 记账):4K×64 要 642 GiB/纸面 7.53 → 8 device(4 颗),4K×256 要 694 GiB/8.13 → 16 device(8 颗),128K×256 要 2,821 GiB/33.08 → 64 device(32 颗),KV 是权重 3.5×;8 个 device 放完权重共剩 57 GiB(每 device 约 7.2 GiB),4K 纸面装 213 条,但实测 FP8 放不下本课推导:权重 671 GB = 625 GiB;每 device 94.75 GiB × 0.9 = 85.275 GiB 可用(一颗芯片=两个 device,不当整块用);0.9 为本课假设;实测见上一行
128K × 256 并发:DeepSeek-V3 KV 约 2,196 GiB(权重 625 GiB 的 3.5 倍);单条 128K 8.58 GiB本课推导:70,272 B × 131,072 × 256 ÷ 230
GB300 R1:并发 8 只用上 ~3% 容量;854 → 10,715 tok/s,12.5×;并发 256 → 512 总吞吐只再涨 3%(10,390 → 10,715,本课推导),首字 12 s → 30 sgpu-tpu-pedia gpu/inference/a4x-max/deepseek-v3/sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md :401、:405-413、:415
投机解码原理(按标准拒绝采样实现时分布无损)Leviathan 等 arXiv 2211.17192;Chen 等 arXiv 2302.01318
K3 开投机:TPOT 11.1 → 2.31 ms,接受长度 6.96;一步变慢 1.45×,每字快 4.81×SGLANG-K3-RUNBOOK.md:1089、:979;本课推导:2.31 × 6.96 ≈ 16.1 ms,16.1 ÷ 11.1 ≈ 1.45,11.1 ÷ 2.31 ≈ 4.81
并发升高收益收窄:4.22× → 1.74×;32K 只剩 1.32×;不开投机时每字间隔 4K 11.1 ms、32K 11.4 ms;32K 变慢的三条原因(验证撞算力墙、草稿也读长 KV、接受率可能降)为本课推导,未拆分SGLANG-K3-RUNBOOK.md:1089-1092、:1057-1058、:924、:935(c1 TPOT);DSpark 草稿块 7 个::373
V3 batch 8 一步要读的字节是 batch 1 的 4.4×本课推导:均匀路由下命中专家 8 → 57.5 个,37.5 → 163.8 GB
B200 V4-Flash(vLLM,DEP8)开 MTP 反而降 3–37%gpu-tpu-pedia gpu/inference/a4/deepseek-v4/README.vllm.md:265-277
V4-Pro MTP:峰值 −13%,端到端 +28%SGLANG-V4PRO-RUNBOOK.md:900-911
temperature 与接受率(V4-Pro 贪心 DSpark 草稿在温度 1.0 下实测 1.16%);K3 4.73/2.61;1.16% 低于单字理论值:接受率 = 收下 ÷ 猜的草稿字、每步猜 7 个、第一个被拒后面作废VLLM-V4PRO-RUNBOOK.md:398-410(num_speculative_tokens=7、接受率 = accepted ÷ draft 均为原文;低于理论值的解释为本课推导,未拆分);VLLM-K3-RUNBOOK.md:226-237;告警见 kimi-k3/PD-BACKLOG.md:175
PD 碰上投机解码:新交接请求 1 个 token 对 1+N,掉出整图 CUDA Graph、退回 piecewise 或 eager;补齐后 TPOT ~40 → ~22 msvLLM 博客 vllm.ai/blog/2026-07-23-glm-5.2-nvfp4-b300-pd;转述见 kimi-k3/PD-BACKLOG.md:52-59
草稿模型谱系(MTP、DSpark 的定义;V3 的 MTP 是一整层 transformer,共享 embedding 和输出头;EAGLE-3 2025-03 融合多层状态,SGLang batch 64 吞吐 1.38×;DSpark 摘要:吞吐相同时单用户生成比线上 MTP-1 快 60–85%)SpecInfer 2305.09781、Medusa 2401.10774、EAGLE 2401.15077/2406.16858、MTP 2412.19437、EAGLE-3 2503.01840、DSpark 2607.05147、Lookahead 2402.02057、SuffixDecoding 2411.04975、DiffuSpec 2510.02358、DFlash 2602.06036(均 arXiv);github.com/apoorvumang/prompt-lookup-decoding;MTP 结构见 DeepSeek-V3 技术报告 §2.2 MTP Modules;EAGLE-3 摘要页(v1 2025-03-03)。2026-10-15 核对
8 颗 v7 读一遍 V3 激活权重:BF16 1.26 ms、FP8 0.63、MXFP4 0.33、NVFP4 0.35本课推导:37e9 × 位数 ÷ 8 ÷ (8 × 7.37 TB/s)
MXFP4 每 32 个数一个 E8M0 scale(只能取 2 的幂),合 4.25 bit;NVFP4 每 16 个一个 E4M3(可取非 2 的幂),合 4.5 bitOCP Microscaling Formats (MX) v1.0 规范;NVIDIA 技术博客「Introducing NVFP4」
v7 公开规格只列 BF16、FP8 峰值,没写 FP4 算力Google Cloud TPU7x 公开规格页
V4 专家权重为 FP4Hugging Face DeepSeek-V4 模型卡
R1 FP4 每 device 60.9,FP8 101.8 放不下(README 写 GB);上限 94.75 GiB(运行日志单位);K2.6 INT4 存成无符号 0–15,加载时直接当有符号读(没减 8)就崩R1 FP4 README:59、72-73、:875-878(README 实测值);K2.6 README:217、:265-266
kernel 气泡:H100 理想 1,350 次前向/秒,实际 770;megakernel 带宽利用 50% → 78%,比 vLLM 快约 2.5×、比 SGLang 快 1.5× 多;Llama-3.2-1B、batch 1,小模型小 batch 收益最大;PDL 同步粒度太粗hazyresearch.stanford.edu/blog/2025-05-27-no-bubbles;1,350 = 3.35 TB/s ÷ 2.48 GB 本课推导
Mirage MPK 编译成 megakernel:端到端推理延迟最多低 1.7×(对逐算子 kernel 的服务系统);2025-06 开源,论文 2025-12arXiv 2512.22219(v1 2025-12-22);github.com/mirage-project/mirage(2025-06-19 公开,作者博客「Compiling LLMs into a MegaKernel」)
TPU megakernel:16 颗 v7 单用户 700+ tok/s,对照 GB200(vLLM)452,两边都按接受长度 6 换算;一步 ~8.5 ms,编译 <90 s;(博客另报不开投机 batch 1–8 约为 GB200 基线 1.4–2×,课件 L87 起不引);博客写的是 megakernel + DSpark 投机,未提量化https://inferact.ai/blog/tpu-megakernels(2026-09-23;博客图注「Output tokens per second with speculative decoding at an acceptance length of 6」同时覆盖两条曲线);6 ÷ 8.5 ms ≈ 706 本课推导
KV 存 FP8:FlashMLA 给 V3.2 的布局每 token 每层 656 B(512 个 FP8 + 4 个 FP32 缩放 + 64 维 BF16 RoPE 不量化),是 BF16 1,152 B 的 57%;DSA 每 token 每层另有 indexer key 132 B(128 个 FP8 + 1 个 FP32 缩放,BF16/FP8 KV 下都存 FP8),合计 788 B 对 1,284 B(61%),请求容量约是 BF16 KV 的 1.63 倍;K3 Peak Throughput 预设 --kv-cache-dtype fp8_e4m3 必开(BF16 KV 装不下每副本 128 个请求)github.com/deepseek-ai/FlashMLA README(2026-09-30 提交 2e5429f 之前的版本,「FP8 with scale」一节;现版只剩 V4.1 的 528/288 B 格式);HF deepseek-ai/DeepSeek-V3.2 config.json(index_head_dim 128);DeepSeek-V3.2-Exp inference/model.py(k_cache float8_e4m3fn、k_scale_cache float32 × head_dim÷128);vLLM deepseek_v2.py Indexer(head_dim+head_dim÷128×4,dtype uint8);SGLang memory_pool.py DSATokenToKVPool(index_k_with_scale_buffer_dtype=uint8);本课推导 656 ÷ 1,152、788 ÷ 1,284、1,284 ÷ 788;SGLANG-K3-RUNBOOK.md:1308
分桶浪费:一步整批 token 总数只补到一个 8K 桶时浪费 87.3%,32 个桶 10.8%;13 个按 √2 递增的档 16.0%、16 个等距 512 的档 19.7%;补齐按整批总数(RPA ragged 布局),单条请求不补本课推导:每步 token 总数取对数正态,中位 700、σ 0.9;RPA arXiv 2604.15464;预编译参数 mimo README:269-270
新形状首个请求现编译 60–90 s,之后同形状 <1 s;预编译开关Qwen3.5 README:794;mimo README:269-270
14.2:强杀后每卡显存仍占 97 GB、只剩 187 GB,mem-fraction-static 0.85 要静态占 241 GB(权重+KV 池),差 54 GB,下次启动 OOM;从删 pod 到显存清零实测 56 秒SGLANG-V4PRO-RUNBOOK.md:960-978(97 GB 在 :962-963,算式 :966,56 秒 :978);284 × 0.85 ≈ 241、284 − 97 = 187、241 − 187 = 54 本课推导
冷启动拆账:GLM-5.1 名义加载里藏 6 分 29 秒重编译(原表总计 ~10 分 44 秒,分项和 10 分 29 秒);Qwen3-Coder 40 分钟里编译 29;MiMo-V2.5-Pro 编译 15 + 预热 7(原表总计 ~50 分钟,分项和 52 分钟)GLM-5.1 README:470-476;Qwen3-Coder README-TPU-VM.md:1011;MiMo-V2.5-Pro README:184-188
R1 加载 215.7 → 21.4 s(1,367 个张量只有 25 种形状);K2.6 57 分钟 → 6 分 8 秒(9.3×);持久编译缓存R1 README:1202-1223、:1238-1259;K2.6 README:23、39-40;JAX 文档「Persistent compilation cache」
KV 感知路由:命中缓存首字 340 ms,不路由的最坏情况 2,850 ms(原文 worst case,与冷推理同值),命中率 87.4%(4,176/4,776)Red Hat Developer 2025-10-07「Master KV cache aware routing with llm-d」
JetStream 停止维护:核心功能并入 tpu-inference、宣布 2026-02-01 起归档,最后提交 2026-01-05;截至 2026-10-15 仓库 archived 标记仍为 falsegithub.com/AI-Hypercomputer/JetStream README 公告与提交记录,2026-10 核对
同等 GPT-3.5 水平推理价格 2022-11 → 2024-10 降 280 多倍,主要归给小模型斯坦福 HAI《AI Index Report 2025》
llm-d 分层卸载(TPU7x、Qwen3-32B,KV 卸到主机内存):平均 TTFT 0.98 → 0.56 s,P90 TTFT 2.1 → 0.5 s,输入输出合计吞吐 67,262 → 73,178 tok/s(+8.9%)llm-d/llm-d@accc6c5:guides/tiered-prefix-cache/README.md:436-439(HBM-only 对 HBM + CPU RAM 那张表,2026-06-11 随 #1561 加入,故 15.3 表记 2026)。2026-10-15 核对
Kimi K2 Thinking:QAT、MoE 原生 INT4,生成约快 2 倍Hugging Face 模型卡 moonshotai/Kimi-K2-Thinking
年份:GPTQ 2022、Splitwise 2023;批不变 kernelarXiv 2210.17323;arXiv 2311.18677;Thinking Machines 博客「Defeating Nondeterminism in LLM Inference」
Mooncake 对 NIXL:并发 64 输出 1,333 对 1,693 tok/s;SGLang R1 改走 Mooncake NVLink 后跑通,K3 的 PD 尝试同样选 mooncake,但 3 次尝试均受阻(PP8 head 比值 → decode 自毙 → 集群删除)未跑通VLLM-V4PRO-RUNBOOK.md:705;sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md:57、:570;SGLANG-K3-RUNBOOK.md:1286-1291、:1049
14 台 prefill 扫描 6,788/8,809/8,993;14 台全崩、注册表仍显示 14SGLANG-V4PRO-RUNBOOK.md:43、1117;同文约束 #8
Qwen3-Coder +12%Qwen3-Coder-480B/README.md:1005-1021
K3:KV 池 787,504 → 637,504;max-running 回调到 48;PD 下 decode 每请求一个状态槽SGLANG-K3-RUNBOOK.md:1171、:76、:1318
R1 传输程序缓存:1 分 48 秒对 3 分 17 秒~3 分 51 秒R1 FP4 README:1237-1250
K2.6 共享存储每层读取慢 38 倍;V4-Pro 806 GB 权重放本地 SSD RAID,读 14 GB/s,估算加载不到 1 分钟K2.6 README:259;gpu/inference/a4x-max/deepseek-v4/README.md:55(806G、14 GB/s、< 1 min)、SGLANG-V4PRO-RUNBOOK.md:35、:91(806G)、gb300-local-ssd-raid0-SETUP.md:111(800G 估 ~57 s);806 ÷ 14 ≈ 58 s 本课推导
14.2 栈对比表tpu-inference 支持矩阵;SGLang-JAX 模型列表
上下文变长:GPT-4 Turbo 128K(2023-11-06),Gemini 1.5 Pro 1M 私有预览(2024-02-15)openai.com/index/new-models-and-developer-products-announced-at-devday;blog.google「Our next-generation model: Gemini 1.5」。2026-10-16 核对
Mooncake:Kimi 线上在 A800、H800 集群比此前系统多接 115%、107% 请求;真实 trace 下有效请求容量比基线 +59%~498%(2024 预印本摘要的 75%、525% 已由正式版替换)FAST'25 论文页 usenix.org/conference/fast25/presentation/qin(「enables Kimi to handle 115% and 107% more requests on NVIDIA A800 and H800 clusters, respectively, compared to previous systems」)
DeepSeek 磁盘缓存:命中按十分之一计价;128K 高复用 prompt 首字 13 s → 0.5 s(≈ 1/26 本课推导);24 小时 6,080 亿输入 token 里 56.3% 命中磁盘 KVapi-docs.deepseek.com/news/news0802(2024-08),价格只取比例;6,080 亿/56.3% 取自 github.com/deepseek-ai/open-infra-index 202502OpenSourceWeek day_6(统计窗口 2025-02-27~28,608B 中 342B 命中)。2026-10-15 核对
PagedAttention 同延迟吞吐 2–4×(对 FasterTransformer、Orca)arXiv 2309.06180 摘要
Medusa-1 2.2×、Medusa-2 2.3–3.6×(正文合写 2.2–3.6 倍)arXiv 2401.10774 摘要
AI Index:硬件成本每年降 30%、能效每年升 40%Stanford HAI AI Index 2025 要点第 7 条
Hopper 张量核支持 FP8;DeepSeek-V3 FP8 混合精度训练NVIDIA H100 发布(2022-03);arXiv 2412.19437 §3.3
第十五节八问的顺序本课归纳
R16 补充:FlashAttention 2022;FlashInfer MLSys 2025;DeepSeek-V3.2-Exp(2025-09)的 DSA 每字读 2,048 个 token、API 降价五成以上(2,048 见 V3.2 报告 §2.1);NVFP4 KV 省约一半、损失 <1%、命中率 +20%、首字延迟最多降到约三分之一;LMCache 15 倍、截断让命中率减半;SGLang(含 RadixAttention)6.4 倍(对当时其他推理系统);投机解码 2–3 倍;GQA 每层 4,096 B ÷ MLA 1,152 B ≈ 3.6(本课推导;按每层,按每 token 是 327,680 ÷ 70,272 ≈ 4.7,因层数 80 对 61,第十五节表只给每层口径);Ring 2023-10、Ulysses 2023-09、Meta CP 2024-11;Kimi K2 Thinking「low-latency mode」arXiv 2205.14135、2501.01005;api-docs.deepseek.com/news/news250929、arXiv 2512.02556;developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache;arXiv 2510.09665、2312.07104、2211.17192、2310.01889、2309.14509、2411.01783;huggingface.co/moonshotai/Kimi-K2-Thinking。2026-10-16 核对
R18 补充:DeepSeek-V4 的 CSA 每 4 个 token 压成一条 KV、HCA 每 128 个压成一条,另留最近 128 个 token 的滑窗 KV;CSA 层再由索引器从压缩条目里挑 top-k 读,HCA 层不挑(4.1「存和读都改」);DeepSeek 一天的 token 近八成是输入(6,080 ÷ 7,760,本课推导);226.75 节点 × 8 卡 ≈ 1,814 卡(本课推导)DeepSeek-V4 技术报告 §2.3(CSA/HCA「every m tokens into one entry」);Hugging Face deepseek-ai/DeepSeek-V4-Pro config.json 的 compress_ratios(4/128)、sliding_window 128 与 index_topk;VLLM-V4PRO-RUNBOOK.md:300(「CSA…再由索引器挑 top-1024」「HCA…不挑」);open-infra-index day_6
R21 补充 · 0.1:o1 2024-09 发布,先想再答(思维链);DeepSeek-R1 2025-01,原文「ranges from generating hundreds to thousands of reasoning tokens」openai.com/index/learning-to-reason-with-llms(2024-09-12);arXiv 2501.12948 §2.2.4
R21 补充 · 4.3 / 3.3 / 15.3:vLLM V1 前缀缓存 V0 默认关(命中率低时 CPU 开销拖慢)、V1 改数据结构后命中率 0% 时吞吐降不到 1%、默认开;V1 吞吐最多 1.7 倍(对 V0,原文注明不开 multi-step scheduling);V1 的 EngineCore 进程只跑调度和模型执行,分词、多模态输入处理、反分词、流式回传与之重叠blog.vllm.ai/2025/01/27/v1-alpha-release.html(博客日期 2025-01-27,见 URL 与页内署日;「less than 1% decrease in throughput even when the cache hit rate is 0%」「up to 1.7x higher throughput compared to V0」)。2026-10-15 核对
R21 补充 · 3.3 / 6 / 14.3 / 15.3:SGLang v0.4(2024-12)零开销调度吞吐 1.1 倍;DeepSeek 模型的 DP attention decode 吞吐最多 1.9 倍;cache-aware 路由命中率 20% → 75%、吞吐 82,665 → 158,596 tok/s(≈1.9 倍;原文表头是 v0.3 对 v0.4,测试负载为多组长前缀、各组完全均衡)lmsys.org/blog/2024-12-04-sglang-v0-4(「1.1x increase in throughput」「up to 1.9x decoding throughput improvement」;1.9 = 158,596 ÷ 82,665 本课推导,原文也写 up to 1.9x)
R21 补充 · 4.4:SGLang HiCache(2025-09)三层分层缓存,后端 Mooncake、3FS、NIXL;长上下文与多轮对话基准吞吐最多 6 倍、TTFT 最多降 80%(博客未写明对照组)lmsys.org/blog/2025-09-10-sglang-hicache(「up to 6× throughput improvement and up to 80% reduction in TTFT」)
R21 补充 · 第八节:NVIDIA Dynamo 2025-03-18 开源,含 PD 分离、KV 感知路由(Smart Router)、KV 下放(Memory Manager);传输库 NIXLnvidianews.nvidia.com/news/nvidia-dynamo-open-source-library-accelerates-and-scales-ai-reasoning-models;NIXL 名字见 NVIDIA 技术博客「NVIDIA Dynamo, A Low-Latency Distributed Inference Framework for Scaling Reasoning AI Models」
R21 补充 · 14.3:llm-d 2025-05-20 发布,含 AI-aware 路由(送到最可能有热缓存的服务器)redhat.com 新闻稿「Red Hat Launches the llm-d Community」(Boston,2025-05-20)
R21 补充 · 11.3 / 15.3:EAGLE-3 加速比最多 6.5 倍(对普通自回归),SGLang 中 batch 64 吞吐 1.38 倍arXiv 2503.01840 摘要(「speedup ratio up to 6.5x」「1.38x throughput improvement at a batch size of 64」)
R21 补充 · 12.1:vLLM FP8 权重(2024-07),Llama 3 70B 每字间隔最多降到未量化(16 位;原文没写对照精度,图注为 FP16 server)的 1/2、Mixtral 8x7B 最多降到 1/1.6(2×H100;原文「2x/1.6x ITL improvement」,按时间比读)developers.redhat.com/articles/2024/07/15/vllm-brings-fp8-inference-open-source-community(「Up to 2x ITL improvement for serving dense models」「Up to 1.6x ITL improvement for serving Mixture of Experts」)
R21 补充 · 12.1「MoE 赚得少」:只有读权重那份减半时,加速 = 1 ÷ (1 − f/2),f 为读权重占一步的比例;2 倍要 f ≈ 100%,1.6 倍对应 f ≈ 75%。MoE 每步只读选中的专家,权重字节少,KV、通信、kernel 调度这些不随位数变的部分占比就高,f 低本课推导、推测(Red Hat 原文未给原因;12.1 正文按推测语气写)
R21 补充 · 12.4:NVFP4 KV 比 FP8 KV 缓存命中率高 20%、首字延迟最多降到约三分之一(Qwen3-Coder-480B-A35B 上分析)developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache(「up to 3x lower latency and 20% higher cache hit rate compared to FP8 KV cache」)
R21 补充 · 15.3:固定一档能力,达到它的推理每年便宜 9 到 900 倍、中位 50 倍;去掉 2024 年 1 月前的数据后中位升到每年 200 倍。与第八到十二节招数进生产时间重合是本课观察,Epoch 未归因epoch.ai/data-insights/llm-inference-price-trends(2025;「between 9x per year and 900x per year, with a median of 50x per year」「the median rate increased from 50x per year to 200x per year」)
R21 补充 · 15.3:DeepSeek-V3.2-Exp 相对 V3.1-Terminus 唯一的结构改动是 DSA;lightning indexer 仍对全部历史打分(O(L²) 但头少、可跑 FP8),主注意力每个 query 只取 top-k = 2,048 个 KV,核心注意力复杂度 O(L²) → O(Lk)DeepSeek-V3.2-Exp 技术报告(github.com/deepseek-ai/DeepSeek-V3.2-Exp,DeepSeek_V3_2.pdf §2.1、Inference Costs 一节);Hugging Face 模型卡(「builds upon V3.1-Terminus」)
R25 补充 · 0 / 4.1:DeepSeek-V4-Pro、V4-Flash 2026-04 发布(预览版);V4.1-Flash 2026-09-10 开源,552B 主干;CSA2 让各层共用主 KV 和索引 K,主 KV 存 FP4(E2M1,每 16 通道一个 E4M3 缩放),全局 KV 每 token 890 B,约 V4-Flash 的 1/4huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash(「share main KV and indexer K across layers」「reduce the global KV cache footprint to 890 bytes per token — roughly 1/4 of DeepSeek-V4-Flash」;HF 建库时间 2026-09-10);huggingface.co/deepseek-ai/DeepSeek-V4-Pro(「a preview version of DeepSeek-V4 series」;建库 2026-04-22)
R25 补充 · 12.4:FlashMLA 新增读 NVFP4 压缩 KV 的 kernel,比原先的 FP8 KV 小 45%vllm.ai/blog/2026-10-07-deepseek-v41-flash(「a new NVFP4 compressed KV format, which is 45% smaller than the previous FP8 KV cache」)
R25 补充 · 4.4:vLLM 0.11.0 起自带 KV 下放连接器(OffloadingConnector),附 CPU 后端vllm.ai/blog/2026-01-08-kv-offloading-connector(「introduced in vLLM 0.11.0」「bundled with a CPU backend, enabling native CPU offloading of KV data in vLLM」)
R25 补充 · 第八节:NVIDIA Dynamo 1.0 正式版 2026-03-16 发布nvidianews.nvidia.com/news/dynamo-1-0(「NVIDIA Enters Production With Dynamo」,2026-03-16)
R25 补充 · 11.3:DFlash 一次前向出一整块候选草稿;Gemma-4 31B 在单卡 DGX B300 上用 vLLM,单并发比自回归快 3.0(MT-Bench)–5.8 倍(Math500);SGLang 上 Qwen3-8B 单卡 B200 最多 5.1 倍developer.nvidia.com/blog/boost-inference-performance-up-to-15x-on-nvidia-blackwell-using-dflash-speculative-decoding(2026-06-23,表 2、表 3;「generates an entire block of candidate tokens in a single forward pass」)
R32 补充 · 5.1:Flash-Decoding 的 8 倍是 CodeLlama-34B、batch 1、序列 512 到 64k 的 decode 速度,对照为纯 PyTorch 注意力、FlashAttention v2(2.2 前)、FasterTransformer;注意力本身最多是 FlashAttention 的 50 倍crfm.stanford.edu/2023/10/12/flashdecoding.html(「Flash-Decoding unlocks up to 8x speedups in decoding speed for very large sequences」「the attention itself is up to 50x faster than FlashAttention」)
R32 补充 · 第八节:Splitwise 同成本同功耗下吞吐最多 2.35 倍,或吞吐最多 1.4 倍、成本低 20%(对不拆阶段的现有集群设计)arXiv 2311.18677 摘要(「Splitwise clusters achieve up to 1.4× higher throughput at 20% lower cost. Alternatively, they can deliver 2.35× more throughput under the same power and cost budgets.」)
R32 补充 · 第十二节:GPTQ 3 bit OPT-175B,batch 1 逐字延迟 1 张 A100 71 ms 对 FP16 5 张 230 ms(3.24×,正文按原文取 3.25);2 张 A6000 130 ms 对 FP16 8 张 589 ms(4.53×)arXiv 2210.17323 表 6(「the 3-bit OPT-175B model obtained via GPTQ running on a single A100 is about 3.25× faster than the FP16 version (running on 5 GPUs) in terms of average time per token」)
R44 补充 · 4.3 / 3.3 / 9.4 / 12.1 / 12.4:vLLM V1 alpha 公开于 2025-01(4.3「2025 年 1 月」、3.3「2025 年」);MegaScale-Infer 首版 2025-04-03(9.4「2025 年」);Kimi K2 Thinking 2025-11 发布(12.1「2025 年」);NVFP4 KV 首字延迟「最多降到约三分之一」即原文 up to 3x lower latency;V3.2 FP8 KV 同显存多接六成多请求 = 1,284 ÷ 788 ≈ 1.63 减 1(本课推导,同第 116 行)blog.vllm.ai/2025/01/27/v1-alpha-release.html(2025-01-27);arXiv 2504.02263 提交历史 v1「Thu, 3 Apr 2025」;huggingface.co/moonshotai/Kimi-K2-Thinking(HF API 仓库 createdAt 2025-11-04,首次 README 更新 2025-11-06;第三方报道均记 2025-11-06 发布,正文只写年份);developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache 图 4 注「NVFP4 KV cache delivers up to 3x lower latency and 20% higher cache hit rate compared to FP8 KV cache」、正文「up to 3x better time-to-first-token (TTFT) latency」。2026-10-15 核对
R49 补充 · 1.1 图注:b = 64 时专家覆盖率 87%、每人分到权重 9.14 GB本课推导:第 19 行公式取 b = 64,覆盖率 = 1 − (31/32)64 ≈ 0.87,[非路由 + 653.9B × 0.87] ÷ 64 ≈ 9.14 GB;脚本断言见 topic06-fig-phases.py:93
R49 补充 · 第四节:MHA(2017);Qwen3.5 混合池块编号池算大约 3.5 倍;V3 一条 64K 序列 KV ≈ 4.29 GiB、FP8 每 token 40,016 字节arXiv 1706.03762(Attention Is All You Need,2017-06);tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:77(「block_id pool ~3.5× 过大」);本课推导:70,272 B × 65,536 ÷ 230 ≈ 4.29 GiB,656 B × 61 层 = 40,016 B
R49 补充 · 第三节:mem-fraction 调高后端到端吞吐只多 0.8%;Gemma4 256K 的 prompt 切成 16 块本课推导:10,704 ÷ 10,614 ≈ 1.008(两数同第 36 行);tpu/tpu-inference Gemma4-31B README.md:224-226(max-num-batched-tokens 16384,「将 256K 拆为 16 个 16K chunk」)
R49 补充 · 第五节:G = 8 时离屋脊 313 差了近 40 倍;MLA 吸收后每头 1,088 次乘加,展开后 320 次,前者是后者的 3.4 倍;潜向量 576 维本课推导:313 ÷ 8 ≈ 39;V3 config kv_lora_rank 512、qk_rope 64、qk_nope 128、v_head 128:576 = 512 + 64,1,088 = 576 + 512,320 = (128 + 64) + 128,1,088 ÷ 320 = 3.4(第 54 行的 278,528 和 81,920 即 1,088 和 320 各乘 256)
R49 补充 · 第六节:TP 从并发 256 到 512 只涨 3%(4,130 → 4,266);图中 c=512 TP 4,266、DP 6,914github.com/vllm-project/tpu-inference/pull/2577 正文表(in 1k/out 8k:c=256 TP 4,130、DP 5,029;c=512 TP 4,266、DP 6,914);3% 为本课推导,4,266 ÷ 4,130 ≈ 1.033
R49 补充 · 第七节:K3 DCP 在输入 4K 各档并发都亏,最多亏 26%(4K 并发 1 −26%、并发 64 −6.8%)SGLANG-K3-RUNBOOK.md §11.0.3 :1010-1023(4K c1 87.8 → 64.7,4K c64 1,511 → 1,409)
R49 补充 · 第八节:recompute 策略下 12 个 prefill 时每卡 3,187 掉到 2,645,约交 17% 的税;SGLang R1 在 GB300 上 NIXL 走 RoCE 不通,单请求 60 s 超时;KV 传输只占 1–2 s prefill 的一成上下VLLM-V4PRO-RUNBOOK.md:760(「17% 的算力税(12p 时 3,187 → 2,645/GPU)」)、表 :715-726;gpu/inference/a4x-max/deepseek-v3/sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md:570;1–2 s 沿用专题五台账第 25 行
R49 补充 · 第九节:平均首字省下 0.67 s;prefill 从 14 到 16 台只涨 2%(8/14/16 台对应 6,788/8,809/8,993)本课推导:2.40 − 1.73 = 0.67 s(两数同第 83 行);8,993 ÷ 8,809 ≈ 1.021(三数同第 129 行)
R49 补充 · 第十节:换切法后每卡反而掉了 28%;GB300 DEP8 理论能扛约 288 个并发本课推导:1,319 ÷ 1,820 ≈ 0.72(两数同第 89 行);sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md:401(「GB300 DEP8 理论可扛 ~288 并发」)
R49 补充 · 第十一节:温度 0 的吞吐 2,911 是温度 1.0 时 944 的 3.1 倍;K3 KV 池少了 19%;B200 V4-Flash 开 MTP 共十档并发本课推导:2,911 ÷ 944 ≈ 3.08(同第 26 行);(787,504 − 637,504) ÷ 787,504 ≈ 19.0%(同第 131 行);十档为 README.vllm.md:267-277 的 c=1、8、40、60、80、100、200、300、400、600
R49 补充 · 第十二节:NVIDIA 2025-12 放出 NVFP4 KV;图注 kernel 交接空等加起来四成多developer.nvidia.com/blog/optimizing-inference-for-long-context-and-large-batch-sizes-with-nvfp4-kv-cache(datePublished 2025-12-08,2026-10-15 核对);本课推导:1 − 770 ÷ 1,350 ≈ 43%(两数同第 113 行)
R51 补充 · 0.1 / 15.3 / 故事图:0.1 各泳道补上的倍数(36.9、2–4、2.6–3.7、1/57、1.63、6.4、107%–115%、7.4、5、2–3、1.8、3.25、2)均为既有台账行的数,原样搬用;15.3 新增 GPTQ 3.25 倍、vLLM FP8 权重 2 倍、V3.2 FP8 KV 1.63 倍三行,并按发表月份重排同年各行;故事图 GPTQ 卡改写 3.25×、Splitwise 卡改写 2.35×;第四节与 15.3 的 DeepSeek 磁盘缓存由计价比例改为首字 13 s → 0.5 s同第 42、138、43、55、116、38、136、28、66、40、164、152、163、137 行
R53 补充 · 4.3:vLLM 前缀缓存按块哈希,每块哈希含父块哈希与本块 token,只认完全相同的前缀;截断上下文能让前缀命中率掉一半docs.vllm.ai/en/latest/design/prefix_caching.html(「we hash each kv-cache block by the tokens in the block and the tokens in the prefix before the block」);LMCache arXiv 2510.09665 摘要(「context truncation … can greatly reduce prefix cache hit ratio by half」)
R53 补充 · 4.4:Mooncake Store 由 Master(空间分配、元数据)与 Client 组成,经 Transfer Engine 走 RDMA,可从内存下放到 SSD,按哈希前缀存取 KV 块;SGLang 2025-09-10、vLLM 2026-05-07 正式接入kvcache-ai.github.io/Mooncake/design/mooncake-store.html(「Powered by the Transfer Engine」「supports offloading cached data from RAM to SSD」「responsible for object space allocation and metadata maintenance」);github.com/kvcache-ai/Mooncake README 新闻栏(「store, retrieve, and reuse KV cache blocks based on hash-based prefix caching」)
R53 补充 · 12.4:FP8 KV 不校准时缩放全取 1.0;校准后可按张量或按 KV 头给缩放,按头只支持 FlashAttention 后端且须经 llm-compressor 校准docs.vllm.ai/en/latest/features/quantization/quantized_kvcache.html(「No calibration (default scales): All quantization scales are set to 1.0」「Per-attention-head quantization is currently available only with the Flash Attention backend and requires the calibration pathway provided by llm-compressor」)
R56 复核 · 3 / 4 / 5.1 / 11 / 12 / 14 / 15.3 / 故事图:SGLang 路由 20%→75%、1.9 倍改记「对 v0.3」;DeepSeek 13 s → 0.5 s 的条件是「128K、高复用 prompt」,正文去掉「大半重复」;megakernel 2.5 倍/1.5 倍是 H100、Llama-1B,B200 上对 vLLM 超 3.5 倍;Flash-Decoding 8 倍、EAGLE-3 6.5 倍与 1.38 倍、llm-d 340/2,850 ms、Orca 36.9× 与原文一致lmsys.org/blog/2024-12-04-sglang-v0-4(「up to 1.9x throughput increase and 3.8x hit rate improvement」,表「Cache hit rate; SGLang v0.3: 20%; SGLang v0.4: 75%」);api-docs.deepseek.com/news/news0802(「For a 128K prompt with high reference, the first token latency is cut from 13s to just 500ms」);hazyresearch.stanford.edu/blog/2025-05-27-no-bubbles(「On an H100, our megakernel runs almost 2.5x faster than vLLM and over 1.5x faster than SGLang」「On a B200, the gap with vLLM rises to over 3.5x」);arXiv 2512.22219(「up to 1.7× lower end-to-end inference latency」);crfm.stanford.edu/2023/10/12/flashdecoding.html(「up to 8x speedups in decoding speed for very large sequences」,batch size 1);arXiv 2503.01840(「speedup ratio up to 6.5x」「1.38x throughput improvement at a batch size of 64」,表 3 基线为不投机的 SGLang,H100、LLaMA-3.1 8B);Red Hat Developer 2025-10-07(「Warm cache hit; Without cache routing: 2,850 ms TTFT (worst case); With KV cache routing: 340 ms TTFT」)。2026-10-15 核对
R59 补充 · 15.3 图「DeepSeek 一天的账」:输入未命中 2,660 亿;命中缓存、未命中、输出三段分别占全天 7,760 亿 token 的 44.1%、34.3%、21.6%;输入占 78.4%本课推导:6,080 − 3,420 = 2,660;3,420 ÷ 7,760、2,660 ÷ 7,760、1,680 ÷ 7,760;6,080 ÷ 7,760(6,080/3,420/1,680 同第 137、30 行;1,814 卡与每卡每秒约 4,950 同第 144、30 行)
R76 复核 · 11.2 / 15.3:B200 V4-Flash 开 MTP 并发 1 也慢 12%(72 → 63 tok/s),高并发变慢归因于算力已满(原文);PyTorch 博客 11,200 是 2026-06 开 MTP 曲线、2,200 是 Day-0(2026-04)不开 MTP 曲线gpu/inference/a4/deepseek-v4/README.vllm.md:268、:283(「高并发下 EP+DP=8 已充分利用 GPU 算力,MTP 的投机计算变成纯开销」);pytorch.org/blog/serving-deepseek-v4-on-gb300-with-sglang-5x-higher-throughput-at-the-same-interactivity-since-day-0(「the June 2026 MTP curve delivers ~11,200 tok/s/GPU … versus ~2,200 tok/s/GPU for the Day-0 (April 2026) no-MTP curve」)。2026-10-15 核对
R77 复核 · 5 节末:RPA kernel 2025-02-28 并入 vLLM V1 的 TPU 后端(现行为 v3 版),论文 2026-04;节末改写「2025 年进 vLLM 的 RPA」,5.1 引论文不变github.com/vllm-project/vllm/pull/13379「[V1][TPU] Integrate the new ragged paged attention kernel with vLLM v1 on TPU」(mergedAt 2025-02-28);arXiv 2604.15464 脚注 1(kernel 路径 ragged_paged_attention/v3)。2026-10-15 核对
R84 补充 · 第二节:Gemma4-31B 在 TPU v7x 并发 256 输出 4,495、峰值 6,144 tok/s;SGLang 重启后首轮另一组 8,520 → 9,118(+7.0%);2.1 那一档每卡约 2,200 → 约 11,200,成本降到约五分之一tpu/tpu-inference/Gemma4-31B/README.md:19、:460;SGLANG-V4PRO-RUNBOOK.md:480-494(§8.4 审计轮 1);本课推导:2,200 ÷ 11,200 ≈ 0.196(两数同 R76 复核行)
R84 补充 · 第四节:8K 输入、ratio 0.15 时两池占用 0.80/0.37,每 rank 峰值 410 条SGLANG-V4PRO-RUNBOOK.md:864-866(§11.5 ISL 8192 表第 5 行)
R84 补充 · 第三节:SGLang-JAX 另一处空档约 7 ms → 24 µs(与 12 ms → 38 µs 同句)lmsys.org/blog/2025-10-29-sglang-jax 原文「from approximately 7ms to 24us」(2026-10-15 核对)
R84 补充 · 第五节:Llama-3.1-70B 参数按 config 现算 70,553,706,496本课推导:词表与输出头各 128,256 × 8,192(不共享)+ 80 层 × 855,654,400(q/o 各 8,192²、k/v 各 8,192 × 1,024、MLP 3 × 8,192 × 28,672、两个 norm)+ 末层 norm 8,192;形状取 HF meta-llama/Llama-3.1-70B config.json;与 safetensors index total_size 的对照本轮未重核
R84 补充 · 第五节:默认 tile 每块 8 × 128 × 4 = 4,096 字节;FP8 时 A 32 KiB(64 倍)、B 8 KiB(16 倍)、C 512 B本课推导,占用公式见 5 节该图出处框;tile 规则取 openxla tiled layout 文档与 Ragged Paged Attention(arXiv 2604.15464)§2.1.2
R84 补充 · 第五节:均匀路由下 256 个 token 让每个专家至少被选中一次的概率 > 99.9%;V3 FP8 分块缩放每专家约 1 万字节本课推导:1 − (31/32)^256 ≈ 1 − 3 × 10⁻⁴;3 个矩阵 × (7,168 ÷ 128) × (2,048 ÷ 128) = 2,688 块 × 4 字节 ≈ 10,752(形状取 HF DeepSeek-V3 config.json)
R84 补充 · 第六节:TP 下 KV 副本倍数 = TP ÷ min(TP, KV 头数):MLA TEP8 为 8、Qwen3.5-397B 为 4、8 个 KV 头的 GQA 为 1;dep8 步时约为 TP4 的四分之一docs.vllm.ai Context Parallel Deployment 页(「the KV cache for each GPU will be duplicated for tp_size / H times」,2026-10-15 核对);本课推导:8 ÷ 1、8 ÷ 2、8 ÷ 8;11.8 ÷ 46.8 ≈ 0.25(两数同第 62 行)
R84 补充 · 第七节:K3 DCP 4K 并发 32 −11%、并发 64 −7%;32K 并发 32 的 TP8 取 408.2,宽表 ratio 0.4 那行是 420,比值 1.04SGLANG-K3-RUNBOOK.md 宽表 :923-929(4K c32 TP8 最优 1,139 → DCP8 1,019,−10.5%)、§11.0.3 :1015(c64 1,511 → 1,409,−6.8%)、:1019、:933;本课推导:436.5 ÷ 420 ≈ 1.04
R84 补充 · 第八节:NixlConnector 调好后单次 KV 传输 200–800 ms → 2–10 msVLLM-V4PRO-RUNBOOK.md:194
R84 补充 · 第九节:DistServe 例子中单卡 goodput 混部 1.6、prefill 5.6、decode 10 rps;2P1D 每秒 10 个、每卡约 3.3;混部接 10 个要 7 张卡DistServe 作者博客 haoailab.com/blogs/distserve「Throughput is Not All You Need」(2024-03,原文 min(5.6 × 2, 10) = 10 reqs/s ÷ 3 GPUs ≈ 3.3,2026-10-15 核对);本课推导:⌈10 ÷ 1.6⌉ = 7
R16 补充 · 9.1:混部只到 1.6 rps 的原因是 TTFT、TPOT 两条延迟要求,两段互相干扰时只能顾一头或多堆卡(「In the presence of stringent latency requirements, existing systems have to prioritize one latency over the other, or over-provision compute resources to meet both」)DistServe,arXiv 2401.09670 摘要(2026-10-19 核对)
R84 补充 · 第九节:B200 V3 加一台 prefill,并发 256 每卡 1,798.1 → 1,775.6;12 个 prefill 时每卡 3,187(25,500 ÷ 8 = 3,187.5);4K 输入重扫 1 个 prefill 喂料 2.06 倍gpu/inference/a4/deepseek-v3/REPORT-2P1D-DeepSeek-V3.md:71、:87、:120;VLLM-V4PRO-RUNBOOK.md:723、:635-639
R84 补充 · 第十节:GB300 R1 压测并发 512 时实际并发 416;8 ÷ 288 = 2.8%(原文约 3%)gpu/inference/a4x-max/deepseek-v3/sglang-r1-nvfp4-gb300-3p2d-DEPLOY-GUIDE.md:401、:414
R84 补充 · 第十一节:V3 专家以外的参数约 17.1B,每 token 激活约 37.5B本课推导:每专家 3 × 7,168 × 2,048 ≈ 4,404 万;671B − 256 × 58 × 4,404 万 ≈ 17.1B;再加 8 × 58 × 4,404 万 ≈ 37.5B;外部锚点为技术报告 37B(arXiv 2412.19437)
R84 补充 · 第十一节:V4-Pro steps 1 → 2 接受长度 1.88 → 2.36(+26%)、反推单步耗时 +41%;B200 V4-Flash 开 MTP 接受率约 54%;K3 并发 64 开投机的 TPOT 是不开的 40%SGLANG-V4PRO-RUNBOOK.md:900-911;gpu/inference/a4/deepseek-v4/README.vllm.md:268-277(十档 53.5%–53.9%);SGLANG-K3-RUNBOOK.md:1090(14.61 ÷ 36.3 ≈ 0.40,本课推导)
R84 补充 · 第十二节:8 × 192 GiB = 1,536 GiB ≈ 1,649 GB;94.75 GiB ≈ 101.7 GB、101.8 GiB ≈ 109.3 GB;R1 FP4 专家连同注意力每 device 约 70本课推导:GiB × 1.0737;tpu/tpu-inference/DeepSeek-R1-671B-FP4/README.md:877-878
R84 补充 · 第十二节:megakernel 在 B200 上一次前向不到 680 µs;Inferact 用 16 颗 TPU v7 = 32 个 TensorCore、每 TensorCore 64 MiB VMEMhazyresearch.stanford.edu/blog/2025-05-27-no-bubbles(「under 680 microseconds per forward pass」);inferact.ai/blog/tpu-megakernels(「64 MiB of VMEM per TensorCore」);均 2026-10-15 核对;32 = 16 × 每芯片 2 个 TensorCore(本课推导)
R84 补充 · 第十四节:pkill -9 后每卡仍占 97,486 MiB/284,208 MiB;分桶示意 2,000 步、截到 8,192SGLANG-V4PRO-RUNBOOK.md:960-978(:962-963);分桶数据为本课推导示意(对数正态分位点,非真实流量)
R85 补充 · 第零节 fig6-engines:vLLM 2023-06 首发 PagedAttention,吞吐最多是 HF 的 24×blog.vllm.ai/2023/06/20/vllm.html(「up to 24x higher throughput compared to HF」)
R85 补充 · 第零节 fig6-engines:DeepSpeed-FastGen 2023-11,vLLM 回应「已在路线图」vllm.ai/blog/2023-11-14-notes-vllm-vs-deepspeed(「This optimization is on vLLM's roadmap」)
R85 补充 · 第零节 fig6-engines:SGLang 2024-01 首发,吞吐最多 5×(对 Guidance、vLLM 等),原文写明复用了 vLLM 的代码lmsys.org/blog/2024-01-17-sglang/(「up to 5 times higher throughput compared to existing systems, namely Guidance and vLLM」;「reused some code from … vLLM」)
R85 补充 · 第零节 fig6-engines:vLLM 前缀缓存 APC 2024-03 合入,V0 默认关、V1 改默认开github.com/vllm-project/vllm/pull/2762(03-02 合入);blog.vllm.ai/2025/01/27/v1-alpha-release.html(「we now enable prefix caching by default in V1」)
R85 补充 · 第零节 fig6-engines:分块 prefill vLLM 2024-04-11 合入,SGLang 2024-07-29 合入,晚 3 个多月github.com/vllm-project/vllm/pull/3884;github.com/sgl-project/sglang/pull/800;间隔为本课推导,往下取整
R85 补充 · 第零节 fig6-engines:DistServe 2024-01、Sarathi-Serve 2024-03、DeepSeek-V2(MLA)2024-05、Mooncake 论文 2024-06arXiv 2401.09670;arXiv 2403.02310;arXiv 2405.04434;arXiv 2407.00079
R85 补充 · 第零节 fig6-engines:SGLang v0.2 2024-07,吞吐 3.1×(对 vLLM 0.5.2)lmsys.org/blog/2024-07-25-sglang-llama3/(「up to 3.1x higher throughput on Llama-70B」)
R85 补充 · 第零节 fig6-engines:vLLM v0.6.0 2024-09 博客承认调度的 CPU 开销让 GPU 吃不饱;2.7×,基线 v0.5.3blog.vllm.ai/2024/09/05/perf-update.html(「2.7x Throughput Improvement」)
R85 补充 · 第零节 fig6-engines:SGLang v0.3 2024-09 MLA 优化,3–7×(对基线系统)lmsys.org/blog/2024-09-04-sglang-v0-3/(「3x to 7x higher throughput than the baseline system」)
R85 补充 · 第零节 fig6-engines:Mooncake 传输引擎 2024-11 开源;vLLM 2024-12-15 合入(同月 12-01 合入首批 PD 代码),SGLang 2025-04-10 支持,晚 3 个多月github.com/kvcache-ai/Mooncake(README 时间线);github.com/vllm-project/vllm/pull/10884、/pull/10502;间隔为本课推导
R86 补充 · 第零节 开场新闻:Dory 4B 2026-10-16 发布,前 8、循环 20、后 8 层,每圈重新喂输入;默认 2 圈,1 圈省算力,agent 任务 4 圈;圈数多可能少出 token;默认每圈各存 KV,可改成只存 1 圈大小huggingface.co/nvidia/NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16(「Input and Output blocks have 8 layers each, while the Recurrent block has 20 layers」「We recommend two loops as the default」)
R86 补充 · 第零节 开场新闻:Koi-4B 1 圈约 18、4 圈 29;每微批随机抽圈数、梯度穿过全部圈;1.79×/1.20× 训练算力、保留 84%;4B 估多 16%;128K 每圈存 KV 7.5 GiB 对 3.0 GiB;输出 token 少 21.8%/29.5%/32.7%arXiv 2610.12582(Elastic Latent Recurrence,2026-10-08)§1、§3.2、§5、§6.5
R86 补充 · 第零节 开场新闻:免训练循环,直接重复通常变差,阻尼小步后 Qwen3-4B-Instruct MMLU-Pro +2.64pparXiv 2605.23872;续训改造见 arXiv 2511.07384、2410.20672、2605.11011
R86 补充 · 第零节 开场新闻:等深 96 层、权重约 38%、中间段比 VMEM 大一个数量级本课推导:8+20×4+8=96;36/96;4B 参数 BF16 约 8 GB,中间 20 层约占一半,对 128 MiB
R85 补充 · 第零节 fig6-engines:SGLang v0.4 2024-12-04(零开销调度、DP attention);V3 Day-0 SGLang v0.4.1 12-25/26,vLLM v0.6.6 12-27,早一两天lmsys.org/blog/2024-12-04-sglang-v0-4/;github.com/sgl-project/sglang/releases/tag/v0.4.1;github.com/vllm-project/vllm/releases/tag/v0.6.6
R85 补充 · 第零节 fig6-engines:vLLM V1 2025-01-27 博客致谢 SGLang 等引擎blog.vllm.ai/2025/01/27/v1-alpha-release.html(「These engines have significantly influenced our work」)
R85 补充 · 第零节 fig6-engines:MTP SGLang 2025-02-14 合入,vLLM 2025-02-19 合入,晚 5 天github.com/sgl-project/sglang/pull/3582;github.com/vllm-project/vllm/pull/12755;间隔为本课推导
R85 补充 · 第零节 fig6-engines:DeepSeek 开源周 2025-02(FlashMLA、DeepEP、DeepGEMM);Dynamo 2025-03-18 开源github.com/deepseek-ai/open-infra-index;NVIDIA Dynamo 新闻稿(nvidianews.nvidia.com,2025-03-18)
R85 补充 · 第零节 fig6-engines:EAGLE-3 SGLang 2025-03-18 合入(自称首个支持),vLLM 2025-04-25 合入,晚 5 周github.com/sgl-project/sglang/pull/4247;github.com/vllm-project/vllm/pull/16937;间隔为本课推导(38 天)
10-19 补充 · 11.3:EAGLE 草稿结构(嵌入层、LM head 借目标模型不训;只训 FC+一层 decoder;输入=出字前特征+提前一位的字嵌入,拼 2 倍宽压回);70B 可训参数 0.99B、ShareGPT 6.8 万条、A100 40G 服务器 1–2 天EAGLE arXiv 2401.15077 v3 正文 §3 Figure 6 说明、§4 Training 段
10-19 补充 · 11.3:EAGLE-3 低/中/高三层特征拼 3k 压回 k、改为直接预测 token、第 2 步起用草稿输出 a 顶替目标特征、training-time testEAGLE-3 arXiv 2503.01840 v3 正文 §3.1–3.2
10-19 补充 · 11.3:原版 EAGLE 加训练数据提升有限,EAGLE-3 改直接预测 token+training-time test 后能吃到数据规模的收益EAGLE-3 arXiv 2503.01840 摘要(「scaling up data provides limited improvements for EAGLE」「enable the draft model to fully benefit from scaling up training data」)
10-19 补充 · 11.3:DeepSeek-V3 MTP 模块=主干隐状态+下一 token 嵌入→归一化、投影→transformer block,共享嵌入与输出头;Qwen3-Next 按多步推理训 MTP;Step 3.5 Flash 用 MTP-3;Nemotron 3 Super 两层共享权重可递归;GLM-4.5、MiMo 带 MTPsebastianraschka.com/llm-architecture-gallery/mtp;FastMTP arXiv 2509.18362 引言(列 GLM-4.5、Xiaomi MiMo 采用 MTP)
10-19 补充 · 11.3:MiMo-7B 单层 MTP 原样递归连猜,第 1/2/3 个草稿字接受率约 70%/约 10%(贡献段写 11%)/近 0(2%);FastMTP 冻结主模型、自蒸馏数据微调 210.8M 参数 MTP 头后升到 81%/56%/36%,平均 2.03×(对不投机)FastMTP arXiv 2509.18362 v1 贡献段、§4 Implementation、Acceptance Rate Analysis 段
R85 补充 · 第零节 fig6-engines:vLLM KV Connector 接口 2025-04github.com/vllm-project/vllm/pull/15960(04-17);blog.lmcache.ai/en/2025/04/11/shaping-nixl-based-pd-disaggregation-in-vllm-v1
R85 补充 · 第零节 fig6-engines:SGLang 大 EP+PD 复现 2025-05-05;vLLM 接 DeepEP 2025-06-03(PR merged_at),晚近 1 个月lmsys.org/blog/2025-05-05-large-scale-ep/;github.com/vllm-project/vllm/pull/18434;间隔为本课推导(29 天)
R85 补充 · 第零节 fig6-engines:DeepSeek-V3.2 两家 2025-09-29 同日 Day-0;V4 vLLM 2026-04-24、SGLang 04-25vllm.ai/blog/2025-09-29-deepseek-v3-2;lmsys.org/blog/2025-09-29-deepseek-V32;vllm.ai/blog/2026-04-24-deepseek-v4;lmsys.org/blog/2026-04-25-deepseek-v4
R85 补充 · 第零节 fig6-engines:SGLang HiCache 2025-09;vLLM 2025-10 删掉 V0、TPU 新后端 tpu-inference;SGLang-JAX 2025-10lmsys.org/blog/2025-09-10-sglang-hicache/;github.com/vllm-project/vllm/releases/tag/v0.11.0;blog.vllm.ai/2025/10/16/vllm-tpu.html;lmsys.org/blog/2025-10-29-sglang-jax/
R85 补充 · 第零节 fig6-engines:vLLM Wide-EP 2025-12,每 H200 约 1.5k → 2.2k tok/svllm.ai/blog/2025-12-17-large-scale-serving(「2.2k tokens/s per H200」,此前「~1.5k」)
R85 补充 · 第零节 fig6-engines:vLLM MRV2 2026-03,吞吐 +56%(Qwen3-0.6B)vllm.ai/blog/2026-03-24-mrv2(「56% throughput increase」)
R85 补充 · 第零节 fig6-engines:SGLang V4 on GB300 2026-06,同交互档 5.1×(对自家 Day-0);Inferact TPU megakernel 2026-09pytorch.org/blog/serving-deepseek-v4-on-gb300-with-sglang-5x-higher-throughput-at-the-same-interactivity-since-day-0;inferact.ai/blog/tpu-megakernels
R85 补充 · 第零节正文:两家共用的外部部件 FlashInfer、xgrammar、DeepEP 与 FlashMLA、Mooncake、NIXLvLLM PR #4353(FlashInfer)、v0.6.5 release(xgrammar 默认)、v0.8.0(FlashMLA)、#18434(DeepEP)、v0.9.0(NIXL);SGLang lmsys 2024-07-25(FlashInfer)、2024-12-04(xgrammar)、v0.4.4 release(FlashMLA)、v0.4.5(DeepEP)、v0.4.6(Mooncake、NIXL)
R86 补充 · 3.2:chunked prefill 在引擎里 vLLM 先合入(2024-04),SGLang 同年 7 月跟进;思路源头是 Sarathi 论文与 DeepSpeed-FastGen(2023-11)vLLM PR #3884「Fully working chunked prefill e2e」,2024-04-11 合入(github.com/vllm-project/vllm/pull/3884);SGLang PR #800,2024-07-29 合入(github.com/sgl-project/sglang/pull/800);DeepSpeed-FastGen 博客(github.com/microsoft/DeepSpeed/blob/master/blogs/deepspeed-fastgen/README.md)
R86 补充 · 3 lead:PagedAttention 首发于 vLLM,2023 年(v0.1.0 与发布博客 2023-06-20;论文 SOSP 2023);Orca 在前,OSDI'22blog.vllm.ai/2023/06/20/vllm.html;arXiv 2309.06180;Orca 见本台账 Orca 那一行
R87 补充 · 15.3 表:「补的哪个洞」列的环号 ①–⑪ 对应 0.1 的 11 环问题链(V1 重写不在链上,不标环号;⑩ DCP/PCP 无实测行);「首发」列只标这一招最早由谁公开:Orca、GPTQ、投机解码、DistServe、Sarathi-Serve、EAGLE-3 为论文;PagedAttention、V1、FP8 权重博客为 vLLM;RadixAttention、KV 感知路由为 SGLang;MLA、磁盘 KV 缓存、MTP、大 EP(SGLang 那行是复现)、DSA、V3.2 FP8 KV 为 DeepSeek;Mooncake、K2 INT4 为 Kimi(Moonshot);NVFP4 KV 为 NVIDIA 博客;末行 5.1 倍出自 SGLang 的 PyTorch 博客本课归纳;各行原始出处见本表已录各条(Orca/PagedAttention/RadixAttention/DistServe/Sarathi-Serve/EAGLE-3 论文,vLLM V1 与 FP8 博客,lmsys.org/blog/2024-12-04-sglang-v0-4,DeepSeek-V3/V3.2 报告与 API 文档,Mooncake 论文,huggingface.co/moonshotai/Kimi-K2-Thinking,NVIDIA NVFP4 KV 博客,llm-d README,PyTorch 博客 2026-06-23);首发先后另对照引擎时间线素材(GitHub release/博客,2026-10-15 调研)
R88 补充 · 第零节 fig6-engines:SGLang v0.2 博客点名 vLLM 的 CPU 调度开销,是 SGLang 改用纯 Python 轻量调度的出发点lmsys.org/blog/2024-07-25-sglang-llama3/(「vLLM suffers from high CPU scheduling overhead」)
R89 补充 · 14.2:Qwen3.5-397B prefill 时 MoE 约占八成时间本课据私有实测指数化(取整到「约八成」)
R89 补充 · 14.2:Qwen3.5 全注意力层 2 个 KV 头、512 个专家选 10 个;注意力 DP=8 + MoE EP=8;比过 all-to-all,选 all-gather + reduce-scatter 是为了延迟可预测https://developers.googleblog.com/systems-engineering-playbook-optimizing-qwen-35-397b-moe-on-ironwood-tpu7x/(§1、§3「Because deterministic latency is critical」)
R89 补充 · 14.2:SparseCore 合并把 HBM 读 20 → 10、写 15 → 5(原文未写单位);reduce-scatter 切 4 块流水;线性层状态 FP32 → BF16https://developers.googleblog.com/systems-engineering-playbook-optimizing-qwen-35-397b-moe-on-ironwood-tpu7x/(§B.3「reducing the HBM read requirements from 20 down to 10 and writes from 15 down to 5」「partitioned into 4 distinct chunks」;§C.2)
R89 补充 · 14.2 与 fig6-s13-ladder:DP8 prefill 指数 1.00 → 1.06 → 1.16 → 1.45 → 1.58,四刀各 ×1.06、×1.09、×1.26、×1.09;同期首尾实测 1.59;「只差半个百分点」;绿柱高过前两刀之积(1.26 > 1.06 × 1.09 ≈ 1.16)本课据私有实测指数化;连乘与差值为本课推导:1.0565 × 1.0945 × 1.2553 × 1.091 ≈ 1.584,1.592 ÷ 1.584 ≈ 1.005
R89 补充 · 14.2:整层融合之前 reduce-scatter 约占 device 时间两成;通信切块那一刀 XLA 仍不重叠本课据私有实测指数化(取整到「约两成」)
R89 补充 · 14.2:SMEM 1 MiB;SparseCore 一块 512 行硬件属性;本课据私有记录(路由表预取进 SMEM 的上限、SparseCore 块 = lane × core × subcore)
R89 补充 · 14.2:decode 64K 上下文、几百条并发;TP2 后每 rank 1 个 KV 头,旧布局 FP8 页与 BF16 页一样大本课推导:2 个 KV 头 ÷ TP2 = 1;按头这一维打包时 ceil(1×2 ÷ 2) = ceil(1×2 ÷ 4) = 1;场景参数本课据私有实测指数化
R89 补充 · 14.2:one-hot 那一刀 decode 涨一成上下;线性层状态 BF16 让 KV 池多装约一成、decode 涨几个百分点到一成;换布局那天跳了好几倍(相对前一天,为修复退化)本课据私有实测指数化(分档取整)
R89 补充 · 14.2:PCP 吞吐虚高源于 MoE 在 PCP 下静默跳过通信本课据私有实测指数化(只取机制,不取数)
R89 补充 · 14.2:K3 每 token 不重复字节约 158 GB本课推导:按 huggingface.co/moonshotai/Kimi-K3 config 逐项加总激活参数 104.2B(对官方 104B)后折算字节
R89 补充 · 14.2:92 个 MoE 层一次 Pallas 调用、不分 grid;16 颗 v7、32 个 TensorCore、TP4 × EP8;跨层预取;每 TensorCore 64 MiB VMEM;2×2×4 拓扑、换拓扑要重写集合通信;batch 1 → 8 后加残差流序列并行;一次验 1 锚点 + 7 草稿,每步收下 3–6 个、一步 ~8.5 ms;编译 <90 s 对 30+ 分钟https://inferact.ai/blog/tpu-megakernels(2026-09-23)
R89 补充 · 14.2:VMEM 分开放 90.67 MB、共用一块 31.29 MB;4 个专家槽轮转本课推导:按 https://github.com/Inferact/tpu-megakernels(Apache-2.0)的 VMEM 分配逐项加总
R89 补充 · 14.2:MXFP4 → FP8 专家字节 ×1.60(对 MXFP4)、向量单元缩放活约 1/8;batch 1 只到自身布局带宽上界五成上下本课推导:按 https://github.com/Inferact/tpu-megakernels 的打包格式,MXFP4 4 + 8/32 = 4.25 bit,FP8 + 每 256 个一个 bf16 = 8.06 bit,三块合计 3 × 4.25 = 12.75 → 2 × 8.06 + 4.25 = 20.37,比 1.60;256 ÷ 32 = 8;带宽占比由公开 config 与博客吞吐推得 46%–56%,取整为五成上下
R90 补充 · 第零节 fig6-engines:Dynamo 2025-03 开源,首发即支持 vLLM 与 SGLangdeveloper.nvidia.com/blog/introducing-nvidia-dynamo-a-low-latency-distributed-inference-framework-for-scaling-reasoning-ai-models/(「supports all major LLM frameworks including NVIDIA TensorRT-LLM, vLLM, and SGLang」)
R91 补充 · 4.1:GQA-8 每条样本解码 1.51 → 0.28(MHA-XXL → GQA-8-XXL),平均分 47.2 → 47.1;MQA 0.24、46.6arXiv 2305.13245v3 Table 1(TPU v4,8 颗,每颗 batch 至多 32;T5-XXL 以 5% 预训练量改造;「GQA achieves significant additional quality gains, achieving performance close to MHA-XXL with speed close to MQA」,2026-10-16 核对);本课推导:1.51 ÷ 0.28 ≈ 5.4。原文单位为每条样本时间,正文只讲相对比
R91 补充 · 4.1 / 15.3:V3.2 架构上只改了 DSA;基准与 V3.1-Terminus 基本持平(MMLU-Pro 85.0 对 85.0,HLE 21.7 对 19.8)arXiv 2512.02556 §2.3(「the only architectural modification of DeepSeek-V3.2 is the introduction of DeepSeek Sparse Attention (DSA) through continued training」);github.com/deepseek-ai/DeepSeek-V3.2-Exp 技术报告 PDF(「DeepSeek-V3.2-Exp does not show substantial performance degradation compared with DeepSeek-V3.1-Terminus」,2026-10-16 核对)。查过:成本降幅只有按 H800 租价画的每百万 token 成本图(Figure 3),正文无比值,本课不写价格,故不取
R91 补充 · 7.2 / 15.3:Llama3 405B、H100、机内 TP8 跨机 CP:机器数翻倍延迟约减半,CP8 做 128K 5.85 s;2 台 CP2 对 TP16 差约 15%,8 台差约 100%(TP 慢)arXiv 2411.01783v3(MLSys 2025)(「While the latency is different by roughly 15% between CP2 and TP16 on 2 nodes, the difference drastically increases to 100% when scaled to 8 nodes」,2026-10-16 核对)。R87 那行「⑨ 无实测行」自本轮起不再成立。查过:vLLM PCP 文档与 RFC,无公开数字
R91 补充 · 12.1 / 12.3 / 15.3:AWQ,Llama-2-7B、RTX 4090、batch 1、4 token 输入 200 token 输出取中位延迟:FP16 融合 52 → 62 tok/s,INT4 再快 3.1 倍;WikiText-2 困惑度 FP16 5.47、RTN 5.73、AWQ 5.60(INT4 g128)arXiv 2306.00978v5(「For Llama-2-7B, we improve the inference speed from 52 tokens/s to 62 tokens/s through FP16 kernel fusion. On top of the stronger FP16 baseline, we further harvest 3.1× additional speedup from the fast quantized linear kernels.」,2026-10-16 核对)
R91 补充 · 12.1:8B 混合 Mamba-Transformer 训 1T token,训练 loss 相对 BF16:MXFP4 约 2.5%、NVFP4 约 1.5%;MXFP4 多训 36% token 追平 NVFP4 的 lossarXiv 2509.25149v2(「MXFP4 has a relative error of around 2.5% compared to 1.5% for NVFP4」「MXFP4 matches NVFP4 loss when trained on 36% more tokens」,2026-10-16 核对)
R91 补充 · 12.1:DeepSeek-R1-0528 从 FP8 训后量化到 NVFP4,主要语言任务掉点 ≤1%developer.nvidia.com/blog/introducing-nvfp4-for-efficient-and-accurate-low-precision-inference(2025-06,「1% or less accuracy degradation on key language modeling tasks for DeepSeek-R1-0528, when quantized from its original FP8 format to NVFP4 using post-training quantization」,2026-10-16 核对)。查过:NVIDIA 博客、NVFP4 预训练论文、TensorRT-LLM 文档,无同卡 FP4 对 FP8 的官方同条件吞吐对比
R91 补充 · 12.1:K2 Thinking 低延迟模式约快 2 倍、「无损」,基准全在 INT4 下报huggingface.co/moonshotai/Kimi-K2-Thinking(「lossless 2x speed-up in low-latency mode」「All benchmark results are reported under INT4 precision」);moonshotai.github.io/Kimi-K2/thinking.html(「roughly 2x generation speed improvement」),2026-10-16 核对。查过:模型卡、官方博客、K2.5 技术报告 arXiv 2602.02276,无对照精度说明、无 INT4 对 FP8 精度表;一位 Moonshot 工程师的个人文章称对照为 block FP8,非官方,正文不取
R91 补充 · 12.3:Hazy megakernel,Llama-3.2-1B、batch 1、H100:比 vLLM 快近 2.5 倍、比 SGLang 快 1.5 倍以上;TensorRT-LLM DeepSeek-R1 8×B200 低延迟,「Fuse oneshotAR + RMSNorm」一步 164 → 168 TPS/user(逐步累加)hazyresearch.stanford.edu/blog/2025-05-27-no-bubbles(「On an H100, our megakernel runs almost 2.5x faster than vLLM and over 1.5x faster than SGLang」);nvidia.github.io/TensorRT-LLM/blogs/tech_blog/blog1_Pushing_Latency_Boundaries_Optimizing_DeepSeek-R1_Performance_on_NVIDIA_B200_GPUs.html 优化步骤表,2026-10-16 核对
R91 补充 · 15.3:5.1 倍里 MTP 的份额官方没拆;两条六月曲线各对首发日曲线:不开 MTP 在 40 tok/s/user 档 2.1 倍,开 MTP 在 80 档 2.6 倍PyTorch 博客 2026-06-23(「the June curves sustain 2.1x more throughput at 40 tok/s/user (no-MTP) and 2.6x more at 80 tok/s/user (MTP)」,2026-10-16 核对)。查过:该博客与 SGLang 文档,无 MTP 单项消融;两数档位不同,不相减不相除
R91 补充 · 15.3:TensorRT-LLM DeepSeek-R1 8×B200、输入 1k 输出 2k:不开 MTP 111 TPS/user,MTP1 198,MTP3 253(接受长度 2.82),MTP5 239nvidia.github.io/TensorRT-LLM/blogs/tech_blog/blog1_Pushing_Latency_Boundaries_Optimizing_DeepSeek-R1_Performance_on_NVIDIA_B200_GPUs.html(2026-10-16 核对);与 5.1 倍模型、硬件都不同,只作量级参考
R91 补充 · 0.1 / 15.3 / 讲稿:AI Index 的 280 倍、硬件成本每年降 30%、Epoch 的 9–900 倍/年都是价格口径,正文与讲稿改为定性(「便宜得很快」「年年在便宜,2024 年以后更快」),只留非价格的能效每年升 40%;开场竞猜改用同卡、同模型、同交互档的 5.1 倍。上面三行原始台账保留作出处本课取舍;出处见本台账 AI Index 两行与 R21 Epoch 行
R91 补充 · 4.1:线性注意力首发 2020 年(Katharopoulos 等「Transformers are RNNs」,ICML 2020)arXiv 2006.16236,v1 提交于 2020-06-29(「up to 4000x faster on autoregressive prediction of very long sequences」,2026-10-16 核对)
L80 补充 · 0.1 时间轴/图下两张表/讲稿:vLLM 2025-09 随 v0.10.2 合入解码上下文并行(DCP,先支持 MLA)github.com/vllm-project/vllm/releases/tag/v0.10.2(2025-09,含「[attention][DCP]」「Support decode context parallelism on Blackwell with CUTLASS MLA」);2026-10-16 核对
L80 补充 · 0.1 时间轴/讲稿:RadixAttention 首次公开于 SGLang 论文 2023-12,早于 2024-01 的引擎首发博客arXiv 2312.07104(2023-12 首版);lmsys.org/blog/2024-01-17-sglang/
L87 补充 · 0.1 时间轴:分块 prefill 首次公开按 SARATHI(arXiv 2308.16369,2023-08)算,从 2024 挪进 2023;环号 ⑧→⑥ ⑥→⑦ ⑦→⑧,0.1 图、图下表、15.3 表、讲稿同步arXiv 2308.16369(SARATHI: Efficient LLM Inference by Piggybacking Decodes with Chunked Prefills);arXiv 2403.02310(Sarathi-Serve,倍数出处)
L80 补充 · 0.1 时间轴:点按首次公开排,投机解码、量化落在 2022;L81 起环号按时间重编,从左到右 ①–⑪ 连续(旧→新:①→① ⑪→② ⑩→③ ③→④ ②→⑤ ⑦→⑥ ④→⑦ ⑥→⑧ ⑤→⑨ ⑨→⑩ ⑧→⑪),0.1 图下表与 15.3 表同步;跨年的环点下标末年(④ DSA 2025-09、⑨ HiCache 2025-09、⑥ Dynamo 2025-03、⑪ SGLang 复现 2025-05、⑩ vLLM DCP 2025-09、③ EAGLE-3 2025-03、② V4.1-Flash FP4 KV 与 Inferact megakernel 2026-09)本课归纳;各年份见本表已录各条(Orca、GPTQ arXiv 2210.17323、Leviathan 等 arXiv 2211.17192、GQA arXiv 2305.13245、Splitwise arXiv 2311.18677、Sarathi-Serve、Mooncake、第七节 Meta 上下文并行、R85 补充各行)
L84 补充 · 4.3:vLLM 前缀缓存只给写满的块算哈希(hash_block_size,默认等于 block_size,CacheConfig.DEFAULT_BLOCK_SIZE = 16),增量计算并存在请求上;哈希输入为(父块哈希,本块 token 元组,extra_keys:LoRA/多模态/cache_salt);默认算法 sha256(可选 sha256_cbor、xxhash);SGLang RadixCache 按 page_size 对齐比对 token 编号github.com/vllm-project/vllm main:vllm/v1/core/kv_cache_utils.py(hash_block_tokens、get_request_block_hasher「We only hash full blocks」)、vllm/config/cache.py(DEFAULT_BLOCK_SIZE、prefix_caching_hash_algo);github.com/sgl-project/sglang main:python/sglang/srt/mem_cache/radix_cache.py(RadixKey.match)。2026-10-17 核对
L85 补充 · 3.1:Orca 两招为迭代级调度(引擎每次只跑一步,调度器在步间返回已完成请求、加入新请求)与选择性批处理(非注意力算子把各请求 token 拉平成一长条批处理,注意力按请求拆开);Orca 按最大长度为每个请求预留 KV;vLLM 论文 20.4%–38.2% 的对照为作者复现的 Orca(Max/Pow2/Oracle)Orca,OSDI 2022(Yu 等)第 3–4 节;vLLM,SOSP 2023(arXiv 2309.06180)图 2 与第 6 节基线说明。2026-10-17 核对
L86 补充 · 3.2:vLLM max_num_batched_tokens 默认按设备分档(≥160 GB GPU 16,384;≥70 GB 且非 A100:LLM 类 16,384、API 服务 8,192;其余 GPU 8,192/2,048;TPU V6E 2,048/1,024);SGLang chunked_prefill_size 按显存分档(<20 GB 2,048;<60 GB 4,096;<160 GB 8,192;其余 16,384);V3 注意力每对约 5.0 MFLOP、线性部分约 74 GFLOP/token、交叉点约 1.5 万、末块/首块约 7 倍、H100 平衡点约 300 token、MoE 约 9,400 token 均为本课推导github.com/vllm-project/vllm main:vllm/engine/arg_utils.py(默认 max_num_batched_tokens 分档);github.com/sgl-project/sglang main:python/sglang/srt/arg_groups/memory_hook.py;DeepSeek-V3 config.json(qk_nope_head_dim 128、qk_rope_head_dim 64、v_head_dim 128、128 头、61 层、256 专家取 8);FlashAttention-2(arXiv 2307.08691)外层按 query 分块。2026-10-17 核对
L88 补充 · 第三/四节:调度提到 KV 之前(先坐满、再问座位从哪来),两节编号、锚点、图 id 与全课交叉引用同步对调;数字未改结构调整,无新数;2026-10-17 核对
L89 补充 · 3.1:Orca 是 OSDI 2022 论文及其中实现的服务系统(论文原文「we have implemented a distributed serving system called ORCA」)usenix.org/conference/osdi22/presentation/yu 摘要。2026-10-18 核对
L90 补充 · 6.5 双微批:prefill 同 token 数快 27%~35%、每卡 16,384 token 时比不拆最优快 40.5%;decode 256 token/卡快 25.5%、32 token/卡慢 27%(小批 kernel 效率低);DeepSeek decode 把注意力拆两段走 5 段流水;vLLM DBO 纯 decode 阈值默认 32 tokenLMSYS 博客 2025-05-05「Deploying DeepSeek with PD Disaggregation and Large-Scale Expert Parallelism on 96 H100 GPUs」TBO 一节;DeepSeek open-infra-index「Day 6 · Inference System Overview」;vLLM vllm/config/parallel.py(enable_dbo、dbo_decode_token_threshold 默认 32、dbo_prefill_token_threshold 默认 512);SGLang --enable-two-batch-overlap。2026-10-18 核对
L91 补充 · 6.12 EPLB:V3 prefill 32 个冗余专家、每卡 8+1、定期重算(例如每 10 分钟);SGLang 大规模 EP 开 EPLB prefill 1.49×、decode 2.54×(作者注明看负载分布);256+32=288 可用 12、72 路;vLLM eplb_config 默认 step_interval 3000、window_size 1000、num_redundant_experts 0DeepSeek-V3 技术报告 arXiv 2412.19437 sec. 3.4;DeepSeek EPLB 仓库 README;LMSYS 博客 2025-05-05 大规模 EP 一文 EPLB 一节;vLLM vllm/config/parallel.py EPLBConfig;SGLang --enable-eplb、--ep-num-redundant-experts(server_arguments 文档)。2026-10-18 核对
L92 补充 · 12.3 CUDA Graph:A100、LLaMA-2-7B、batch 1,不开 30 tok/s、开 69 tok/s(2.3×),提速全来自 CPU 开销;vLLM 默认录 [1,2,4]+8..248 步 8+256 起步 16,上限 512(数据中心 Blackwell 1,024);V1 默认 FULL_AND_PIECEWISE(decode 整图、prefill/混合分段)Fireworks 博客「Speed, Python: Pick Two. How CUDA Graphs Enable Fast Python Code for Deep Learning」2023-08-29;vLLM vllm/config/compilation.py(max_cudagraph_capture_size、cudagraph_mode);SGLang --cuda-graph-max-bs。2026-10-18 核对
L93 补充 · 11.5 n-gram 草稿:Llama3-70B、4×H100、QPS=1,CNN/DailyMail 最多 2.8×,草稿模型(Qwama-0.5B)跑 ShareGPT 1.5×;vLLM method="ngram",prompt_lookup_min/max 都不填默认 5;SGLang --speculative-algorithm NGRAM。3.1 multi-LoRA:S-LoRA 服务几千个适配器、吞吐最多是 HF PEFT 与 vLLM 简单 LoRA 支持的 4 倍vLLM 博客 2024-10-17「How Speculative Decoding Boosts vLLM Performance by up to 2.8x」;prompt-lookup-decoding 仓库 README;vLLM vllm/config/speculative.py、vllm/config/lora.py(max_loras 默认 1);S-LoRA arXiv 2311.03285 摘要。2026-10-18 核对
L94 补充 · 12.2 重写:gpt-oss-120b MLP 114.71B/Attention 0.96B/Embed+Unembed 1.16B/总 116.83B,只 MoE 权重 MXFP4、单张 80 GB;K2 Thinking quantization_config ignore 含 self_attn、shared_experts、稠密层 mlp、lm_head,INT4 group 32;R1 v7x-8 FP4 专家 60.9 GB/device、FP8 101.8 GB/device;GSM8K R1 94.92%(1319 题)、GLM-5.1 89.46%(5-shot);TPU MoE kernel 4 bit 块进片上点积、按块乘 scale;Marlin batch 16–32 内近 4×、vLLM 端到端最多 2.8×gpt-oss 模型卡 Table 1;huggingface.co/moonshotai/Kimi-K2-Thinking config.json;tpu/tpu-inference/DeepSeek-R1-671B-FP4、GLM-5.1-754B-FP4 README;vllm-project/tpu-inference tpu_inference/kernels/megablox/gmm.py(jnp.dot 后乘 rhs_scale)、common.py(支持 float4_e2m1fn);Marlin README、arXiv 2408.11743。2026-10-18 核对
L95 补充 · 12.4 字节账图 fig-s12-ledger:gpt-oss-120b batch 1 每字权重字节,专家 BF16 7.2/FP8 3.6/MXFP4 1.9 GB,注意力 1.9、输出层 1.2 GB 不变;合计 10.2/6.7/5.0,整步 2.06×、FP8→MXFP4 1.34×,专家占比 70%→38%(本课推导)huggingface.co/openai/gpt-oss-120b config.json;gpt-oss 模型卡 Table 1(Attention 0.96B、激活 5.13B 作锚点,均对上)。2026-10-18 核对
L96 补充 · 第十三节(2026-10-19 按生产做法重写 13.2):三种层的复用边界;vLLM 留存三策略——prompt 末尾必留、按间隔(例每 32K,VLLM_PREFIX_CACHE_RETENTION_INTERVAL,0 只留末尾)、Marconi 第二次命中才存,「Caching at every token position would be prohibitively expensive」;K3 起物理块、调度对齐、前缀匹配单位解耦;SGLang decode 每 256 记一份(--mamba-track-interval 默认 256)、--mamba-max-states-per-path 默认 -1 不封顶、命中时在分叉处补记、KV 池与 Mamba 池按 --mamba-full-memory-ratio 分、弹性池、两条 LRU、HiCache 分层;--enable-int8-mamba-checkpoint 默认关「~2x cached-prefix capacity」;Nemotron-Nano-12B-v2 块 672 token;Qwen3.5 一份快照 ≈183 MiB = 45 ×(64×128×128×4 B + 72 KiB),KV 30 KiB/token,≈6,250 token;K3 一份 ≈430 MiB = 69 ×(96×128×128×4 B + 3×12,288×3×2 B),MLA 24 × 576 × 2 B ≈ 27 KiB/token,≈1.6 万 token,状态按 fp32 计,本课推导vLLM 博客 2026-07-27 Kimi K3(Agentic serving: smarter cache retention policies;PR #43447、#45845、#37898、#47782);vLLM 博客 2026-07-22 Kimi K3 preview;LMSYS《Unified Radix Cache》2026-08-11;PyTorch 博客《Hybrid Models Meet SGLang》2025-12-03、《Hybrid Models as First-Class Citizens in vLLM》2025-11-05;SGLang 源码 arg_groups/fields/exec_.py、arg_groups/fields/schedule.py、mem_cache/unified_cache/components/mamba.py、mem_cache/kv_cache_configurator.py、mem_cache/mamba_checkpoint_pool.py;Qwen3.5-397B-A17B 与 Kimi K3 config.json。2026-10-19 核对
L97 补充 · 13.1 图 fig-s13-snap:int8 快照 ≈48 MiB,只压递归状态;128K 前缀 KV 131,072 × 30 KiB = 3.75 GiB;只留末尾 1 份 ≈0.18 GiB(5%)、再每 32K 一份共 4 份 ≈0.72 GiB(19%)、每 256 都留 512 份 ≈92 GiB(约 24 倍)。全部本课推导Qwen3.5-397B-A17B config.json;SGLang mem_cache/mamba_checkpoint_pool.py(conv 状态保持原 dtype);留存策略见上一行 vLLM K3 博客。2026-10-19 核对
L98 补充 · 14 节里 tpu-inference 的对照数:冷启动约 7 min;PD 每请求约 349 MB、单并发 0.95 倍(第四节另引块池约 3.5 倍)tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:20-33、50-54、60-70、750、789-791。2026-10-18 核对
L99 补充 · 14 节主线(vLLM-TorchTPU,2026-10-20 开源):v7x-8 = 4 芯片 8 TensorCore、768 GiB;GDN 状态约 189 MB/序列(FP32);GDN 状态换视图后指令包 366→87;prefill 四刀 1.0565 × 1.0945 × 1.2553 × 1.091 ≈ 1.58、实测约 1.59;收尾 PCP8 ÷ DP8 ≈ 0.89;不排序 MoE daily 约 +12.5%;BF16 状态 KV 池 +12%、同时在跑 208→232私有实测,按起点 = 1.00 换算成指数;768 GiB = 4 × 192 GiB、189 MB = 45 层 × 64 头 × 128 × 128 × 4 B、四百来 GB 按 397B × 1 字节估,本课推导;「PCP 为延迟」为本课推测。2026-10-20 栈已开源,名字与 PR 出处见 R101。2026-10-18 核对
L100 补充 · 3.2「一步里装了什么」:vLLM V1 开 chunked prefill 时先排全部 decode、预算有剩再排 prefill、装不下就切;SGLang --enable-mixed-chunk 默认关,即一步不混 prefill 和 decode;图与动画的预算、人数、长度均为示意docs.vllm.ai Optimization and Tuning 页 Chunked Prefill 一节;docs.sglang.ai Server Arguments 页。2026-10-18 核对
L101 补充 · 6.3 大 EP 定义:TensorRT-LLM 口径 EP > 8;DeepSeek 线上 decode EP144/DP144、18 节点、32 个冗余专家、每卡 2 路由 + 1 共享;prefill EP32、4 节点、每卡 9 + 1;V3 技术报告 decode 写 EP320、40 节点、每卡 1 个专家TensorRT-LLM 博客「Scaling Expert Parallelism in TensorRT-LLM」(「large-scale EP (here means EP > 8)」);DeepSeek open-infra-index「Day 6 · Inference System Overview」;arXiv 2412.19437 §3.4.2。2026-10-18 核对
L102 补充 · 6.3 大 EP 为什么省(含动画 BigEP):每份专家行数 = EP × 32 × 8 ÷ 份数,EP8 8 行、EP144 128 行;一个路由专家 44.0M 参数(FP8 44 MB);每层每卡读 1,409 对 88 MB(16×);路由专家占显存 81.7 对 5.1 GB;V3 671 GB > 8 × 80 GB;两条好处为 DeepSeek 原话本课推导:3 × 7168 × 2048 = 44,040,192;8 × 32 × 8 ÷ 256、144 × 32 × 8 ÷ 288;32 × 44.04、2 × 44.04 MB;× 58 层;断言在 manim/topic06-anim-serve.py 的 bep_row 与 topic06-fig-bigep.py。DeepSeek-V3 config.json(hidden 7168、moe_intermediate_size 2048、first_k_dense_replace 3、61 层);Day 6(「EP significantly scales the batch size…」「reducing memory access demands」)
L103 补充 · 6.4 网络:DeepEP 低延迟 kernel EP8→256 分发 77→194 µs、汇回 114→360 µs;(194 + 360) × 58 ≈ 32 ms;每 token 最多发约 57 KB(FP8)、收约 115 KB(BF16);机内 NVLink、全集群 IB 全互连、decode 用 IBGDA;训练限每 token 最多 4 个节点;llm-d 要求 IB/RoCE 全互连与 GPU 发起 RDMA;SGLang GB200 纯 NVLink 可关双微批、decode 48 卡;Ironwood 64 颗 3D 环面、每颗 6 邻居、光交换到 9,216 颗、再往外 DCN;MaxText dcn_expert_parallelism 存在但未推荐;公开 TPU 推理为 DEP8、all-gather + reduce-scatterDeepEP v1.2.1 README 表格;arXiv 2412.19437 §2.1.2、§3.2.2、§3.4;llm-d wide-expert-parallelism 文档;vLLM expert_parallel_deployment 文档排障一节;LMSYS 2025-06-16「GB200 NVL72 Part I」、2025-09-25「Part II」(「For decode, we use 48 ranks」);Google Cloud 博客「Inside the Ironwood TPU codesigned AI stack」;MaxText base.yml;SemiAnalysis「TPU InferenceX」。本课推导:8 × 7168 × 1 B、× 2 B;环面远处要转发。2026-10-18 核对
L104 补充 · 6.4 代价:decode 每卡 32 token 时双微批慢 27%;一张卡过载拖慢全系统;一个 DP rank 故障整组下线、最多 128 卡;没有容错会抬高故障率;DeepEP 常规与低延迟模式不能同组 → PD 分离;decode 靠 CUDA Graph,DeepEP 常规模式不兼容(LMSYS 2025-05-05);TensorRT-LLM 因 DeepEP 并非所有场景都兼容 CUDA Graph,在 GB200 上自写通信 kernel(blog4)LMSYS 2025-05-05 大规模 EP 一文(TBO 一节、PD 一节);Day 6;Anyscale 博客「dp-group-fault-tolerance-vllm-wideep-ray-serve-llm」(「up to 128 GPUs」);TensorRT-LLM 博客 blog4(容错与 CUDA Graph 两段)。2026-10-18 核对
L105 补充 · 3.2:门口与车上(每人输出 1,000 字、车上 300 人 → 平均每 3.3 步补 1 人);KV 读取对比:V3 每 token KV 70,272 B(61 层,bf16 MLA),FlashAttention query 块按 128 计,一段 4K 因果 prefill 读 128×(1+2+…+32)=67,584 个 token 的 KV,两段 9.50 GB;300 人×4,096 历史 86.35 GB;比值 9.1×,每格 1.16 MB 对 288 MB,约 248×。1.1 删去封顶线一句本课推导;query 块 128 为假设(FlashAttention 常用块长)。2026-10-18
L106 补充 · 3.2 混跑过屋脊点但出字看 decode 人数;6.4 每 token 每步通信上限(57+115)KB × 58 ≈ 10 MB、对 4K 上下文 KV 288 MB、每字等 2 × 58 = 116 次;6.5 微批内串行、decode 通信不占 SM、权重一步读两次、跨层预取本课推导(通信量、读两次);decode 通信不占 SM 见 deepseek-ai/profile-data README(Decoding 段:RDMA 发出后 SM 全部释放);节点内转发去重见 DeepEP README;跨层预取见 14.4 K3 对照。2026-10-18
L107 补充 · 11.3 草稿三步:DFlash 一次前向出整块、加速比最多是 EAGLE-3 的 2.5 倍;EAGLE-3 只在草稿入口用大模型特征,DFlash 注入每层草稿 KVDFlash arXiv 2602.06036(v1 2026-02-05,ICML 2026)摘要;lmsys.org/blog/2026-06-15-next-generation-speculative-decoding-dflash-v2(「EAGLE-3 uses target model features only at the input…DFlash instead injects target features into the KV cache of every draft layer」)。2026-10-18 核对
L108 补充 · 11.3 DSpark:骨干是 DFlash;「of course/no problem → of problem」例;Markov 顺序头;接受长度比 EAGLE-3 高 30.9/26.7/30.0%、比 DFlash 高 16.3/18.4/18.3%(Qwen3 4B/8B/14B);batch 128 草稿 4→16 个整轮只比 DFlash 多 0.2–1.3%;置信度头、前缀存活概率连乘、全批排序贪心调度;MTP-3/5 高并发拉低总吞吐所以线上只开 MTP-1(验 2 个);DSpark-5 并发 <200 时每请求验约 4–6 个;V4-preview 两周后替下 MTP-1;V4-Flash 60–85%、V4-Pro 57–78%arXiv 2607.05147(v1 2026-07-06)HTML 版 §3、§4、§5;vLLM API 文档 vllm/models/deepseek_v4/nvidia/dspark(「reuses the target model's architecture similarly to MTP」,load_weights 读 mtp.{0,1,2}.*);2026-10-18 核对
L110 补充 · 0.1 引擎地图:Triton Inference Server 现名 Dynamo-Triton(通用模型服务器),LLM 专项交给 Dynamo;TGI 维护模式、官方推荐 vLLM、SGLang、llama.cpp、MLXdeveloper.nvidia.com/dynamo-triton(「NVIDIA Dynamo-Triton, formerly NVIDIA Triton Inference Server」);github.com/huggingface/text-generation-inference README(「now in maintenance mode」)。2026-10-18 核对
R92 补充 · 15 节:vLLM FP8(W8A8)2×H100 跑 Llama 3 70B,每字间隔最多降到未量化的 1/2;NVFP4 KV 前缀命中率最多高 20%(Qwen3-Coder-480B)Red Hat Developer 博客 2024-07-15(「Up to 2x ITL improvement … Llama 3 70B」);NVIDIA 博客 NVFP4 KV(「up to 20% higher cache hit rate」)。2026-10-18 核对
R93 补充 · 5 节:RPA 2025 年 2 月进 vLLM-TPUarXiv 2604.15464 §4.4(「Since its integration into vLLM-TPU … in February 2025」)。2026-10-18 核对
R94 补充 · 8.5:GB200 NVL72 上 PD 配法,Part I decode 12 节点 48 卡、prefill 用剩下的 2 节点,真实部署类比 18 节点里 6P+12D;decode 7,583 tok/s/卡,是 H100 的 2.7×(H100 柱含模拟 MTP;基线是 2025-05 那次 96 张 H100 的 PD+大 EP)lmsys.org/blog/2025-06-16-gb200-part-1(「we use 12 nodes for decode and the remaining for prefill」);并行配置见 github.com/sgl-project/sglang/issues/7227
R94 补充 · 8.5:Part II decode 48 rank,prefill 每实例 4 卡(高精度)或 2 卡(低精度);batch 1,408(2K)/768(4K);26,156/13,386 是 3.8×/4.8×,原精度 18,471/9,087;注意力 1.8×、GEMM 最多 1.9×;CPU–GPU 900 GB/s(双向)卸载权重以缩小 EPlmsys.org/blog/2025-09-25-gb200-part-2(「for prefill, we use 4 ranks per instance for high-precision and 2 for low-precision」、「utilize GB200's fast bandwidth between CPUs and GPUs (900GB/s, bidirectional) to offload weights」);复现见 github.com/sgl-project/sglang/issues/10903(低精度 prefill 压测命令写 --input-len 4096,与博客正文「2000-token input」有出入,课件按博客正文)
R94 补充 · 8.5:P/D 分开量,另一边假设资源无限,decode 用 slow-down 撑满;H100 prefill 是 4 节点 EP32lmsys.org/blog/2025-05-05-large-scale-ep(「assuming unlimited resources for the non-tested phase」)
R94 补充 · 8.5:2,000 进 100 出时 prefill 卡数约是 decode 的 10 倍,输出约 1,000 字才接近 1:1本课推导:2,000 ÷ 26,156 ≈ 0.076 卡·秒;100 ÷ 13,386 ≈ 0.0075 卡·秒
R95 补充 · 6.4:DeepEP 纯 NVLink 模式靠把远端显存映射进本卡地址空间;纯 NVLink 低延迟让双微批可关lmsys.org/blog/2025-06-16-gb200-part-1(「The new NVLink-only environment is supported by mapping remote GPU memory to the local virtual address space」「This allows two-batch overlap to be disabled, resulting in both kernel performance speedup and avoiding waste when overlapped communication is longer than computation」)
R95 补充 · 6.4:Part I decode 7,583 tok/s 每卡,对 H100 每卡 2.7×(2K 输入);14 个节点里 12 个跑 decode;slow-down 接口让 decode 跑满;H100 基线一组开了模拟 MTP;许多 kernel 未吃满同上(「7,583 tokens per second per GPU … 2.7x speedup compared to the H100 per GPU … for 2,000-token input lengths」「The yellow baseline bar indicates simulated MTP」「Many kernels have yet to fully saturate」)
R95 补充 · 6.4 / 6.6:decode 48 卡,每卡 768 请求,共 36,864;32 份冗余专家github.com/sgl-project/sglang/issues/7227(--nnodes 12 --tp-size 48 --dp-size 48 --enable-dp-attention … --max-running-requests 36864 … --cuda-graph-bs 768 … --ep-num-redundant-experts 32)
R95 补充 · 6.4:FP8 KV 让 decode 访存约减半;batch 2K 输入 1408、4K 输入 768,2K 输入从 1408 降到 768 约掉一成(原文只写 batch size,按每卡读是本课推断,与 Part I 的 768 × 48 = 36,864 口径一致);NVFP4 融进 DeepEP,分发流量减半;prefill 缩 EP 加卸载(900 GB/s 双向),每实例 4 卡或 2 卡lmsys.org/blog/2025-09-25-gb200-part-2(「roughly halves the memory access pressure in decode」「768 for 4k ISL and 1408 for 2k ISL … reduces performances by roughly one tenth」「halving the required network traffic」「minimizes the explosion radius … reduce the time wasted waiting for the slowest rank」)
R95 补充 · 6.5:细粒度重叠,汇回通信叠下投影 GEMM 和共享专家同上(「we overlap the combine communication with both the down GEMM and the shared experts」)
R96 补充 · 5.1:DSA prefill 的 gather 为取不到 2048 个不同行物化约 419 万行,稀疏路径 96.3% 设备时间在 gather;位图在 SparseCore 上建,带掩码稠密注意力与稀疏等价;4K 首 token 1338.81 → 729.04 ms;KV ≤ 9216 走 masked-dense公开工程博客「Hy4 在 TPU v7 上的推理性能优化」篇(2026-10-08,更新于 10-09)(「物化出约 419 万行,冗余 2048 倍,稀疏路径设备时间的 96.3% 都花在 gather 上」「把 top-k 结果写成一张位图(在 SparseCore 上完成)」「4K 输入的 TTFT 从 1338.81 ms 降到 729.04 ms」「masked-dense(KV ≤ 9216 时),否则 sparse」)
R96 补充 · 5.1:Hy4 78 层只 21 层算 top-k、其余共用;位图跨层复用 +5.6%同上(「位图跨层复用:78 层中只有 21 层计算 top-k,其余共用」「+5.6%」,并发 32)
R96 补充 · 14.1:64 token 分块循环追踪时展开 → fori_loop;attention sink 闭包常量 → 运行时输入;同一形状键 12–14 份程序;跨 rank 回放;95.1 分钟 → 约 14 分钟;图指纹看不见闭包常量、回滚换缓存根目录公开工程博客「Hy4 在 TPU v7 上的冷编译优化」系列:第一篇(2026-10-01,更新于 10-09)(「冷编译从 95.1 分钟降到约 14 分钟(mnbt 2048,两次测量 819 秒和 842 秒)」「同一形状键下有 12–14 份程序」「回滚时更换缓存根目录」)
R96 补充 · 14.1:跨 DP 回放,Qwen3.5 DP8 权重加载完成到服务就绪 741 s → 270 s同系列第二篇(2026-10-09)(「Qwen3.5 DP8 从 741 秒降到 270 秒」;741 为单次、270 为三次均值)
R97 补充 · 14.1–14.3 深讲:Qwen3.5 全注意力层是 GQA,32 个查询头、2 个 KV 头、head_dim 256;GDN 64 个 V 头、16 个 QK 头、head_dim 128;TP8 摊到每 device 0.25 个头,复制让并发只到约 200(计划 512);DP 每核 --max-num-seqs=64;all-to-all「massive, unpredictable network routing overhead」;分层 reduce-scatter 片内共享内存比芯片间 ICI 快 6 倍、芯片间递归倍增、切 2–4 个微批防 VMEM 溢出;SparseCore「optimized for indirect addressing」、收拢到连续缓冲区;SSM 状态 FP32 → BF16 向量单元吞吐翻倍;两种状态对齐放一起存、少补齐不碎片https://developers.googleblog.com/systems-engineering-playbook-optimizing-qwen-35-397b-moe-on-ironwood-tpu7x/(§1、§3、§A–§D,2026-10-19 核对);本课推导:32 ÷ 2 = 16、8 ÷ 2 = 4、8 × 64 = 512、64 ÷ 8 = 8、[81920, 4096] 的 81920 = 8 × 1,024 × 10、每 token KV 15 × 2 × 256 × 2 × 2 = 30,720 字节
R97 补充 · 14.1、14.3 深讲:kernel 搬之外的阶段与起步收尾带宽闲置、每个 kernel 重来一遍;megakernel 去掉边界后权重搬运「can be issued as early as on-chip storage allows」;XLA「schedules chains of operations as a unit and reserves the right to reorder them or reclaim their buffers」;make_async_copy().start()/.wait();run_scoped 管 VMEM 分配的生存期;单程序不分 gridhttps://inferact.ai/blog/tpu-megakernels(2026-10-19 核对)
R97 补充 · 14.1–14.3 深讲(本课推导):TP2 后 1 个 KV 头,按头维打包每 token 每层 BF16/FP8 都占 256 × 4 = 1,024 字节,序列维最内时 FP8 占 512;统一池 1K 请求状态占比约 86%、64K 约 9%,分池按 64K 定比例时 1K 流量下 KV 池约九成八闲置;整层融合上限 1 ÷ 0.8 = 1.25 对实测 ×1.26;SMEM 是 VMEM 的 1/64;64 MiB ≈ 67.11 MB,67.11 − 31.29 ≈ 35.8 MB本课推导:32 位格子装 2 个 BF16 或 4 个 FP8(tile 规则同第 195 行);183 MiB ÷ 30 KiB ≈ 6,250(13.2),6,250 ÷ (6,250 + 1,024) ≈ 0.86、6,250 ÷ (6,250 + 65,536) ≈ 0.087,0.09 ÷ 183 × 30 ≈ 0.015 对 0.91;两成取自第 248 行;64 ÷ 1 = 64;64 × 1,048,576 = 67,108,864
R98 补充 · 7.1(L200 试讲回填):K3 并发 1 每 token TP8 4K 11.1 ms → 128K 12.0 ms,DCP8 15.2 → 15.3 ms;4K 关 symm-mem 的 TP8 15.1 ms,DCP8 起点高约 4 ms 基本是 symm-mem 损失;官方 Peak Capacity(+--dcp-size 8)并发上限 +72%、引擎吞吐不变、ITL ×1.8;TP8 每卡读整份 KV、DCP8 读 1/8;Meta 叫 pass-KV/pass-Q,Helix 叫 KVPSGLANG-K3-RUNBOOK.md 宽表 :924(TP8 4K)、:940(TP8 128K)、:928(DCP8 4K)、:941(DCP8 128K)、:929(B-nosymm-noAR 15.1 ms);:1309(Peak Capacity);arXiv 2411.01783 §3.4;arXiv 2507.07120;4 ms 归因与「读 1/8」本课推导
R98 补充 · 11.3(L200 试讲回填):DFlash 一块 16 格(LLaMA 3.1 为 10),首格是上一轮确认的字、其余为 mask;草稿 5 层(Qwen3 Coder 为 8),共享并冻结 embedding 与 LM head;目标模型 5 层隐状态拼接投影后注入每层草稿 KV;块内双向注意力、单次前向;训练随机采 anchor 位置、盖住后续格arXiv 2602.06036 §4、§5
R99 补充 · 0.1 时间轴:去掉右端「GB300 × V4-Pro」菱形(结果不是招数),5.1× 挪到图下折叠表说明;补模型侧 ⑫ 线性注意力混合(2025-09 起,到 2026)、⑬ 循环模型(2026-10)。两点按进入主流大模型的时间放,思路更早Qwen3-Next 博客 2025-09-10、vLLM 博客 2025-09-11(「Gated DeltaNet (linear attention)」);Koi-4B 见 R86 行;Dory 4B 见 R86 行;更早:H3 arXiv 2212.14052、Jamba arXiv 2403.19887、Universal Transformers arXiv 1807.03819
R100 补充 · 13.2 SWA Bounded Replay:V4 滑窗 KV 落盘、未命中重算「层数 × 窗口」、占持久缓存近一半;V4.1 滑窗 KV 只留产出机内存,TTL 约 180 s、命中率 98% 以上;回放命中前缀末 128 token、注意力截在回放段内、得近似滑窗 KV;命中长度 L1 或 L1 − 128;decoder 精确重建 20 层 × 2,560 token → prompt 末 128,prefill 总计算量近乎减半知乎专栏 DeepSeek「DeepSeek V4.1 Flash 大规模推理部署实践」(zhuanlan.zhihu.com/p/2095560295930508953,2026-10-20)(「只重算最近 128 个 token,并把注意力窗口截断在重算段内」「重算得到近似的 SWA KVCache」「总 prefill 计算量近乎减半」);github.com/deepseek-ai/DeepInfer README(Decoder SWA bounded replay,默认 DEEPINFER_YOCO_PREFILL_KEEP_TOKENS=140,须覆盖窗口+最大回退;文中 ring 为 128+6=134)。2026-10-20 核对
R100 补充 · 4.4 不分层:块 KV 全落独立 3FS 集群、约 100 PiB SSD;TTL agent 3 天、chatbot 7 天,chatbot 3 天左右命中率掉 0.5%–1%;不做前缀亲和路由;计算节点故障率比存储高一个数量级以上;命中三段只有哈希链匹配在关键路径;换入用 GDR、不占 SM;峰值读 10 TiB/s、写约 850 GiB/s知乎专栏 DeepSeek「DeepSeek V4.1 Flash 大规模推理部署实践」(zhuanlan.zhihu.com/p/2095560295930508953,2026-10-20)(「相比多级存储系统,独立的存储集群使得所有 prefill 机器能命中任何前缀」「计算节点故障率比存储高数量级以上」)。KV 系统未开源(github.com/deepseek-ai/DeepInfer README「not included in this release」)。2026-10-20 核对
R100 补充 · 6.4 容错:decode EP64–128;重启分钟级,靠配额冗余+请求级重新路由;按健康卡数重定 EP;下线宽限 1 min 后剩余请求连 KV 转发。9.1 扩缩:prefill 按未命中 token 数、decode 按在算请求数,有上下界与限速,配额占用 > 0.8 禁止缩容,留 ready 机器作库存。14.3 共享存储免前缀路由知乎专栏 DeepSeek「DeepSeek V4.1 Flash 大规模推理部署实践」(zhuanlan.zhihu.com/p/2095560295930508953,2026-10-20)「自动扩缩容」节(「平台按当前健康的所有卡重新确定EP大小」「宽限期(1 min)」「配额占用率高于 0.8 时禁止缩容」)。2026-10-20 核对
R101 补充 · 14 节改写(TorchTPU 开源):主线栈具名 vLLM-TorchTPU(TorchTPU 后端),同时公布 SGLang-TorchTPU;编译回放 #1810(已合入)、跨 DP #1708(评审中);参考配方 #989 并发 4–32 TP8、64–1,024 DP8、全程 EP8;#384 并发 32 TP8→DP4×TP2 吞吐 −2.65%、TPOT −17.93%;统一池 #106 起用、#170 默认;PCP 下 GDN 状态本地化 #65、交换改 all-to-all #129;KV 序列维布局 #504 移植、#608 接统一池;SparseCore 目的地优先合并 #317(单层 profile 合并 −39.7%、MoE 流程 −13.8%);分段流水 #529;整层 Pallas #543(reduce-scatter 每层 1,190 µs、占设备时间 22%;同量 all-gather 36 µs;c128 端到端 10,614→21,297 tok/s);小 batch one-hot #371/#509、小 batch kernel #1678;BF16 状态 #1458(KV +12.2%、5,343→5,828 tok/s);Pallas 经 jax.export 包成 torch 算子(#543 正文)github.com/vllm-project/vllm-torchtpu 各 PR 正文与 main 分支提交记录;github.com/google-pytorch/torch_tpu README;github.com/sgl-project/sglang-torchtpu;Google Cloud 博客 2026-10-20 TorchTPU 发布文。PR 绝对数与梯子指数测法不同,不互相换算。2026-10-20 核对
R102 补充 · 第十二节「为什么压了不掉点」一:收敛处梯度近零,损失按 ½ΔwᵀHΔw 涨;Hessian 特征值大多在零附近、少数离群;GPTQ 用近似二阶信息AdaRound arXiv 2004.10568(「we can also ignore the gradient term as it will be close to 0」);Sagun 等 arXiv 1706.04454(bulk 集中在零附近 + 离群);GPTQ arXiv 2210.17323 摘要(「based on approximate second-order information」)。2026-10-21 核对
R102 补充 · 第十二节 二:QuIP 不相干条件、首个可用 2 bit;LLM.int8() 离群特征;Super Weight 剪一个参数困惑度涨三个数量级arXiv 2307.13304 摘要;arXiv 2208.07339;arXiv 2411.07191 摘要。2026-10-21 核对;「误差大半抵消」是本课解释
R102 补充 · 第十二节 三:MoE 专家层比稠密 FFN 更扛量化、2 bit 专家可用;准确率相近而答案翻转,建议看 KL 和 flipsMoQE arXiv 2310.02410 摘要(「expert layers in MoE models are much more robust to the quantization than conventional feedforward networks (FFN) layers」);Dutta 等 arXiv 2407.09141 摘要。2026-10-21 核对
R102 补充 · 第十二节 四:eδ 放大;DeepSeek-V3 FP8 训练留高精度的组件;INT8 注意力 Llama2 MMLU 25.5%、K 按通道离群;KIVI K 按通道 V 按 tokeneδ 本课推导;arXiv 2412.19437 §3.3.1(「due to their sensitivity to low-precision computations」,训练场景);SageAttention arXiv 2410.02367 引言(「Llama2 only achieves a random-guessing-level accuracy of 25.5% on the MMLU dataset with INT8 attention」「The matrix K exhibits a significant channel-wise outlier」);KIVI arXiv 2402.02750。2026-10-21 核对
R102 补充 · 第十二节 边界:推理模型 W8A8、W4A16 基本无损,更低位风险明显,与模型大小、来源、题目难度有关arXiv 2504.04823 摘要(COLM 2025);「小翻转在长思维链上累积」是本课推测。2026-10-21 核对
R103 补充 · 11.3 DSpark 数据图:Qwen3-4B 逐位条件接受率 EAGLE-3 闲聊 0.53→0.74、DFlash 代码 0.87→0.78、闲聊 0.72→0.63(「deeper into the block」,未写位次);数学第 1 位 EAGLE-3 0.81、DFlash 0.88、DSpark 0.93;表 1 Qwen3-8B 九个基准接受长度(三类平均为本课计算,九基准平均复现 26.7%/18.4%,图脚本 assert);温度 1.0、块长 7、草稿 5 层(EAGLE-3 1 层)arXiv 2607.05147 HTML 版 §4.1、§4.3.1、Figure 2、Table 1。2026-10-21 核对
R103 补充 · 11.3 两支 DSpark 动画:Algorithm 1(ar,j 连乘、全批按存活概率排序、Θ = τ·SPS(B)、吞吐不升即停以保无损);线上 §5.2 去掉提前停止做全局搜索(SPS 锯齿),用两步之前的置信度定截断长度 K、配合 ZOS 异步;动画里的分数、把握、吞吐表(一步耗时 = 固定 100/4 + 每 token 1)为示意,14 个/7 个由脚本按 Algorithm 1 现算并 assertarXiv 2607.05147 §3.2.2 Algorithm 1、§5.2(「we remove the early-stopping break」「using the confidence head outputs from two steps prior」)、附录 A。2026-10-21 核对
2026-10-22 补充 · 3.3 SGLang 重叠调度:先发这一步、再处理上一步结果;下一步的输入 token 经显卡上的占位接力(FutureMap),结束判断晚一步SGLang 源码 commit 4eb606b(2026-10-17):python/sglang/srt/managers/scheduler.py event_loop_overlap(「Launch the current batch」在「Process the last batch」之前);python/sglang/srt/managers/overlap_utils.py FutureMap(「relay for cross-iter values」)
2026-10-22 补充 · 4.2 V4-Pro 层表:61 层 = 30 层 ratio 4(CSA)+ 31 层 ratio 128(HCA),sliding_window 128,index_topk 1024,num_key_value_heads 1、head_dim 512;全长池九成七在 CSA 层(30÷4 = 7.5 对 31÷128 ≈ 0.24,本课推导,只按 KV 条数、不含索引器)huggingface.co/deepseek-ai/DeepSeek-V4-Pro config.json(compress_ratios 共 62 项:31 个 128、30 个 4、末尾 1 个 0,2026-10-22 读取;末尾那个 0 本课未核实对应哪一层)
2026-10-22 补充 · 4.2 两池的计价与自动配比:全长池每 token 计 CSA 层 1/4 条+索引器、HCA 层 1/128 条;滑窗池每槽计全部层原样 KV;每请求滑窗最坏槽数 = 窗口 + 淘汰间隔 × 草稿数 + 页 + 解码预留,淘汰间隔默认 128;不显式传比例且给了每卡请求上限时走 cap 模式,否则默认比例 0.1。「最优比例 ≈ 每请求固定滑窗槽 ÷ 平均长度」「4,600 × 0.15 ≈ 700」是本课推导SGLang 源码 commit 4eb606b(2026-10-17):python/sglang/srt/model_executor/pool_configurator.py(DSV4PoolConfigurator、_compressed_bytes_per_full_token、_resolve_swa_cap_tokens、compute_swa_request_cap、DSV4_DEFAULT_SWA_FULL_TOKENS_RATIO = 0.1);python/sglang/srt/environ.py SGLANG_SWA_EVICTION_INTERVAL = EnvInt(128)。我们七月的实测用的是显式比例(gpu/inference/a4x-max/deepseek-v4/SGLANG-V4PRO-RUNBOOK.md §11.5)
2026-10-22 补充 · 7.1/L200 第五节:K3 开 DCP 时 SGLang 强制关 --enable-symm-mem,理由是 decode CUDA graph 正确性;symm-mem bs=1 +35%;TP8 每 token 约 186 次 all-reduce(93 层 × 2,runbook 推算);V3 提问 128 × 192 = 24,576 对 MLA 一行 576,约 43 倍(本课推导)SGLang 源码 commit 4eb606b:python/sglang/srt/arg_groups/model_overrides/kimi_k3.py(「Kimi-K3 DCP disables --enable-symm-mem due to decode CUDA graph correctness issues」);SGLANG-K3-RUNBOOK.md §11.0.4、§11.2;DeepSeek-V3 config(num_attention_heads 128、qk_nope 128+rope 64、kv_lora_rank 512)
2026-10-22 补充 · 7.1/L200 第五节备答:DCP 不传 1536 维压缩提问。SGLang 各卡算本卡头的 q(q_nope、q_rope),在 DCP 组 all-gather 到全部头;若改传压缩 q 由各卡自解压,每层每卡多读 7/8 ×(1536×128×192 + 128×128×512)≈ 4,000 万参数,对比收提问 7/8 × 128 × 576 × 2 B ≈ 129 KB/token,交叉点约 300 token(本课推导,FP8 权重按 1 字节)SGLang 源码 commit 4eb606b:python/sglang/srt/models/deepseek_v2.py(「q_nope, q_rope is all gathered from dcp ranks」)、layers/attention/trtllm_mla_backend.py(「query all-gathered across the DCP」);DeepSeek-V3 config(q_lora_rank 1536、128 头、qk_nope 128、rope 64、kv_lora_rank 512)
2026-10-22 补充 · 12.2 我们在 TPU v7 上的 FP4:R1/V3.2/GLM-5.1 只压路由专家、注意力 FP8;FP8 按 128×128 块缩放解回 FP32 → 每输出通道 abs_max ÷ fp4_max → float4_e2m1fn 四舍五入,无校准;FP8 作存盘中转(FP4 16 值是 FP8 子集);CPU 12 进程 R1 58 层约 28 min;R1 专家 FP8 101.8 GB/device 超 94.75 GB、FP4 60.9 GB;R1 p2048 7,309 tok/s(1,827/chip);GLM-5.1 专家 27.5 GB/device、总 58.43 GB(61.6%)、剩 36 GB;K2.6 原生 INT4 W4A16(compressed-tensors,group 32 对称),packed uint32 常驻 HBM、片上 bitcast,单台 v7x-8 前向 105 GB OOM、改 v7x-16本仓库 tpu/tpu-inference/DeepSeek-R1-671B-FP4/README.md(关键性能表、硬件表、Step 4 流水线)与 gen_fp4_cache_cpu_parallel.py 文件头;tpu/tpu-inference/GLM-5.1-754B-FP4/README.md(HBM 表);tpu/tpu-inference/Kimi-K2.6-1T-A32B-INT4/README.md(已验证性能表、架构对比表、已知问题 1)
2026-10-22 L200→L300 回填:①单芯片 bf16 口径 0.032 ms、权重按 2 字节读 10 ms(本课推导,比例同为 0.32%);② 999/886 × 77.7/85.3 ≈ 1.027(本课推导);③ MHA 128K 一人 3,997,696 × 131,072 ≈ 524 GB ≈ 488 GiB(本课推导);④ K3 config:num_attention_heads 96、linear_attn_config.num_heads 96、linear head_dim 128;⑤ 300 × 256 ÷ 8 ≈ 9,600、32 卡每卡约 300、128 卡约 75(本课推导);⑥ vLLM V4-Pro 那组两边 DSpark、num_speculative_tokens=7;⑦ vLLM DCP ag_rs 三次通信、a2a 3→2、dcp_q_replicate;V3 183、K3 72 次(本课按层数乘);⑧ symm-mem 87.8 对 64.9 tok/s;⑨ Meta 负载均衡 2N 块首尾配对;⑩ 均匀分布一百个数的反例;⑪ 成本降到约五分之一的分母前提①②③⑤ 本课推导;④ huggingface.co/moonshotai/Kimi-K3 config.json(2026-10-22 读取);⑥ gpu/inference/a4x-max/deepseek-v4/VLLM-V4PRO-RUNBOOK.md:52;⑦ vLLM 主干 vllm/config/parallel.py、vllm/v1/attention/ops/dcp.py(2026-10-17);⑧ SGLANG-K3-RUNBOOK.md §11.0.4;⑨ arXiv 2411.01783(Meta CP 推理论文,load-balanced sharding);⑩ Google Research「Looking back at speculative decoding」;⑪ 本课推导(2.3 公式)

← 回 课程总纲 · 上一讲 专题五 · 并行策略
本页由 Courses/tools/topic06-build.py 拼装,正文在 topic06_s*.py。