每个数字的出处在文末台账;自己推出来的数,都标了「本课推导」。
每一行勾上这种并行训练一步里要用到的通信,可以勾不止一个。五行都勾完再点「对答案」。
| 并行方式 | AllReduce | AllGather | ReduceScatter | AllToAll | 一对一收发 |
|---|---|---|---|---|---|
| DP 数据并行每张卡一份完整模型,各吃一份数据 | |||||
| FSDP(ZeRO-3)权重、梯度、优化器状态全切开 | |||||
| TP 张量并行一层里的矩阵切给几张卡 | |||||
| PP 流水线并行按层切成几段 stage | |||||
| EP 专家并行MoE 的专家分到不同卡 |
| 并行方式 | 答案 | 用在哪 |
|---|---|---|
| DP | AllReduce | 每步把各卡的梯度加起来、人人一份。AllReduce 本来就能拆成 ReduceScatter + AllGather,拆开勾也算对 |
| FSDP | AllGather + ReduceScatter | 前向用到哪层先 AllGather 拼回权重,反向再拼一次;算完的梯度 ReduceScatter,各卡只留自己那块 |
| TP | AllReduce | 每层前向两次、反向两次,把切开的矩阵乘结果加回来;配序列并行时换成 AllGather + ReduceScatter,也算对 |
| PP | 一对一收发 | 只在相邻 stage 之间传激活(反向传梯度),不需要全员一起 |
| EP | AllToAll | 每层两次:把 token 派给它选中的专家,算完再原路收回 |
推理只剩前向,这张表还能用,但轻重变了:TP 每层那几次 AllReduce 数据不多,卡的是延迟(5.3、第七节);EP 也不一定走 AllToAll —— 公开的 TPU 推理专家那步用的是 AllGather 加 ReduceScatter(6.4)。
训练时答案已知,整段序列一起算,只看吞吐;推理得一个字一个字往外吐,还要守延迟。 吞 prompt 那一段(prefill)还像训练的前向,吃算力;往外吐字那一段(decode)每步只出一个字,吃带宽。 一次请求里,前后两段要的硬件正好相反。
做法:模型分三段。前段、后段各跑一遍,中间一段共享的层反复跑 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「回到开场新闻」。
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。
首次公开: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。年内等距排,只表先后。
| 环 | 首次公开 | 谁先做 | 卡在哪 → 怎么解 | 省了多少(对谁) | 解完又冒出什么 | 节 |
|---|---|---|---|---|---|---|
| ① | 2022 | Orca 论文 | 整批人陪最慢的那个写完 → 连续批,每步都能进出 | 同延迟吞吐 36.9×(对 FasterTransformer) | 座位数归 KV 管,按最长预留,真用上的两到近四成 | 三 |
| ② | 2022 → 2026 | GPTQ 等量化、megakernel | 大 batch 下能省的只剩字节 → FP8/FP4、合 kernel | Llama 3 70B FP8 权重,每字间隔最好降到 BF16 的 1/2 | v7 上 FP4 推测只能存不能算;INT4 少了「减 8」会吐乱词 | 十二 |
| ③ | 2022 → 2025 | Google、DeepMind 论文;DeepSeek MTP、EAGLE-3 | 思考题动辄几千 token → 投机解码/MTP,一趟验几个字 | MTP 约 1.8×;EAGLE-3 单请求最多 6.5×(都对不投机) | 并发大、上下文长、开 DEP 时收益缩水,甚至倒亏 | 十一 |
| ④ | 2023 → 2025 | GQA 论文、DeepSeek | 每条 KV 太厚 → GQA、MLA,再到 DSA 只挑一部分读 | GQA 约 ÷8、MLA 约 ÷57(本课推导);DSA 每字只读 2,048 条 | MLA 全层一份 KV,TP 切不开,开几路就复制几份 | 四 |
| ⑤ | 2023 | vLLM | KV 预留白占显存 → PagedAttention 分页存 | KV 利用率 96%;吞吐 2–4×(对 FasterTransformer、Orca) | 能坐几人 = KV 池 ÷ 每条 KV,而上下文在变长 | 四 |
| ⑥ | 2023 | SARATHI 论文(2024 年扩成 Sarathi-Serve);引擎里 vLLM 先合入 | 长 prompt 一进门全员卡住 → 分块 prefill | Sarathi-Serve 达标请求 2.6–3.7×(对 vLLM) | 只把打扰摊薄,两段还挤在同一批卡上 | 三 |
| ⑦ | 2023 → 2025 | Splitwise、DistServe → Mooncake → Dynamo | prefill 与 decode 抢卡 → PD 分离 | DistServe 可接请求 7.4×(对当时最好的系统,两段同卡) | 每请求多搬一趟 KV,还得调 P、D 配比 | 八 |
| ⑧ | 2023 | SGLang 论文 | 同样的开头一遍遍重算 → RadixAttention 复用前缀 | 最多 6.4×(对当时其他系统) | 想复用的前缀多到显存放不下 | 四 |
| ⑨ | 2024 → 2025 | Mooncake(Kimi)、DeepSeek | 前缀放不下 → 分层下放到内存、SSD | Kimi 线上多接 107%–115% | 副本一多,前缀只在自己那份里有;靠 KV 感知路由把命中率从 20% 拉到 75% | 四、八、十四 |
| ⑩ | 2024 → 2025 | Meta(CP);vLLM 2025 合入 DCP | DEP 起不来、KV 被复制 → DCP/PCP 按序列切 | DCP 把 KV 副本让出来,PCP 切 prompt 压首字 | DCP 只在长上下文划算;PCP 遇上线性注意力,状态得一卡接一卡传 | 七 |
| ⑪ | 2024 → 2025 | SGLang、DeepSeek | MoE 把 batch 拆碎,每专家约 8 行 → DP attention + 大 EP | SGLang 复现:最多是同卡数纯 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)。表里每个倍数各有各的基线,彼此包含,不能乘起来(第二、十五节)。
示意图,无实测数。第 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 跑单机和端侧,本课讲数据中心,不展开。
全部日期见第十六节台账「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-06 | vLLM | PagedAttention 首发,吞吐最多是 HF 的 24× | — | vLLM 博客 2023-06-20 |
| 2023-11 | 外部 | DeepSpeed-FastGen 提出切块拼批 | vLLM 回应「已在路线图」 | vLLM 博客 2023-11-14 |
| 2024-01 | SGLang | 首发 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-03 | vLLM | 前缀缓存 APC 合入,V0 里默认关 | V1 改成默认开 | vLLM 合入记录;V1 博客 |
| 2024-04 | vLLM | 分块 prefill 在引擎里先落地 | SGLang 2024-07-29 跟进,晚 3 个多月 | 两家合入记录 |
| 2024-05 | 外部 | DeepSeek-V2 提出 MLA | — | arXiv 2405.04434 |
| 2024-06 | 外部 | Mooncake 论文 | — | arXiv 2407.00079 |
| 2024-07 | SGLang | v0.2 纯 Python 轻量调度,点名 vLLM 的 CPU 调度开销;最多 3.1×(对 vLLM 0.5.2) | — | lmsys 博客 2024-07-25 |
| 2024-09 | vLLM | v0.6.0 承认 CPU 开销让 GPU 吃不饱,Llama 8B 上 2.7×(对 v0.5.3) | 原文没说是回应 v0.2,不标 | vLLM 博客 2024-09-05 |
| 2024-09 | SGLang | v0.3 先做 MLA 优化,3–7×(对基线系统) | — | lmsys 博客 2024-09-04 |
| 2024-11 | 外部 | Mooncake 传输引擎开源 | — | Mooncake README 时间线 |
| 2024-12 | SGLang | v0.4:零开销调度、DP attention;V3 首发日支持 | V3 首发日比 vLLM 早一两天 | lmsys 博客 2024-12-04;两家 release |
| 2024-12 | vLLM | 接 Mooncake(12-15),同月 12-01 合入首批 PD 代码 | SGLang 2025-04-10 跟进,晚 3 个多月 | vLLM 合入记录;Mooncake README |
| 2025-01 | vLLM | V1 重写,前缀缓存默认开 | 原文:SGLang 等引擎影响显著 | vLLM 博客 2025-01-27 |
| 2025-02 | SGLang | MTP 先合入(02-14) | vLLM 02-19 跟进,晚 5 天 | 两家合入记录 |
| 2025-02 | 外部 | DeepSeek 开源周:FlashMLA、DeepEP、DeepGEMM | 两家随后都接入 | open-infra-index |
| 2025-03 | SGLang | EAGLE-3(03-18),自称首个支持 | vLLM 04-25 跟进,晚 5 周 | 两家合入记录 |
| 2025-03 | 外部 | NVIDIA Dynamo 开源 | 一上来就同时支持两家 | NVIDIA 新闻稿 2025-03-18 |
| 2025-04 | vLLM | KV Connector 接口(接 LMCache、NIXL) | — | vLLM 合入记录;LMCache 博客 |
| 2025-04 | SGLang | 接 Mooncake(04-10) | 晚 vLLM 3 个多月 | SGLang 合入记录 |
| 2025-05 | SGLang | 大 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-09 | SGLang | HiCache 分层 KV 缓存 | — | lmsys 博客 2025-09-10 |
| 2025-09 | vLLM | 合入 DCP(MLA) | — | vLLM v0.10.2 release |
| 2025-10 | vLLM | v0.11 删掉 V0;KV 可下放 CPU;TPU 新后端 tpu-inference | — | v0.11.0 release;vLLM 博客 2025-10-16 |
| 2025-10 | SGLang | SGLang-JAX 跑 TPU | — | lmsys 博客 2025-10-29 |
| 2025-12 | vLLM | Wide-EP,每张 H200 约 1.5k → 2.2k tok/s | — | vLLM 博客 2025-12-17 |
| 2026-03 | vLLM | MRV2,吞吐 +56%(Qwen3-0.6B) | — | vLLM 博客 2026-03-24 |
| 2026-04 | 外部 | DeepSeek-V4 | vLLM 04-24、SGLang 04-25 首发日支持 | 两家博客 |
| 2026-06 | SGLang | GB300 上跑 V4-Pro,同交互档对自家首发日涨了几倍(15.3 揭晓) | — | PyTorch 博客 2026-06-23 |
| 2026-09 | vLLM 生态 | Inferact 的 TPU megakernel | — | Inferact 博客 |
两家共用的外部部件:FlashInfer、xgrammar、DeepEP 与 FlashMLA、Mooncake、NIXL。间隔都按两边日期本课推导,往下取整;全部出处见第十六节台账「R85 补充」「L80 补充」。
⚠️ 示意时间线:格子长短不按比例,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)。
📌 形状取 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 更不行,它是每个人自己的历史,各读各的(第一节)。
⚠️ 本课的分法:每节按它主要的贡献归一根杠杆。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、decode 摆在一起比:prefill 一次喂几千个 token(矩阵乘里每个 token 占一行),decode 每人每步只喂一个。 行数差了三个数量级,瓶颈就从算力换到了显存带宽。0.1 里的每一招都冲着这个事实。
| 训练 | prefill | decode | |
|---|---|---|---|
| 一步喂进去的 | 整批完整序列 | 一段 prompt,几千行 | 每人一行 |
| 算什么 | 前向+反向+更新 | 只有前向 | 只有前向 |
| 序列能不能并行 | 能:答案已知,整段一起算 | 能:prompt 已知 | 不能:下一个字要等上一个 |
| 卡在哪 | 算力、通信 | 算力 | 显存带宽 |
| 显存装什么 | 权重、梯度、优化器状态 | 权重+每人的 KV | |
| 看什么 | 吞吐 | 首字延迟 | 字间隔,以及同时服务多少人 |
prefill 就是训练的前向,专题五那套切法和 kernel 大多能直接搬。decode 每步只出一个字,却要把全部权重和每人的 KV 读一遍;请求又随时到、长短不一。一颗很贵的芯片,大半时间在等搬运。
v7 按 bf16(每个数 2 字节)算,每读 1 字节要做满 313 次运算才不被带宽拖住,这叫屋脊点。 矩阵乘一次喂进 M 行,每个权重就要做 M 次乘加(2M 次运算),而它只占 2 字节:只算读权重,每字节的运算次数(强度)就是 2M ÷ 2 = M。
📌 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。
📌 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 毫秒是每步用时的下限,实测离它越近,带宽用得越满。可这一趟只出了一个字。
权重一次读完能分给一整批人,KV 却是每人自己的历史。
📌 本课推导: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。
📌 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 都过,不受影响。
要说清后面每一招省了多少,先得有把尺子。可同一次测量,换一种数法,每卡每秒的 token 数可以是 5,270,也可以是 11,880。 先把尺子对齐,后面每一节的数才能放在一起比。
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 是逐次间隔的列表。
吞吐和交互性是一条曲线。
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 目标时,每张卡能扛的最大请求速率。
同一次测量,四把尺子。
本课程作者实测: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 的公开基准)。
峰值: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。
每百万输出 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。
分母只算 decode 卡还是全部、分子含不含输入;在每用户多少 tok/s 的档位测的;峰值还是稳态。TPU 上再问:卡按芯片还是 device 数。
第一节算过:decode 每一步把权重搬一遍,同一趟坐的人越多,每人摊到的越少。最早的服务一批人一起进、一起出,先答完的人座位空着,等最慢的那个。 调度决定这一趟能坐满几个人。
逐步调度:Orca(Yu et al., OSDI'22)的 iteration-level scheduling;论文在 GPT-3 175B 上报告同等延迟下吞吐是 FasterTransformer 的 36.9 倍。
⚠️ 示意:请求长度是编排的,假设一开始全在排队;两种调度的步数、空转格数由本脚本模拟得出。
Orca 是 2022 年 OSDI 上的一篇论文,也是论文里做的那套服务系统。今天没人直接跑它,跑的是它的招:论文叫迭代级调度,业界后来通称连续批(continuous batching),vLLM、SGLang 都按步调度。同延迟下,吞吐是 FasterTransformer(NVIDIA 早年的推理库)静态批的 36.9 倍(GPT-3 175B:每 token 中位延迟都压在 190 ms,每秒服务 0.185 → 6.81 个请求)。
--enable-lora、--max-loras 开。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 块。
一步里装了什么:新人怎么接上。
调度规则:vLLM 文档 Optimization 页(V1 默认开 chunked prefill;先排全部 decode,预算有剩再排 prefill,装不下就切)。
SGLang 默认一步只跑一种:要么一块 prefill,要么全员 decode;开 --enable-mixed-chunk 才混(Server Arguments 页)。
⚠️ 示意:预算、人数、长度都是编排的;格子由 mix_sim 现算。
一步就是一趟前向。每步开头调度器排一次:车上的人各占一格,剩下的格子按排队顺序切给新 prompt(3.2)。拼好的这一行一起乘权重,只有注意力各读各的 KV(3.1 的选择性批处理)。
--enable-mixed-chunk 才混。不混也不用等:prefill 那步照样出首字,下一个 decode 步就带上它。本课程作者实测: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 端排队。
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,本课推导)。
CPU 那几毫秒也要藏起来。
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 的重叠循环是:先把这一步发出去,再回头处理上一步的结果。
批开大了,KV 可能中途装不下,只能先请出去几个。回来两种办法:KV 换到主机内存再搬回(swap),或丢掉、重算 prefill(recompute)。
vLLM V1 默认重算,文档说 V1 里重算开销更低。
10,000 × 0.05 = 500 人。只装得下 300 人,吞吐钉在约 300 × 1000 ÷ 50 = 6,000; 要么少搬(第十二节末尾的 FP8 KV 让每条 KV 约减到 61%,含索引键),要么换个交互档。
上一节的槽位要靠 KV 撑:每条在跑的序列都在显存里单独占一块 KV。Orca(2022)已让每步都能换人,KV 却按最长预留,只用上两到近四成。 KV 池装得下几条序列,decode 每一趟搬运最多就分给几个人。 2023 年 vLLM 的 PagedAttention 起,几招都在同样的显存里多装人、少重算。
| 记法 | 每层存什么 | 每 token 字节 | 例子 |
|---|---|---|---|
| MHA(2017) | 每个头各存一份 K、V | 3,997,696 | V3 的形状假如用 MHA;128K 一人约 524 GB(488 GiB),一颗 192 GiB 的芯片装不下(本课推导) |
| GQA(2023) | 几个头共用一组 K、V | 327,680 | Llama-3.1-70B:8 组 × 128 维 × 80 层 |
| MLA(2024) | 一条压缩向量,所有头从它解出 K、V | 70,272 | DeepSeek-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 只挑一部分读。
出处: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 各存一份,池子更小。
出处:每 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 越少:这是长上下文贵的第一个原因。
早先按最大长度给每条序列预留一整段连续显存。PagedAttention 把 KV 切成固定大小的块,用页表记每块住在哪。
出处: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 上这个模型)。物理块编号是示意。
混合模型有两个池,预算要分。SGLang 让 V4 两个池共用一份显存预算,用 --swa-full-tokens-ratio 定隔板。滑窗池每条用量封顶,全长池随输入变长一直涨,隔板因此跟着输入长度挪。
出处: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 倍,越界写入被静默钳回末尾,输出乱码。
很多请求开头一样(同一段 system prompt、多轮对话的前几轮),这段的 KV 留着,下一个直接接着算。
出处:首字 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%。两个数来自两份文档、两个时间点,不是同一次测量。价格不画。
线性注意力和滑窗难复用:线性层的状态截不回任意位置,滑窗层早先的 KV 已经丢了,只能隔一段存一份快照(第十三节)。
显存留不下所有想复用的 KV,就往下放到主机内存、磁盘乃至远端存储,用时搬回。
本课推导:重算 = (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 才划算。
llm-d/llm-d@accc6c5:guides/tiered-prefix-cache/README.md)。每条 70,272 × 65,536 字节 ≈ 4.29 GiB,装 10 条。存 FP8 按 12.4 的布局每 token 40,016 字节,约装 18 条(严格减半才是 21 条)。
座位坐满后,权重一趟已分给几百人,每一步本身却还慢。一张卡上的 decode 有两块最难啃:注意力读的是每个人自己的 KV(5.1、5.2),MoE 的每个专家只分到几行(5.2)。两块都是搬运问题。最后补一条小 AllReduce(把各卡的部分和加起来再发回每张卡,5.3),它卡的是延迟。
长上下文除了占座位(第四节),每人每步要读的 KV 也更长,且各读各的,攒 batch 摊不薄。
decode 注意力每读 1 字节只做 G 次运算(G = 几个查询头共用一个 KV 头),推导见专题三 §3.1。Llama-3.1-70B 64 个查询头配 8 个 KV 头,G=8,v7 的屋脊点 313 是它的近 40 倍。
📌 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 的注意力后端之一。
分段与三份预编译版本: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 能做的只剩一件:每个字节只搬一次,搬的时候别让计算单元等。
搬运规则: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 数变。
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 个,若头这一维落在这两维上,就可能被补成整块,多出的全是空位。
📌 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 推过「吸收」:把投影并进查询,所有头直接对同一条压缩后的潜向量算,K/V 不展开。那是 decode 用的,prefill 呢?
📌 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。
📌 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 出);合入后默认关,要用环境变量开(出处见第十六节台账)。
📌 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 攒得再大也喂不饱(第六节)。
专家要多凑几行,就得铺到更多卡上,何况 V3 一张卡本来就装不下。切多卡时专家都用 EP,分歧在注意力:几张卡合算一批请求,还是各算各的。 选哪个,看模型有几个 KV 头、要多大 batch。
专题五 §4.4 讲过:同一批卡进注意力和进专家时可用两套切法。 TEP 是注意力用 TP、专家用 EP;DEP 是注意力用数据并行、专家用 EP。
📌 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。
📌 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 池装满时能放几批人,速度看同样负载下一步要多久。这套部署记了每卡在跑几个请求,容量那条轴看得见:
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 一宽就成倍涨。
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 dep8 | decode dep16(prefill 剩 12 台) |
|---|---|---|
| 出字间隔 | 60 ms | 33 ms |
| 首字 | 45 s | 54 s |
| 每张 decode 卡输出 | 9,032 tok/s | 5,270 tok/s(总输出只多 17%) |
拓扑一换,瓶颈换边,P:D 配比要重扫。
tpu-inference 一个公开 PR 给带线性注意力的混合模型接上了 DP 注意力。 Qwen3.5-397B 在 v7x-8 上比了 DP=8 和 TP=8:
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)。
EP 是把专家分给不同的卡(专题五 §4.4)。一台 8 卡机器里分完就是 EP8,token 走机内 NVLink。出了一台机器还在分,就是大 EP;TensorRT-LLM 划的线是 EP 超过 8。注意力不跟着切专家,各卡各管自己那批请求,所以大 EP 就是放大版的 DEP。
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 个,不铺大,总批凑不起来。动画把这条链拆开:
实测:SGLang 2024 年 12 月先给 DeepSeek 模型开了 DP attention,decode 吞吐最多是原来的 1.9 倍;后来用 96 张 H100 复现大 EP,输出最多是同卡数纯 TP 的 5 倍,但含第八节的 PD 分离。
大 EP 每层传两趟:先把 token 分发到专家所在的卡(FP8),算完再汇回(BF16)。按 V3 的 7168 维、选 8 个专家,每个 token 最多发出约 57 KB、收回约 115 KB(本课推导,上限)。卡越多,每趟越慢:
左: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 没吃满带宽和算力。
大 EP 每层要传两趟:先把 token 分发到专家所在的卡,算完再汇回。传的时候,计算单元空等。DeepSeek 把一批拆成两个微批:A 在传,B 就在算。SGLang 叫它 TBO,vLLM 叫 DBO,都是这一招。
做法: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)。时长比例是示意,本课自定。
哪个专家热门,要等路由算完才知道(专题五 §4.3)。专家那一步等最慢的卡,热门专家所在的卡拖住所有人。EPLB(专家并行负载均衡器,DeepSeek 开源)按过去一段的负载统计,把热门专家多复制几份放到别的卡上,再重新排座位。
做法:DeepSeek EPLB 仓库 README(按负载估计算出复制与摆放方案;负载估计常用历史统计的滑动平均,不在仓库范围内);DeepSeek-V3 技术报告 sec. 3.4。
负载数字与「token 平分给两份」均为示意,本课自定;8 专家 4 卡只为画得下。
--enable-eplb 加 --ep-num-redundant-experts;vLLM 是 --enable-eplb,冗余份数和重排间隔写在 --eplb-config,默认每 3,000 步按最近 1,000 步的统计重排。SGLang 在 GB200 上的复现命令就带着 --ep-num-redundant-experts 32。8 ÷ 4 = 2,是 TEP8 的 2 倍。prefill 喂不上、或 batch 大到算力先到顶时,放得下也换不来吞吐。
第六节切的是头和请求,一条序列变长时还剩两件事。DEP 起不来时(如 6.1 的 K3)只能用 TP,上下文一长,KV 被复制几份,卡很快就满;prompt 一长,第一个字就要等很久。 DCP 管前一件,PCP 管后一件,两者都是沿序列切。
专题五 §5.4 讲过:KV 头比 TP 路数少时,DCP 把 KV 按 token 轮流存到这几张卡上,合并时再统一除 softmax 的分母。轮流放而不是前一半后一半,是因为新字不停写进来,轮流放各卡才能一直一样多(本课的解释)。
📌 vLLM context parallel 部署文档:KV cache 会被复制 tp_size / H 次;DeepSeek-R1 在 MLA 下只有 1 个 KV 头,-tp 8 就是 8 倍复制,可加 -dcp 8。KV 尺寸取自 V3 config.json,本脚本现算。
📌 讲法:Ring Attention(Liu 等,arXiv 2310.01889)附录实现按分子、分母分别累加;分块 softmax 的数值稳定写法见 FlashAttention(arXiv 2205.14135)。
⚠️ 本课示例:数字是随手取的,按定义现算并断言。
代价是每层多几次通信(vLLM 默认后端每层 3 次),度数(切成几份,DCP8 就是 8 份)最多开到 TP ÷ KV 头数。
ag_rs 后端)代价主要是等不是量: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 时各档并发都亏。
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 占用。
--dcp-size 8)写的是并发上限 +72%、引擎吞吐不变、ITL ×1.8。别说成「DCP 让每个字更快」。多长时注意力算得比专家多?拿 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 之前要知道的坑。
PCP 在 prefill 阶段沿序列切,让几台机器合算同一个 prompt(专题五 §5.5)。
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 出错往往不报错,形状全对、数不对。
本课自造的玩具递推,数值由本脚本现算并断言;真实 GDN/KDA 的状态是矩阵、带门控,递推形状一样都是「乘上一步状态再加新东西」。
状态可结合合并的思路见线性注意力/状态空间模型的并行扫描写法(如 Mamba、GLA 的 chunkwise 算法)。
修法是把前一段的末状态传过来;或者利用结合律:各段并行算好自己对状态的映射,再从头合并出每段的起始状态。
把第六、七节的切法摆进同一本账: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。
| 切法 | 权重/device | 剩给 KV | 一条 128K 在每 device 占 | 16 个 device 装几条 |
|---|---|---|---|---|
| DP:整套复制 | 625 GiB | 放不下 | —(一份权重就超了) | 0 |
| TP16:注意力、专家都切 16 片 | 39.1 GiB(全切) | 46.2 GiB | 8.58 GiB(每 device 一整份) | 5 |
| TEP16:注意力 TP、专家 EP | 39.1 GiB(全切) | 46.2 GiB | 8.58 GiB(每 device 一整份) | 5 |
| DEP16:注意力 DP、专家 EP | 54.0 GiB(非专家整份 15.9 + 路由专家 1/16 是 38.1) | 31.3 GiB | 8.58 GiB(只在自己那个 device) | 每 device 3 条,共 48 |
| TEP16 + DCP16 | 39.1 GiB(全切) | 46.2 GiB | 0.54 GiB(按 token 切 16 份) | 86 |
读的一侧取装满时的 batch,每层碰到几个专家按 1.2 的均匀路由算;只算从 HBM 读的字节,下限按每 device 3.685 TB/s(每芯片 7.37 ÷ 2)。
| 切法 | 整套 batch | 每层读权重 | 每层读 KV | 一步读完下限 | 每层通信 | 代价/适用 |
|---|---|---|---|---|---|---|
| TP16 | 5 | 118 MB:注意力 1/16 + 碰到的 37.6 个路由专家和共享专家各 1/16 | 755 MB:5 条全读 | 14.4 ms | 2 次 AllReduce | 单人出字快;KV 复制 16 份,长上下文装不下人 |
| TEP16 | 5 | 118 MB(平均):注意力 1/16 + 本卡被碰到的整块专家 | 755 MB:5 条全读 | 14.4 ms | 2 次 AllReduce | 同 TP16;专家整块,热门专家那张卡要多读,大家等它 |
| DEP16 | 48 | 784 MB:整份注意力 187 + 本卡 12.5 个路由专家 + 共享专家 | 453 MB:只读自己 3 条 | 20.6 ms | 2 次 all-to-all(前 3 层不用) | KV 不复制,人多时最省;每 rank 一份状态,K3 这类起不来(6.1) |
| TEP16 + DCP16 | 86 | 673 MB:注意力 1/16 + 本卡 15 个整块专家 | 812 MB:86 条各读 1/16 | 24.1 ms | 2 次 AllReduce + 3 次 | 装得最多;通信最勤,只在长上下文划算(7.1) |
落点:副本让出来,多放 token。DCP 让出 KV 副本,同样的显存多放 token,这一趟就分给了更多 token;PCP 买的是首字延迟。留下的问题:一张卡上同时出字的人越多,长 prompt 进门那一步耽误的人也越多(第八节)。
4K 不开:KV 放得下,DCP 只剩代价(7.1)。128K 开:TP8 放不下,只能少收请求、排长队。
第六、七节把每张卡的批撑大了,一次 prefill 波及的人也跟着变多。分块 prefill(3.2)只能把打扰摊平:两段还挤在同一批卡上,长 prompt 一来,正在出字的人照样要等。PD 分离把两段拆到两批机器上。 难的是 KV 从 prefill 机传到 decode 机的那一趟。
专题五 §6.1 讲过:decode 每步只出一个字却要读一遍权重,所以要凑大 batch。batch 越大,一次 prefill 卡住的人越多。
⚠️ 推导:稠密层一步读 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:
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 走一趟要多久:
📌 我们的 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)。
📌 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 传输慢得离谱:
📌 带宽和单次传输时间: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 传输带宽。
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 · GB300 | NIXL 走 NVLink cuda_ipc | 能用,唯一活路 |
| vLLM · V4-Pro · GB300 | Mooncake 走 NVLink + 简易代理 | KV 快了,整体更慢:并发 64 输出 1,333 对 NIXL 的 1,693 tok/s |
| vLLM · V4-Pro · GB300 | Dynamo + vLLM + MooncakeConnector | 接不上:Dynamo 的 vLLM 集成没有传 Mooncake 握手地址的通路 |
| SGLang · DeepSeek-R1 · GB300 | NIXL 走 RoCE(以太网上的 RDMA,4.4) | GKE 上调不通,请求 60 s 超时 |
| SGLang · R1 / Kimi K3 · GB300 | Mooncake 走 NVLink | R1 上能用;K3 的 PD 尝试也选了这条 |
别问 NIXL 和 Mooncake 哪个好,要问这个引擎、这张网上哪条路通。共同点只有一个:同一个 NVLink 域里,KV 别出域。
KV 按块存(4.2)。老的 connector 只传填满的整块,不满一块的尾巴让 decode 端补算。
📌 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 就喂了两遍,输出偏了也不报错。
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 坑清单。
--context-length,KV 布局对不上,握手失败;单条能过,压测才暴露。kv_load_failure_policy 设 fail,一次瞬时拒收引擎就死;设 recompute 稳,但 12 个 prefill 时每卡 3,187 掉到 2,645,约交 17% 的税。上下文长度: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/。
正确性:拆了以后先比字。PD 出错最常见的样子是能跑、通顺,但和不拆时不同。上线前先比字,再比速度。
后一种靠批不变的 kernel 消掉,前一种必须修;分不清时把并发降到 1 再比。
跨数据中心:KV 够薄才敢走远路。「网络不是瓶颈」只在同一个机房成立。Moonshot AI 和清华的 PrFaaS 论文敢把 prefill 放到另一个数据中心的另一种卡上,靠的是混合模型的 KV 薄。
📌 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),不是同一参数量下的严格对照。
SGLang 2025 年在 GB200 NVL72 上把这些零件拼成了一套:DeepSeek-V3/R1(671B),PD 分离加大 EP(第六节)。一柜 18 个计算节点、每节点 4 张 GPU,同在一个 NVLink 域;KV 用 Mooncake 走 NVLink,守住 8.2 那条「KV 别出域」。
| Part I(2025-06) | Part II(2025-09) | |
|---|---|---|
| decode | 12 节点 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 和专家负载都不一样。
先量 KV 传输带宽。只有几百 MB/s,多半是退回了 cuda_copy 或跨出了 NVLink 域;带宽正常再看调度层有没有排队。
拆开以后多出一个旋钮:P、D 各配几台。在它前面还有一问:这个负载该不该拆。 都要拿自己的负载去量,别照搬别人的配比。
专题五 §6.3 用 DistServe 的例子讲过:两边按各自上限配。
📌 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。
| 步骤 | 算式 | 结果 |
|---|---|---|
| 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。
📌 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 看是赚。
vLLM 跑 V4-Pro,decode 固定 8 张卡,prefill 从 1 个加到 14 个。
📌 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 上的三种摆法:
📌 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%:单并发时两段本不抢资源。
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 都是中位数。两组都是单点测量。
答「否」就停。分块 prefill 见第三节,KV 薄不薄见 8.4。
📌 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 例子都是单点测量,不是扫描。
专题五 §6.5 讲过:decode 里的注意力和专家也能拆到两批机器上,多台注意力机喂同一批专家,专家那边就凑得出大 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 上的数,配比一错就比不拆还慢。
📌 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 还有余力」的定性说法画的,没有利用率数字。
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 抢资源。
第六到九节给出了一串拓扑,每换一个,调好的参数就得重找。换一次拓扑,抵得上把参数调遍。
专题五 §7.1 讲过:通信勤的切法要放在快线里,懒的才能跨慢线。
📌 次数为本课推导: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 的部署记录,都是总吞吐,可图里三档配置用的卡数各不相同。
📌 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。
📌 跨 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 一组。
📌 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 分成两层。
最小切片怎么定。一个引擎最少几个 device,先算纸面账:权重 + KV + 激活值(中间结果)的显存。拿 DeepSeek-V3 在 TPU v7 上算(口径同 4.1):一颗芯片是两个 device,各管各的 94.75 GiB,账按 device 记,最后再换回芯片数。
📌 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,原记录没拆原因。)
容量别拿小并发估。R1 在 GB300 上的部署记录先估了这套 DEP8 decode 的容量,起初却只拿并发 8 去量。
📌 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%。
对照实验的纪律。
专题五 §7.4 的五关,推理时照样走一遍。PP 是流水线并行:按层切给几组卡。
📌 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),「搬一趟权重只出一个字」就成了硬上限。 投机解码先便宜地猜几个字,再让大模型搬一趟验完,猜对几个就出几个。
大模型把草稿当一段输入,一步算出每个位置该写的字,逐个对照。
⚠️ 示意:格子长度(普通一步 10 格、草稿每个 1 格、验证一步 11 格)和接受个数都是举例,不是实测。
机制:Leviathan 等 arXiv 2211.17192;Chen 等 arXiv 2302.01318。收下第 i 个草稿的概率是 min(1, p/q),被拒时从 max(0, p − q) 归一化后重新抽,输出分布与大模型逐个生成相同。
注:「不会比不开更少出字」只说字数;如果验证一步明显变慢、草稿又总猜错,墙钟时间照样可能变长(见并发那张图)。
用标准拒绝采样(按概率决定每个草稿字收不收)时,投机解码只改速度,不改输出分布。为什么不直接比两边抽的是不是同一个字:两边都按同一个均匀分布从一百个数里抽,想法完全一样,也要一百次才对上一次(Google 投机解码回顾博客的示意反例)。所以比的是把握:收下的概率是 min(1, 大模型概率 ÷ 草稿概率)。
收益账:接受长度 ÷ 一步变慢了多少。每步平均出几个字叫接受长度。小 batch 时一步主要在读权重,多验几个 token 本该几乎不加时间。
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 上的实测:一步慢了一截,接受长度却大得多,相除仍是好几倍。
收益会缩:并发、上下文、DEP。并发一高算力先满,草稿里每个 token 都得真算。 K3 输出吞吐对不投机的倍数,并发从 1 加到 64 一路往下缩。并发 1 的倍数也低于 11.1 的每字提速,因为端到端含不受加速的 prefill。
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: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 个跟着作废(本课推导)。
各家报的倍数口径不同,不能横比。
时间取 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)拿已经写出的最后几个字,到提示词里找一样的片段,把后面几个字照抄成草稿。
做法: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: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 个差不多贵。
⚠️ 示意:例句、各行猜 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: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%。
第二刀补验证,这才是它线上好用的主因。另一个小头估每一位被收下的概率,连乘成前缀存活概率。调度器把整批请求的候选前缀按存活概率排队,再查引擎吞吐表,定这一步总共验多少。负载轻多验,负载重少验,没把握的字不占名额。
线上又改了两处(论文 §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 那一路。
大 batch 下投机不灵了,剩下的办法是让每趟少搬、少停。 量化让权重和 KV 占更少字节,kernel 融合去掉交接时的空等。
小 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 毫秒的八分之一(本课推导,只算权重)。
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 差在块大小和缩放格式。
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 读得最多的部分,压它省得最多。
先按组件数参数。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。
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 根本放不下。
为什么压了不掉点:四条道理。扔掉四分之三的位数,模型为什么还认得路?下面四条各有出处,合起来也说明了哪里能压、哪里要护着。
一、训练停在谷底,谷底大多是平的。训到收敛,损失对权重的一阶导数接近零,权重挪一点 Δ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 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: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」一步,模型输出崩成重复的乱词。
CUDA Graph:录一次,整串重放。batch 小时,GPU 算一个 kernel 很快,CPU 一个个发反倒跟不上:GPU 算完一个,就等下一个发过来。CUDA Graph 把一步要发的整串 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)、发射与计算的长短比是示意。
--cuda-graph-max-bs 定上限。人数不在档上就补到上一档。kernel 融合:边界上不再干等。一次前向(模型从头算到尾一遍)要发上百个 kernel。每个 kernel 收尾、下一个开场时,没人在读权重。
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 博客)。
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 时少。
布局: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。
前十二节都默认一件事:每个 token 留一份一样大的 KV,想截在哪就截在哪,想按块复用、按块搬都行。 混合模型(4.1)里的线性层不是这样:一条序列只有一份状态,整段压进去,截不开。
| 层 | 存什么 | 新请求能从哪儿接着算 |
|---|---|---|
| 全注意力 | 每个 token 一份 KV | 共享前缀的任意位置 |
| 滑窗 | 只留最近一个窗口的 KV | 要有完整的最后一个窗口 |
| 线性(GDN、Mamba、KDA) | 每条序列一份固定大小的状态,原地更新 | 只能是正好存过状态的位置 |
线性层的状态每进一个 token 就改写一次,回不到更短的前缀。PyTorch 博客(2025-12)把难处归成三条:退不回去;一份比单个 token 的 KV 大几个数量级;要么整份能用,要么不能用。
前缀缓存只能改存快照。截不开,就在一些位置把整份状态拷一份存下来,叫快照。新请求沿前缀匹配,退到不超过共享前缀的最近一份快照,从那儿接着算,中间那段重算。
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 年把它们挂进同一棵前缀树,各按自己的边界判命中。
一份快照顶几千个 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 博客明说:每个位置都存「贵得没法用」。它留三种:
VLLM_PREFIX_CACHE_RETENTION_INTERVAL 设;设 0 就只留 prompt 末尾。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 长、按块存;快照按请求、按份存。
--mamba-full-memory-ratio 定;弹性池让一边闲时让给另一边。淘汰走两条 LRU:KV 只能从叶子往根删,快照哪个节点上的都能单独删。--enable-int8-mamba-checkpoint(默认关)存 int8,说明写能多缓存约一倍前缀。选 int8 不选 fp8:状态值分布近乎均匀,fp8 的指数位用不上;而且只在命中时还原一次,误差不会在递推里累积。滑窗还有一条路:不存,缺了只重算尾巴。DeepSeek 2026-10 开源推理框架 DeepInfer,同时公开了 V4.1-Flash 的线上做法。
跟快照对照:线性层的状态吃下了整段历史,只能存;滑窗只看最近一个窗口,重算有上限,所以可以不存。
同一个前提,前面已经撞了四次。
--no-enable-prefix-caching,tpu/tpu-inference/Qwen3.5-397B-A17B-FP8/README.md:95),否则断言出错;看样子是还没接上这套快照(本课推测)。GPU 引擎这两年为此补了成套机制。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 哪里不一样,这个模型哪几处要特殊处理,怎么跑快。
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。
形状:GPU 录图只是加速,TPU 不编就不能跑。GPU 上 kernel 逐个发,CUDA Graph 录下来省发射开销,档外的批照样跑(12.3)。XLA 按静态形状整图编译(专题二「谁做决定」),一批的 token 总数补到预编译的几档;没编过的档,第一个撞上的请求要等 60–90 s,之后同形状不到 1 s。
为什么非编不可。打个比方:GPU 像现场点菜,来一单炒一单;XLA 像中央厨房,开工前把整桌菜的工序、锅位、碗碟一次排死。
分桶就是成衣尺码。不给每个总数量体裁衣,只备几个码:这一步整批拼起来 700 个 token,就补零补到 1,024 那一档去算,补的零白算。码备得越多,补得越少,可每个码都要编一次。
⚠️ 本课推导示意: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 各编一遍同一张图,是八个厨师各自试做同一道菜。
fori_loop,不在追踪时展开;把 attention sink 的闭包常量改成运行时输入。所以凡是随 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 拿它算下一步去仓库哪一格取货。
make_async_copy(...).start() 发起搬运,用 .wait() 等它到。run_scoped 让一段小 kernel 声明自己要多大一块 VMEM,用完归还;14.3 的 K3 就靠它分时复用。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。
先认清全注意力层: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 头。
--max-num-seqs=64,8 个核合 512(本课推导)。切法跟着并发换。公开的参考配方(#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,通信藏到矩阵乘后面。
砍的理由跟前面几节一样:HBM 在空等,通信露在外面,布局把窄维补成整块。最大的几刀,都是手写 Pallas 把调度权拿回来。
prefill 四刀,全砍在 MoE。先在片上按目的地累加;再把通信切成小块,想让它跟计算叠起来(XLA 实际仍没叠上);接着整层融成一个程序;最后修剪 kernel 本身。
📌 本课据私有实测指数化:起点那天的 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 带宽,三刀都在少搬字节。
run_scoped 轮流借同一块,共用 31.29 MB 就够,剩约 35.8 MB 给其余的块(本课按公开代码推导)。📌 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 的哪一侧,再决定刀往哪砍。接手一个服务的第一天怎么问,收成第十五节的八问。
接手一个推理服务,第一天先问八件事。前四问算纸上的账,后四问拨开关。
⚠️ 本课归纳:顺序按「先校准、再算账、后调招数」排,各问拿什么回答、判据见正文和对应的节。
⭐ 八问归到一句话:decode 每一步都要搬一趟。前四问算清这一趟有多重、能分给多少人;后四问要么让更多人分,要么让它变轻。
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 | 调度占着 CPU | vLLM | 三 | vLLM V1 引擎重写:吞吐最多是 V0 的 1.7 倍 |
| 2025 | ③ 一趟只出一个字 | 论文 | 十一 | EAGLE-3:单请求最多是不投机的 6.5 倍,batch 64 吞吐仍是其 1.38 倍 |
| 2025 | ⑪ MoE 拆散 batch | DeepSeek | 六 | SGLang 复现大 EP+PD 分离:输出吞吐最多是同卡数纯 TP 的 5 倍 |
| 2025 | ④ 每条 KV 太厚 | DeepSeek | 四 | DeepSeek-V3.2 稀疏注意力(DSA):每字只读 2,048 个历史 token(V3.1-Terminus 全读),基准基本持平 |
| 2025 | ② 字节太多:KV | DeepSeek | 十二 | V3.2 存 FP8 KV:同显存请求容量约是 BF16 KV 的 1.63 倍(本课推导) |
| 2025 | ② 字节太多:权重 | Kimi | 十二 | Kimi K2 Thinking 原生 INT4 权重:低延迟模式生成约快 2 倍(模型卡未写对照精度) |
| 2025 | ② 字节太多:KV | NVIDIA | 十二 | 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。
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 公开的一天:
📌 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 2048 | DeepSeek-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 B | Hugging 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,500 | JAX 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/GPU | gpu-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,070 | SGLANG-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,024 | huggingface.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,053 | SGLANG-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,704 | SGLANG-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 s | SGLANG-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 ms | SGLANG-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;跨实例迁移 Llumnix | docs.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 切注意力会复制 KV | VLLM-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,070 | SGLANG-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,479 | VLLM-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.8271 | github.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/GPU | SGLANG-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/s | VLLM-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 ms | gpu/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 同构 PD | PrFaaS,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 个 prefill | SGLANG-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.23 | gpu-tpu-pedia gpu/inference/a4/deepseek-v3/REPORT-2P1D-DeepSeek-V3.md :69、:85、:100-142;cuda graph 说明 REPORT-1P1D :129 |
| 固定并发压测下每个请求约 65 s | REPORT-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 ms | tpu/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 颗取 8 | Google 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 s | gpu-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 ms | vLLM 博客 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 bit | OCP Microscaling Formats (MX) v1.0 规范;NVIDIA 技术博客「Introducing NVFP4」 |
| v7 公开规格只列 BF16、FP8 峰值,没写 FP4 算力 | Google Cloud TPU7x 公开规格页 |
| V4 专家权重为 FP4 | Hugging 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-12 | arXiv 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 标记仍为 false | github.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;批不变 kernel | arXiv 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 台全崩、注册表仍显示 14 | SGLANG-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% 命中磁盘 KV | api-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);传输库 NIXL | nvidianews.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/4 | huggingface.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,914 | github.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.04 | SGLANG-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 ms | VLLM-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 VMEM | hazyresearch.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,192 | SGLANG-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-06 | arXiv 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.3 | blog.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.64pp | arXiv 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 test | EAGLE-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 带 MTP | sebastianraschka.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-04 | github.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-25 | vllm.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-10 | lmsys.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/s | vllm.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-09 | pytorch.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、NIXL | vLLM 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'22 | blog.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 → BF16 | https://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 与 SGLang | developer.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.6 | arXiv 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 的 loss | arXiv 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 239 | nvidia.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 token | LMSYS 博客 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 0 | DeepSeek-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-scatter | DeepEP 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 注入每层草稿 KV | DFlash 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、MLX | developer.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-TPU | arXiv 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(双向)卸载权重以缩小 EP | lmsys.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 节点 EP32 | lmsys.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 分配的生存期;单程序不分 grid | https://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 叫 KVP | SGLANG-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 和 flips | MoQE 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 按 token | eδ 本课推导;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 现算并 assert | arXiv 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。