专题六 · 推理

这份讲义怎么用

两个用法。
① 上台讲:照着念,台词、切图、每段几分钟都写着。
② 自学:把这一整份丢给 AI,你会得到一个既有全部背景、 也知道该怎么讲的助教,让它带你走一遍。

内容本身在课件那边,这一份只管「怎么讲」。
课程作者 Chris Yang · Google Cloud AI Infra 架构师。

🎯这一节要留下什么 讲完之后台下脑子里该剩的那一句。
🗣讲稿 黄底的可以照着念。
🖥屏幕 该滚到课件的哪张图、放哪段动画。 ⭐ 这些提示挂了 class="board",构建时逐条对账, 指了不存在的图或小节号会当场报出来。
⚠️别讲什么 这一节最容易跑偏的方向。

⏱ 时间:主线 334′

⛔ 第零、一节不能砍,第四节那张「能装几条」也不能砍。 第零节立住「decode 每一步都搬一趟」,第一节算清这一趟的账,后面每节都拿它开头。 要压时间,压中间的例子(实测数、旁支的坑),别压首尾:开头那句「这一招对付那一趟的哪一块」和末尾交棒句,再紧也要念。
讲义共十六节(第零到第十五节),第十六节出处台账不进课堂,被追问时翻。按地板算全讲约 334 分钟(台词 200 字/分钟、每次切屏 15 秒、每个互动半分钟);第十四节为深讲,不计入总时长,计划表里标「—」、地板表里单列「不计时」,奔着讲清楚去讲;讲义按「每个小节都讲全」写,一次课从哪讲到哪由主讲人定。第七节讲完后中场休息(不计入)。
台词里的 4K、8K、32K、128K 这类长度,K 读作「千」。

段落分钟能不能砍说明
零 开场33不能⭐ 开场新闻循环模型(开头抛问题、0.2 讲完一句话后揭晓:多一圈多搬一趟,省的是容量;KV 每圈一份、只留最后一圈);其他引擎落点(TensorRT-LLM、Dynamo-Triton、TGI 维护、端侧);⭐ 开场热身勾选题(五种并行 × 五种通信,回顾专题五);⭐ 开场两道题必须做;时间轴 2022→2026 每年只说那年最疼的一件事(Orca、FlashAttention、GPTQ、投机解码、Hopper FP8;分页、GQA、AWQ、RadixAttention、Splitwise;分块 prefill、PD 分离、MLA、Mooncake、CP、大 EP、o1、MTP;R1、开源周、EAGLE-3、DSA、DCP、NVFP4),2026 右端菱形只留问号(5.1 倍第十五节揭晓);两股外力那张图三格;十三环表只走「又冒出什么」那条链(倍数只念环一 36.9× 当示范),念完「不能乘」;V3 的 6,710 亿/370 亿与 AI Index;双引擎按图上的点走+分工+共用货架;完整时间线只看「对方晚多久」(三个多月 → 五天 → 同一天);0.2 请求一生三行、住在哪/多大/跟长度成正比;逐层图(187+396 MB、KV 一万字 11.5 MB/128K 151 MB、写 1,152 B、传 7,168 维、前三层稠密、MoE 8+1、输出层 0.93 GB、合计约 37 GB;其余原数在 DONT);几人同时 decode;立住「搬一趟」那一句+地图三根杠杆和各节;词表只点三组易混的;出场角色只记 V4-Pro × GB300
一 两个阶段12不能⭐ 训练/prefill/decode 对比表只讲「喂几行」「卡在哪」两行;1.1 屋脊点 313、强度 2M÷2=M、绿点 1 对 239、约 343 人过线、prefill 4K 远过线;揭晓第二题(约 5 毫秒对 0.016 毫秒、0.32%=1/313、W8A8、理想下限);1.2 三组条(KV 两成 → 一半 → 七成八,87% 的来历);MoE 拆散 batch(239 对 8、1/32、差 30 倍);带走一句与第三到六节的去向
二 校准尺子13可压到 12⭐ 开头 5,270 对 11,880 的关子;四个时间指标(TTFT 含排队、不到一百毫秒对将近八秒;TPOT 公式与 1000÷TPOT;ITL 与 p99;NIM 与 vLLM 定义不同);曲线三点(不到十分之一)、50 档上 2,200 → 11,200 必须讲(第十五节要回扣)、224 人、我们的 dep8 在低档不可直比;goodput;四把尺子(16+48 卡、实心两根念数、虚线只说 36 倍、36=约 9×4);chip 与 device;四个坑(峰值虚高一成多、预热两倍、负载 54%、温度、闭环会低估);成本式子与 DeepSeek 线上数;五样口径;考考自己
三 批处理与调度31可压到 30⭐ 静态批对逐步调度(15 步对 12 步、空转 23 对 11)与 contbatch 动画;Orca 36.9 倍(对 FasterTransformer,守 190 ms 延迟线时比)与图上两成多的差别、两招、S-LoRA 多适配器拼批;chunked prefill 两行对比与预算旋钮、Sarathi-Serve 2.6–3.7 倍、引擎合入时间与 Gemma4 16,384;块长随预算浮动、后块更重(本课推导 7 倍)、不多读 KV、块不能太小(H100 约 300 token、MoE 九千多);stepmix 静图四步与动画:首字当步出、真要等只有 KV 满与 PD、门口不是瓶颈、读 KV 差约 250 倍、混跑过屋脊点但吐字看 decode 人数、SGLang 默认不混、TPU 同规则;⭐ 坐满的餐厅(×4.5 负载 +11% 吞吐、首字 45→253 秒)、Little 定律反推 4,335 人、KV 池多给 13% 显存多装 13% 人吞吐 +0.8%、TPU 档位、CPU 重叠 12 ms→38 µs 与 GPU 同招;3.4 swap 与重算;带走一句与考考自己
四 KV cache31可压到 30⭐ 四种记法逐行(MHA/GQA/MLA/线性)与口径;GQA 论文速度与质量、MQA 对照;DeepSeek 三代(DSA 省读、V4 省存、V4.1-Flash 跨层+FP4)与 lineage 图逐列;⭐ batch 上限图:每 device 94.75→46.2 GiB 拆法、172→21、GQA 36、MHA 16K 装不下、Qwen3.5 先交固定状态少得慢;分页动画与静图(共用前缀、写时复制),20.4–38.2%→96.3%、2–4 倍;V4 两池隔板三格(+54%)与池子算错静默乱码;前缀复用:RadixAttention、vLLM 默认开、磁盘命中 13 s→0.5 s 与 56.3%、按块哈希、只认一字不差、kvstore 动画、线性与滑窗难复用;盈亏带宽公式与 offload 图(2.19 GB/s、35K)、Llama 5.35 GB/s、llm-d / Mooncake Store / LMCache / HiCache;带走两件事与考考自己
五 两块硬骨头22可压到 21行李跟人走,攒 batch 只摊权重(互动);柱顶每 token 字节越降越慢、G=8 与屋脊 313、batch≈53 两块一样重(本课推导);Flash-Decoding 治活分不开、不改比值;RPA 一批三段三份预编译版本、86%/73%、FlashInfer;页大小 16→256,kernel 级 428→283 µs;注意力 KV 是私货,每字节只搬一次;kvload 图:页池与页表、两个槽、四头共用一块、时间轴搬早一格;动画;RPA 五件事;512×5K 一步每层 256 万 token(本课推导)、块要够大;prefill 另调块大小;稀疏 prefill 改位图+稠密(取数冗余、1338.81→729.04 ms、78 层 21 层算 top-k、+5.6%);tile 装箱 A 64 倍/B 8 倍/FP8 不省/C 不浪费;MLA 吸收 242 对展开 1、吸收算量 3.4 倍,按阶段挑;全算专家比排序便宜(互动)、两种精度、313 门槛、99.9% 被选中、两个前提(FP8 激活、NaN);one-hot 换排序 +14.5%/+7.3%;小 AllReduce 24 ns 对 11.0 µs,是延迟问题;少搬从布局开始
六 TEP 与 DEP33可压到 32Parallel Folding 两套切法;TEP/DEP 定义与各自好处、坑;1 个 KV 头切不开(互动);容量轴(4 倍是天花板,坐满才兑现);SGLang 两头 DEP 的故事(14×dep4+dep8、727→886 涨 54%(互动)、999 只多 0.8%、95.6%);vLLM TP4→dep8 一句旁证(46.8→11.8 ms、2.09× 与 1.31×);换模型与 TP÷KV 头数判据;DEP 每 rank 自备、K3 KDA 状态池 OOM、只有 TP 切头;忙闲不均;dep16 喂不饱(60→33 ms、首字 45→54 s、9,032→5,270)、14→16 台只涨 2%、P:D 重扫;TPU PR:并发 512 +62%、两种解读、低并发打平、正确性、调度改动;R1 命令参数名、TEP/DEP≠ETP/EDP;大 EP 定义(EP>8)、EP8 放不下、EP144 每卡 2+1、prefill EP32、两份资料对不上;⛔ 8+1 只对单 token 成立,一批几乎碰到所有专家;大 EP 读少 16 倍(互动+动画):行数式、1.41 GB→88 MB、81.7 对 5.1 GB;SGLang 1.9×、5×(含 PD);网络:每 token 57/115 KB、DeepEP 卡数 ×32 每趟 ×2.5~3.2、32 ms 上限;不是非 NVL72 不可(8 卡+IB+IBGDA、llm-d/vLLM 门槛);最多 4 节点、量小难在延迟(10 MB 对 288 MB、116 次);NVL72 余量;TPU 环面、DCN、公开只有 DEP8;五笔代价(通信、大批、最慢卡、爆炸半径、两套 kernel);GB200 NVL72 答卷:tp-size 48 实为 DEP48、纯 NVLink DeepEP 关 TBO、每卡 768 请求、FP8 KV 撑到 1408(降回 768 掉一成)、NVFP4 分发减半、prefill 反着缩到 4/2 卡+卸载、7,583/26,156/13,386 与 2.7×/3.8×/4.8× 带条件;双微批原理、prefill 27~35%/+40.5%、decode 看批、5 段流水、跨层错拍、通信不占 SM、权重多读一遍、NVL72 上换细粒度重叠(汇回叠下投影+共享专家)、单批跨层预取;EPLB 70→52.5、V3 配置、1.49×/2.54×、288 松开卡数、开关;考考自己(互动)
七 切序列17可压到 16两件事:KV 复制与首字;DCP 回顾(8.58→1.07 GiB 每卡、不加卡);先别除合并分母(LSE)、每层 3 次通信、度数上限;4K 亏 128K 赚(互动):+237%、79 万 token 放不下、首字含排队、−26%=关 symm-mem;盈亏看 KV 总量;三个坑(HiCache、状态池、PD 部署口径);PCP 按行切、DCP 是切到只剩一行后的下一步;Meta 405B 1M 77 s、1→8 台约减半而 8→16 台只降约 35%、Ring、TP 跨机慢、Ulysses;两个正确性陷阱、存折玩具递推差 58%、两种修法;7.3 纸面账:DP 放不下、TP16/TEP16 5 条、DEP16 48 条(9.6 倍)、TEP16+DCP16 86 条、DCP 叠不到 DEP(互动);读的下限 14.4/20.6/24.1 ms 与通信列;和 10.2 对账;考考自己答案;末尾中场休息(不计入)
八 拆工作27可压到 26为什么非凑大 batch(313 / 约一万);混部红框与传 KV;Splitwise、DistServe、Mooncake、Dynamo 的来历;那一趟约 100 ms 与 1.04 GB 怎么算、两个前提;搬家三层与按层排查;配错开关慢两个数量级、三样配置、五行表;混合模型尾巴与 TPUConnectorHMA 的代价、K3 前缀缓存;三条 PD 坑;先比字(批不变 kernel、并发降到 1);PrFaaS 四根柱、专线反推、同等成本约 +15%;SGLang 在 NVL72 上的 P/D 配法与每卡数、两边分开量、配比约 10 倍的本课推导、prefill 缩 EP+卸载与降精度;考考自己
九 配比与拆不拆17可压到 16DistServe 2P1D 例子;配比公式四步到 9.8;三个 prefill 个数(9.8 / 8 / 14);多一台 prefill 换首字(每卡 −31%、P99 −48%)与口径;换分母 10.4 倍变 2.2 倍;MiMo 按 pod 算、Qwen3-Coder 单并发;决策树三问;AFD 原理与小批轮转、论文数、昇腾插件配比;EPD
十 先选拓扑15可压到 14通信频率与快慢线;+45% 对 +347% 先看分母、只调并发 +28%、每卡 2.09 倍;TP16 跨 DCN 与 ICI、NVL72 同域;device 编号就是拓扑、mesh_utils;最小切片纸面账、KV 三条路、DCP 帮不上、实测放不下用 FP4;容量扫到见顶由延迟定;两条对照纪律;五关落到两个例子;交棒投机解码
十一 投机解码32可压到 31(EAGLE 结构与 MTP 连猜可只讲两句)⭐ 先猜后验、只搬一趟;动画两次停顿各讲一步(出 3 个、出 5 个);拒绝采样保分布;fig-s11-step 时间线与「只说字数」;收益账=接受长度÷变慢倍数;V3 专家不白送(4.4 倍,偏高);K3 实测 4.81 倍;并发、上下文、DEP 三种缩法与 V4-Pro 峰值和端到端反向;温度坑(1.16% 对 34%,3.1 倍)与概率草稿;告警;草稿五代谱系、tree 图、n-gram 四格与 2.8 倍、DFlash;MTP→DFlash→DSpark 一条线(fig-s11-three 三行;MTP-1 为何只验 2 个、KV 注入、of problem、两刀、替下 MTP-1、占 MTP 的位子);11.4 三笔代价(占显存、默认值被改、PD 形状不齐)
十二 量化与融合23不能GPTQ→FP8→NVFP4 年份;位数减半下限减半(fig-s12-bytes 左右两半);vLLM FP8 实测与 AWQ 精度;MXFP4 与 NVFP4 块大小和缩放格式、训练 loss 对比;QAT 与 V4 发布格式;gpt-oss 参数账与专家压 4 bit;fig-s12-cap 放得下;少读;v7 没有 FP4 算力照样快、Marlin;FP4 精度只能说跑出来;ledger 整步只省一半;INT4 减 8 全崩;CUDA Graph 与分档、和 TPU 桶是两头;kernel 交接空等四成多、PDL、megakernel 与 Inferact;KV 存 FP8 的缩放校准、V3.2 布局 1.63 倍、NVFP4 KV 与 V4.1-Flash
十三 状态没法按 token 切10不能三种层能从哪儿接着算;PyTorch 博客三条难处;快照与退到 512、重算 88;拷到自己槽里;统一前缀树;一份快照 183 MiB 顶 6,250 字 KV、K3 顶 1.6 万字(本课推导);vLLM 三种留法(末尾、间隔、第二次撞见)与 SGLang 池满 LRU;右下 128K 三种留法 5%/不到两成/二十几倍;两个池与一种页、分层、int8 快照;前面撞过的四回
十四 落地(深讲)—不计时深讲,不计入总时长。导语(Qwen3.5 配置、三个问题);diff 图。14.1 四条规矩各配比方+机制:形状(现场点菜对中央厨房、成衣尺码+bucket 图、RPA 长度不进形状、跨 rank 回放=菜谱印八份、随 rank 变的值不进图)、通信(直拨电话对立体方阵、环形 all-gather 可预测、all-to-all 不可预测、XLA 排班大厨)、片上(仓库/工作台/便签本、异步 DMA 双槽、run_scoped、tile 补齐例子 1,024 对 512 字节)、数据格式(窄格式在向量单元解包)。14.2:GQA 不是 MLA(32 查询头/2 KV 头、复制 4 份、并发约 200 对 512;互动:副本倍数)、DP 注意力+EP、统一池(86%/9%、分池九成八闲)、GDN 换视图、PCP 按头切、KV 序列维最内、整层 Pallas MoE+SMEM;K3 对照①。14.3:ladder 四刀各讲瓶颈(SparseCore 间接寻址、切块未叠、融合上限 1.25 对 1.26、分层 reduce-scatter)、decode 三刀都在少搬字节;K3 对照② 三刀(层循环、为什么只能手写、VMEM 分时、MXFP4 换 FP8 互动);map 图;PCP/PD/路由/选栈;落点:先看 batch
十五 八问与收尾18收尾不能砍导语两半;eight 图(图钉、四色、3/4/7/8 钉在车上);15.1 前四问逐条(档位、尺子 36 倍、字节下限、KV 定 batch);15.2 后四问逐条(切法:换拓扑两倍多对调参二十几个点、拆 PD、量化与投机 4.22 倍、预编译),互动(投机变慢先查负载和尺子);八问一句话。15.3 市场降价三分、Epoch 观察、年份表只看三处(起点 36.9 倍、最挤的 2024、第二列环号)、不能连乘(互动)、5.1 倍揭晓开场悬念、MTP 拆不开与 TensorRT-LLM 量级、story 图六泳道+两股压力+不能连乘框、DeepSeek 一天只讲比例+4,950;课后题;问题链回收、留口子(线性层状态、前缀缓存得关)、回到 0.2 那一句
合计334第十六节(出处台账)不进课堂,被追问时翻

⛔ 上面那张表是计划,下面这张是地板。 「地板」= 把讲稿一字不落念完、再加切图的时间,一句现场发挥都没有,也不含等动画转完一圈的时间(全讲约 3 分钟)。每次 build 现数。

⏭ 互动另算:每个 💬 互动按 0.5′。 「含互动」= 地板 + 全部互动;「跳后」= 标了「⏭ 时间紧可跳」的互动改成直接说答案。超时先跳这些,别删台词。

节台词汉字切图地板计划给的互动 / 可跳含互动跳后
第零节 一次请求走一遍4,2532026.3′33′3 / 027.8′27.8′
第一节 prefill 吃算力,decode 吃带宽1,43689.2′12′1 / 09.7′9.7′
第二节 先校准尺子1,6561010.8′13′2 / 011.8′11.8′
第三节 批处理与调度3,4573626.3′31′4 / 128.3′27.8′
第四节 KV cache:账、池、复用3,5943526.7′31′4 / 328.7′27.2′
第五节 两块硬骨头3,0702421.4′22′2 / 122.4′21.9′
第六节 TEP 还是 DEP4,6952329.2′33′4 / 231.2′30.2′
第七节 切序列:DCP 和 PCP2,2001414.5′17′2 / 115.5′15.0′
第八节 拆工作:那一趟 KV3,4091921.8′27′4 / 123.8′23.3′
第九节 配几台、拆不拆2,1151414.1′17′1 / 114.6′14.1′
第十节 先选拓扑,再调参数1,9901112.7′15′2 / 213.7′12.7′
第十一节 投机解码4,3092928.8′32′3 / 230.3′29.3′
第十二节 量化与 kernel 融合3,0872220.9′23′1 / 121.4′20.9′
第十三节 新架构出难题:状态没法按 token 切1,35388.8′10′2 / 29.8′8.8′
第十四节 落地:把 Qwen3.5 在 TPU 上跑起来4,5263030.1′不计时2 / 231.1′30.1′
第十五节 第一天的八问2,2641414.8′18′2 / 115.8′15.3′
合计286′334′37 / 18305′296′

🧵 上台之前:把两条暗线记在心里

① 每一招都对着 decode 那「搬一趟」。 讲每一招都点名:是让这一趟分给更多 token(连续批、PagedAttention、投机解码),还是少搬(量化、MLA、融合); 还有一类把 prefill 和 decode 拆开各放各的机器(PD 分离)。第零节三根杠杆的图就是这条线的地图。 ⛔ 一旦讲成「接下来再介绍一个优化」,这条线就断了。

② 四年多的问题链:每一招补一个洞,又留下一个。 2022 年最慢的写完全批才退出,KV 按最大长度预留;之后先补调度和显存,同时压薄 KV;再拆开放,把 KV 当成存储;最后补「一趟只出一个字」,同时压权重。 同一套 GB300、同一个模型、同一交互档,光改软件每卡吞吐是首发日的 5.1 倍(PyTorch 博客;开场悬念,课件第十五节揭晓);市场降价另算,混着小模型和硬件。 ⚠️ 报告主要归给越来越强的小模型,硬件另算,提到时这半句不能省。
每节开头一句接住上一节留下的问题;结尾一句报这一步进步多少,带上口径(比谁、比什么)。

⭐ 如果只能让台下带走一句话: decode 每一步都要把权重和 KV 从显存里搬一趟。推理的每一招,要么让这一趟分给更多 token,要么干脆少搬。

🖥 投屏怎么放

⭐ 这一讲有三段动画(连续批、分页 KV、投机解码),全是无声循环。 放动画时先闭嘴看一遍,等它转完一圈再开口;边放边讲,台下眼睛和耳朵会打架。 投机解码那段会在每步结束时自己停住,停住的时候再开口。

⭐ 课件右下角有个「折叠讲解」按钮(或按 T),投屏前按一下。 不开的话,台下会低头读字,不听你讲。

第零节 一次请求走一遍(33′)计划 33′ · 含互动 27.8′

🖥 本节主屏:课件 第零节 一次请求走一遍 · 主图 fig-s0-map

🎯 这一节只留一句:decode 每一步都要把权重和 KV 搬一趟;每一招要么让这一趟分给更多 token,要么少搬。

🖥 屏幕:停在第零节开头的蓝框「开场新闻 · 2026 年 10 月:循环模型」。

「正式开讲前,先播一条新闻。上周 NVIDIA 放出一个四 B 的小模型,叫 Dory。它分三段:前八层、后八层各跑一遍,中间二十层是同一套权重,可以反复转。
想省算力就转一圈,默认两圈,写代码这类 agent 活开到四圈。权重只有一份,转几圈上线时再选。」

「十月初还有一篇论文,把账算得更清楚:同一个 checkpoint 转一圈,智能指数跟同尺寸的 Qwen 打平;转四圈,从十八分涨到二十九分。小模型多转几圈,往大模型那一档够。
留个问题:圈数从一加到四,每出一个字要从显存搬的字节,变还是不变?今天的主线就是这一趟搬运,零点二回来揭晓。怎么训、旧模型能不能改,下面折叠框里有,课后翻。」

💬 互动:举手,觉得变多的、觉得不变的各数一下。期望答案:先不揭晓,0.2 对答案。

🖥 屏幕:滚到第零节标题下那个折叠框「开场热身:五种并行,各自要用哪几种集合通信?」,点开;五行勾选先不点「对答案」。

「上课前先把上一讲捡回来。专题五切了五刀:DP、FSDP、TP、PP、EP,每一刀都多出一种通信。表上横着是五种通信:AllReduce、AllGather、ReduceScatter、AllToAll,再加一对一收发。
每一行勾上它训练一步要用的那几种,可以勾不止一个。给大家两分钟,自己勾,勾完我们一起点。」

💬 互动:各自在页面上勾,两分钟后一起点「对答案」,红底的行请一位说说当时怎么想的。期望答案:DP 勾 AllReduce;FSDP 勾 AllGather 和 ReduceScatter;TP 勾 AllReduce;PP 勾一对一收发;EP 勾 AllToAll。

「DP 和 TP 拆开勾成 AllGather 加 ReduceScatter 也算对,因为 AllReduce 本来就是这两半拼起来的;TP 配了序列并行,就正好是这么拆的。
推理只剩前向,这张表还能用,但轻重变了。TP 那几次 AllReduce 数据不多,卡的是延迟;EP 也不一定走 AllToAll,第六节会看到 TPU 上换成了 AllGather 加 ReduceScatter。」

💬 收起折叠框,回到课件封面,先不往下滚;下面两道题都口头问。

「先猜一个数。同一套 GB300、同一个 DeepSeek-V4-Pro、每个用户出字一样快,SGLang 光改软件,从四月首发那天到六月,每张卡每秒出的字涨了多少?一倍半、两倍,还是五倍?」

💬 互动:举手投票,三个选项各数一下人头,先不揭晓。期望答案:先不揭晓,第十五节对答案。

「记住你举的手,答案留到最后一节。卡没换、模型没换、跟手程度没换,涨出来的每一个字都是软件挣的。今天就追这一份:多出来的字,各是哪一招挣来的。
再留一道,第一节揭晓:一个人在 TPU v7 上跑 DeepSeek-V3,出一个字,算力用上了百分之几?一半,十分之一,还是更少?」

「先说跟上一讲差在哪。训练时答案已知,整段序列一起算,只看吞吐;推理得一个字一个字往外吐,还要守延迟。吞 prompt 那段叫 prefill,还像训练的前向,吃算力;往外吐字那段叫 decode,每步只出一个字,吃带宽。
一次请求里,前后两段要的硬件正好相反。今天这一课,几乎都在对付后面那段。」

🖥 屏幕:滚到「0.1 2022 年以来,推理怎么变便宜」,往下到 fig-s0-chain。先指左上图例(实心=系统侧、空心=模型侧),再从左边「2022」那一栏起,一年一栏往右指。

「这条轴上,每一招落在它第一次公开的那一年;圈里的数是环号。实心的是系统这一侧的招,空心的是模型那一侧的;点下面的箭头,是这一招一直做到哪一年。
我每年只说一件事:那一年最疼的是什么。」

「二〇二二年,疼的是『等』:一批请求要等最长的那个写完,才一起退场。环一 Orca 的连续批,让每一步都能有人进出。
同一年,种子几乎全埋下了:FlashAttention 把注意力切成小块放进片上算;环二 GPTQ 把权重压到三四位;环三投机解码,先便宜地猜几个字、大模型一趟一起验;Hopper 的张量核也开始直接算 FP8。」

「二〇二三年,疼的挪到了座位上。KV 是读过的内容留下的缓存,座位有几个,看它装得下几条;可那时按最长的可能给每人预留,真正存着字的只有两到近四成。环五 vLLM 分页存,浪费几乎省光;环四 GQA 把每条压薄,AWQ 把权重压到四位。
可上下文偏偏在变长,十一月 GPT-4 Turbo 开到 128K;座位一满,长 prompt 进门就卡住所有正在出字的人。环六 SARATHI 切块摊平,环七 Splitwise 干脆把两段拆到两批机器上,叫 PD 分离;环八 RadixAttention 让相同的开头不再重算。」

「二〇二四年,疼的是一台机器不够用了。Gemini 1.5 Pro 预览到一百万;MoE 又把拼好的 batch 拆散,每个字只走几个专家,每个专家只分到几行。
于是招数往机器之间铺:DistServe 把 PD 分离做成完整系统;环九 Mooncake 把存不下的前缀往内存、SSD 放;环十按序列切的 CP;环十一大 EP 把专家铺到上百张卡上凑行数。模型侧 DeepSeek-V2 的 MLA 把一层所有头的 KV 压成一份。九月 o1 让一题先想再答;年底 DeepSeek-V3 带上 MTP,自带一层多猜一个字。」

🖥 屏幕:指「2025」那一栏,再指几环点下写着「→2025」的箭头。

「二〇二五年,系统这一侧没有新起头的点,好几环的箭头都写着一直做到二〇二五。疼的是字变多了:R1 让思考 token 动辄几千。
DeepSeek 开源周放出 DeepEP 这些零件,SGLang 把大 EP 加 PD 分离复现出来;EAGLE-3 把投机解码再推一步;DSA 让每个字只挑两千零四十八条历史读;vLLM 合入 DCP,把长序列的 KV 按 token 分到几张卡上,第七节细讲。量化一直做到今天,到 Blackwell,四比特的 NVFP4 也进了张量核。」

🖥 屏幕:指「2025」底下空心的 ⑫,再指「2026」上方空心的 ⑬。

「最右两个空心点是模型这一侧的,思路早就有,图上放的是进入主流大模型的那一年。
环十二,Qwen3-Next 把大部分层换成线性注意力,每条序列只留一份固定大小的状态,后来 Qwen3.5、K3 都这么做;难在状态截不开,第十三节讲。环十三就是开场那条新闻:循环模型,这个月刚出来。」

🖥 屏幕:滚到「十三环展开」,展开图下的表,停在表上,别往下滚到说明段(那里写着 5.1 倍)。先指表头「解完又冒出什么」那一列,再顺着链跳着指行:① → ⑤ → ④ → ⑧ → ⑨ → ⑥ → ⑦ → ⑪ → ⑩ → ③ → ② → ⑫ → ⑬,每行只指最右那格。

「轴上讲的是哪年冒出来;这张表讲的是为什么冒出来。看最右这一列『又冒出什么』:每一招解掉一个麻烦,就留下下一个麻烦,下一环接着解。我顺着这根链走一遍,只念麻烦,不念倍数。
连续批让人随时上下车,可座位归 KV 管;分页把座位省出来,可上下文在变长;GQA、MLA 把每条压薄,可 MLA 切不开,开几路就复制几份;复用相同的开头,开头又多到显存放不下,只好往内存、SSD 放。」

「另一条线在机器之间。长 prompt 一进门全员卡住,分块 prefill 只把打扰摊薄;PD 分离干脆拆开,代价是多搬一趟 KV,还得调配比。MoE 把 batch 拆碎,大 EP 把专家铺开,每张卡又得自带一份状态,K3 开 DEP8 显存都不够;那就按序列切,可 DCP 只在长上下文划算。
最后是出字这一头:思考题动辄几千个字,投机解码一趟验几个,人一多就缩水;剩下能省的只有字节,量化接着压。环十二、十三是模型侧自己动刀,各留一道新题,在第十三节和零点二。」

「中间那列倍数我不念,课后看表。只拿一个当示范:连续批那一环,同延迟吞吐三十六点九倍,对的是 FasterTransformer。每个倍数都带着『对谁』,基线各不相同、彼此包含,千万别乘起来。
合起来涨了几倍,只有同卡、同模型、同档位的那一个数说了算,就是开场那道题。」

🖥 屏幕:指表下那段开头「两股外力」,再往下到 fig-s0-twolong,先指 Ⓐ「① 短 prompt、短回答」,再指 Ⓑ「② prompt 变长:每一趟更重」,最后指 Ⓒ「③ 回答变长:趟数变多」。

「这根链为什么越拉越紧?轴上头那两条细带,是两股外力:上下文变长,输出变长。这张图把它们画开。
每根柱是 decode 的一趟,高度是这一趟要从显存读的 KV;整块面积,就是这个请求一共要读的 KV。先看 ①,短 prompt、短回答,当个基准。深紫是 prompt 留下的 KV,浅紫是已经写出的字留下的。」

「看 ②,prompt 变长:深紫变厚,每一趟都多读,把面积拉高。看 ③,回答变长:柱子多了好几倍,写出的字也进 KV,越往后越高,把面积拉长。
推理模型走的就是 ③;长 prompt 再配上长回答,面积又高又长。格子数是随手取的示意,只为三块能放在一起比。」

🖥 屏幕:滚到「全课的账建在 DeepSeek-V3」那一段。

「后面的账,全建在 DeepSeek-V3 上,二〇二四年十二月发布。MoE,总参数六千七百一十亿,每个 token 只激活约三百七十亿。记住三百七十亿,等会儿它会变成三十七 GB。
市面上推理这两年便宜得很快,斯坦福 AI Index 二〇二五主要归给更强的小模型;系统那一份单独拆不出来。所以开场那道题,挑的是同卡、同模型、同档位的数。」

🖥 屏幕:往下指「这几年的引擎主要是 vLLM 和 SGLang 两家轮流领先」那段,再指段首「其他耳熟的名字落在哪。」和下一段 TGI、llama.cpp。

「这些招落在谁的代码里?这几年主要是两家引擎:vLLM 和 SGLang。先把场上其他耳熟的名字认一认。TensorRT-LLM 是 NVIDIA 自家的引擎,和这两家同一层。
Triton Inference Server 二〇二五年改名叫 Dynamo-Triton,它是通用的模型服务器,不只管 LLM;LLM 那些专门的活,PD 分离、前缀缓存、KV 落到存储,NVIDIA 交给它上面的 Dynamo。」

「Hugging Face 的 TGI 已经进入维护模式,官方自己改推 vLLM、SGLang 这些引擎。LMDeploy 是上海 AI 实验室的引擎。
llama.cpp、Ollama 是跑单机、跑端侧的,本课讲数据中心,不展开。⭐ 所以全课用 vLLM 和 SGLang 当主线,不是漏了别家,是这两家代表了数据中心推理的主流。」

🖥 屏幕:往下到 fig-s0-engines,从左到右按点走:先上面蓝线「2023-06 PagedAttention」,再交替指上下两条线,中间带过两个外部锚点,最后停在右下「2026-06 GB300 × V4-Pro」。

「两家怎么你追我赶?上面蓝的 vLLM,下面红的 SGLang。带底色的小条是跟进的一方,颜色是先做的那一家。
二〇二三年六月 vLLM 首发分页。半年后 SGLang 首发 RadixAttention,博客写明用了 vLLM 的部分代码。七月 SGLang 的 v0.2 拿纯 Python 写调度,吞吐最多是 vLLM 0.5.2 的三倍多。九月 vLLM 新版博客自己承认,CPU 开销拖累了 GPU;原文没说是回应谁。」

「中间两个是外部锚点:十一月 Mooncake 传输引擎开源,转年二月 DeepSeek 开源周。十二月 vLLM 先接上 Mooncake,同月合入首批 PD 代码,SGLang 晚了三个多月。
转年一月 vLLM 重写成 V1,致谢里点了五家引擎,SGLang 在内,原话是对他们影响显著。五月 SGLang 复现大 EP 加 PD,一年后又在 GB300 上交出开场那道题。」

「分工也看得出来:分块 prefill、接 Mooncake,是 vLLM 先;MLA 优化、MTP、EAGLE-3、大 EP,是 SGLang 先。
可更多零件两家从同一个货架上拿:FlashInfer、xgrammar、DeepEP 和 FlashMLA、Mooncake、NIXL。你追我赶,零件却多半出自同一个货架。」

🖥 屏幕:滚到「完整时间线」,展开表,依次指「分块 prefill 在引擎里先落地」「MTP 先合入(02-14)」「DeepSeek-V3.2(DSA)」「DeepSeek-V4」四行。

「图上只留了八个时刻,这张表是全的,课后翻。台上只看一件事:一家先做,另一家晚多久。二〇二四年分块 prefill,vLLM 先落地,SGLang 晚三个多月;到二〇二五年,MTP 只晚五天;DeepSeek-V3.2 一出来,两家同一天首发日支持。
二〇二六年四月 DeepSeek-V4,两家前后差一天首发日支持,这就是开场那道题的起点;六月 SGLang 在 GB300 上交卷,倍数留到最后一节。这些间隔都是按两边日期本课推算、往下取整的。」

🖥 屏幕:滚到「0.2 一个请求的一生,和全课一句话」,fig-s0-life:先指 Ⓐ 上面「在做什么」那一行和红点,再指 Ⓑ 中间「KV 有多长」的紫色阶梯,最后指 Ⓒ 最下面那行「从显存读什么」。

「一个请求就两段。上面一行是在做什么:先排队,再 prefill,整段 prompt 一次算完,红点是第一个字;之后一步一个绿格,一格出一个字。
用户只感觉两个数:从进门等到第一个字,含排队,叫 TTFT;之后平均每字隔多久,叫 TPOT。前者看排队和 prefill,后者看 decode,第二节细说。」

「中间一行是显存里的 KV 有多长:prefill 一次写满整段 prompt 的 KV,之后每出一个字长一格,紫色阶梯每一步都在长。
最下面一行说,每走一步都要读一遍权重和全部 KV。图下那两句就是两段的账:prefill 读一遍权重,分给几千个 token 一起算,卡在算力;decode 读一遍权重和全部 KV 只出一个字,卡在带宽,而且越往后 KV 越长,这一趟越重。」

🖥 屏幕:往下指段首「住在哪。」「多大。」「跟长度成正比。」三段。

「读的是什么、放在哪、有多大?先说住在哪。权重和 KV 都常驻 HBM,就是芯片自带的显存。真正做乘加的地方旁边只有一小块片上存储,一颗 v7 合起来一百二十八 MiB,只有显存的一千五百分之一。
几十 GB 塞不进去,所以每一步都得从显存重新流一遍。」

「再说多大。V3 出一个字要用到三百七十亿参数,FP8 每个一字节,约三十七 GB。
KV 是这个人自己的历史,一人一份,跟长度成正比:上下文一万个 token,一条约零点七 GB;到 128K,八点五八 GiB。每层每个字存多少,等会儿在逐层图上算。」

🖥 屏幕:往下滚到 fig-s0-layer,标题「出一个字,61 层逐层走一遍:」。先指第一行左边两根蓝绿条,再指紫条,再指右边小方块和箭头;然后从上往下扫到「输出层」那一行。

「这张图一行是一层,条长按字节数同一比例画,数都是本课按 config 推的。看第一行:新来的字带着一条七千一百六十八维的向量进来。
先读权重:蓝条是注意力,一百八十七 MB;绿条是稠密前馈,三百九十六 MB,整块读一遍。」

「再读紫条,这是本层的 KV。新字要跟之前每个字算一遍相似度,再把它们的 V 加权求和,所以 KV 从头读到尾,一格都跳不过。上下文一万字,这一层就是十一点五 MB;128K 是一百五十一 MB,跟注意力权重一个量级了。」

「读完留下两样。第一样,在本层 KV 末尾给这个字添一格:五百一十二维压缩 KV,K 和 V 都从它解出来,再加六十四维位置编码那截,一共五百七十六个数。每个数 bf16 两个字节,所以是一千一百五十二字节。五百七十六是个数,一千一百五十二是字节,别弄混。
第二样,那条七千一百六十八维向量传给下一层。其他中间结果算完就丢。」

「往下扫。第一到三层是稠密的,前馈整块读;config 里那个参数叫 first_k_dense_replace,值是三。从第四层起是 MoE,二百五十六个路由专家里只读挑中的八个,加一个共享专家,读量跟稠密层几乎一样。
六十一层合计三十五点七 GB。」

「最后过输出层,拿这条向量给整张词表打分,零点九三 GB,挑出下一个字。全部加起来约三十七 GB,记住这个数,第一节要用。
下一个字,从第一层重来,权重和 KV 再读一遍。」

🖥 屏幕:往下指「几个人同时 decode 时」那一段。

「几个人同时 decode 呢?注意力和稠密层的权重大家共用:读一遍,每人各出一个字。专家不一样:各人挑的八个不同,按均匀路由算,六十四人就碰到将近九成,一百多人几乎挑遍,每层专家都得整块读满。这是本课推的,第一节再看。
KV 更不行,它是每个人自己的历史,各读各的。」

🖥 屏幕:往下停在绿框「一句话」,讲完再放 fig-s0-map:先指中间仓库,再指路上那辆车和右边工位,最后指上面三组彩色标签和右下「量这一趟」。

⭐⭐⭐ 这一句是全课的地基,讲慢。

「全课就一句话:decode 每一步都要把权重和 KV 从显存里搬一趟;推理的每一招,要么让这一趟分给更多 token,要么干脆少搬。还有一类不碰这一趟:把两段拆开,各放合适的机器。
仓库是显存,工位是算力,搬一趟就是车跑一趟。几个人同时 decode,权重这一车大家共用,KV 是各人自己的历史,各搬各的。」

「所以车上多坐人,是一趟分给更多 token;货变轻,是少搬;开两个仓库,是把两段拆开,左边那个虚线框就是专吞 prompt 的仓库。
上面三组标签把后面的节挂上去。橙色开两个仓库,第八、九、十、十四节;绿色货变轻,KV 记得省、kernel 不白搬、再加第十二节的量化;蓝色车上多坐人,这组最大,批处理、切专家、切序列、投机解码都在里面。底下第一节量这一趟,第二节校准量它的尺子。」

🖥 屏幕:往下停在蓝框「回到开场新闻:多一圈,就多搬一趟」。

「拿这句话回头看开场那条新闻。Dory 中间那二十层,权重是 GB 量级;工位旁边那块片上存储才一百二十八 MiB,放不下。
所以每转一圈,这二十层都得从仓库重新拉一车。转四圈,每出一个字搬的权重,跟一个九十六层深的普通模型一样多。答案是变多,搬运一点没省。」

「那它省了什么?省的是仓库面积。存三十六层,跑出九十六层的深度,权重只占约百分之三十八,这是本课推的。腾出来的地方多放 KV、多坐人,这一趟就分给更多 token。
新麻烦在 KV:每圈各存一份,四圈就是一圈的二点五倍;只留最后一圈的 KV,就压回一圈的大小,大部分收益还在。另外圈数多了答得更短,四圈少出三成多的字;每个字慢了,整道题不一定慢。」

🖥 屏幕:滚到「遇到不认识的词,回这儿查」,展开词表,按组往下指。

「这一节底下收着一张词表,全课的词都在里面,课上碰到就回这儿查。只点三组最容易混的。
一,TTFT 含不含排队要写清;TPOT 是首字之后的平均间隔,ITL 是每一次的间隔,看 p99 用后者。二,『每 token 激活的参数』是 MoE 每个字真正走过的那部分参数,不是每层的中间结果『激活值』。三,一颗 TPU v7 芯片对软件显示成两个 device:规格按芯片写,并行度和切片名按 device 数,v7x-8 是四颗芯片。」

「其余的词,TP、EP、DEP 这些切法,goodput、Little 定律、connector,都等正式出场那一节再讲。」

🖥 屏幕:滚到「出场角色」,展开,指「DeepSeek-V4-Pro / V4-Flash」那一行。

「最后一张出场角色,课后翻。只记一件:课里 GPU 那边的实测,大多来自 DeepSeek-V4-Pro 在 GB300 上的部署记录。」

🖥 屏幕:回到 fig-s0-map,指最下面「每出一个字,搬一趟」和「第一节」。

「词和人都认齐了,回到地图最底下:每出一个字,搬一趟。这一趟到底多重、芯片在它面前闲了多少,第一节来量;开场第二道题,就在那儿揭晓。」

⚠️ 这一节最容易跑偏的地方 ⛔ 5.1 倍留到第十五节揭晓,这里说漏就没有悬念了。课件 0.1 折叠表下的说明段写着这个数,台上展开表时停在表上,别滚下去。第二节的 2,200 → 11,200 也只让台下心里除,别替他们除。
⚠️ 十三环那张表只走「又冒出什么」那条链,倍数只念环一的 36.9 倍(对 FasterTransformer)当示范,其余留在表上;念完那句「不能乘」。被问某一环的倍数,指表上那格,连同「对谁」一起说。
⚠️ 口播取整与省掉的原数(R11):片上存储=每个 TensorCore 64 MiB × 2 = 128 MiB,对 192 GiB HBM 约 1/1,500;KV 每层每字 1,152 B、61 层 70,272 B 在课件 0.2;逐层图每层合计 583 MB(MoE 层 585 MB,多 1.8 MB 路由打分),传给下一层的向量 14,336 字节,输出层 7,168 × 129,280,合计 36.6 GB;「将近九成」=64 人碰到 256 个专家里约 222 个(87%),每层专家读满 11.3 GB(本课推导)。完整时间线其余各行(MLA 优化、EAGLE-3 晚五周、Dynamo、KV Connector、HiCache、v0.11、Wide-EP、MRV2、Inferact)台上不念,被问指表。
⚠️ R17 口径(0.1 时间轴改成「每年最疼的一件事」后撤下口播的月份与细节,被问时照这里答):2023-06 vLLM PagedAttention、2023-08 SARATHI、2023-11 Splitwise、2023 年底 SGLang 论文提出 RadixAttention;2024-02 Gemini 1.5 Pro 预览一百万、2024-09 o1;Mooncake 给 Kimi 线上用;SGLang 的 DP attention 与 DeepSeek 大 EP 一起把专家铺开;DistServe 的代价是每个请求多传一趟 KV、多一份配比要调(十三环链那段仍讲);2025-01 R1、2025-02 开源周、2025-05 SGLang 复现大 EP+PD、2025-03 EAGLE-3、2025-09 V3.2 的 DSA、同月 vLLM 合入 DCP,兄弟 PCP 切 prompt 压首字(第七节);环十二 Qwen3-Next 是 2025-09。
⚠️ 投机解码:课件写的是 2022-11 Google 提出、DeepMind 2023-02 独立提出,别说成「同年各自提出」。
⚠️ 双引擎跟着图上的点从左往右走:vLLM 分页首发、SGLang 首发复用代码、v0.2 三倍多、vLLM 自承 CPU 开销(原文没说是回应 v0.2)、两个外部锚点、接 Mooncake 两家差三个多月、V1 原文致谢、大 EP 复现、GB300 那一格。图上没连线的先后,台上也别说成谁学了谁;被问「SGLang 是不是专门冲着 vLLM 的调度去的」,答:课件只记了时间先后,没有这层因果。
⚠️ 五点一倍是软件栈全部改进的合计,后来开的 MTP 也算在里面,揭晓时别说成某一招的功劳。课程不引价格口径的降价倍数,被问到市场降价,只说「AI Index 主要归给更强的小模型,系统那份拆不出来」。
⚠️ 第二道题这里不揭晓。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「token 和字是一回事吗?」→ 不完全是:token 大致是一个字,课件 0.1 那句括号就这么写。台上说「字」只为顺口,课件的数都按 token 计。
🛠 GPU 老兵「市面上推理降价,推理系统占多少?」→ 课件没拆,AI Index 主要归给更强的小模型。系统这一侧最干净的一笔就是开场那道题:同卡、同模型、同交互档,第十五节揭晓。
💰 管预算的「那我们的成本能降多少?」→ 开场那道题就是答案,第十五节揭晓,先别说数。档位放宽还能更多:同一条曲线上每用户从 173 降到 68 个字,每卡吞吐是原来的十倍多(9,759 ÷ 895,本课按图上的数算)。
🧑‍🎓 新人「九点二一 GB 和八点五八 GiB 是两个数吗?」→ 同一份 KV,GB 按十进制、GiB 按二进制,换个单位而已(第一节)。

第一节 prefill 吃算力,decode 吃带宽(12′)计划 12′ · 含互动 9.7′

🖥 本节主屏:课件 第一节 prefill 吃算力,decode 吃带宽 · 主图 fig-s1-b1

🎯 这一节留三样:decode 一步几乎全在读;人多、上下文长了,KV 接过主角;MoE 把拼好的 batch 又拆散。

🖥 屏幕:滚到「训练、prefill、decode 摆在一起比」,指下面那张三列表的「一步喂进去的」和「卡在哪」两行。

「开场说过推理跟训练差在哪,这张表把三样摆一起,只看两行。
一步喂进去几行:训练是整批完整序列,prefill 是一段 prompt,几千行;decode 每人只有一行。矩阵乘里每个 token 占一行,行数差了三个数量级。
卡在哪:prefill 卡算力,decode 卡显存带宽。行数一少,瓶颈就从算力换到了带宽。其余几行课后对一下。」

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

🖥 屏幕:滚到「1.1 一次喂几行,决定卡在哪」,先停在正文那两句,再到 fig-s1-ai,指红色横线。

「先认一条线。专题二讲过屋脊点:每读一个字节要做多少次运算,算力才不闲着。v7 按 bf16 算,每个数两字节,屋脊点是三百一十三,就是这条红线。线上面卡算力,线下面卡显存带宽。」

「强度怎么算?矩阵乘一次喂进 M 行,每个权重就要做 M 次乘加,也就是两 M 次运算,而它只占两个字节。只算读权重,每字节的运算次数,就是两 M 除以二,等于 M。
一次喂几行,强度就差不多是几。图上算的是一块七千一百六十八见方的 bf16 矩阵,正好是 V3 隐藏维那么宽。横轴就是这个 M,两轴都是对数。行越多,同一块权重分给的人越多,点越往上。」

🖥 屏幕:依次指三个绿点「decode 1 人:每字节算 1 次」「decode 64 人:每字节算 63 次」「decode 256 人:每字节算 239 次」,再指「一次喂到约 343 行才过屋脊点」,最后指橙点。

「绿点是 decode,M 就是同时解码的人数。一个人,每字节只算一次;拼到两百五十六人,也才两百三十九次,还在红线下面。
曲线比 M 低一点,因为每层的输入、输出也要读写,这是本课推的。要一步凑够约三百四十三人才过线。」

「橙点是 prefill:一段 4K 的 prompt,一次就是四千零九十六行,远远过线。
图底下那两句:同一块芯片,prefill 时算力是瓶颈,decode 时显存带宽是瓶颈。decode 再多拼人也难过线,prefill 一段就过。」

「零节那张逐层图,六十一层加输出层的权重约三十七 GB,每出一个字读一遍。带宽这头,一颗 v7 每秒读七点三七 TB。读一遍要多久?」

💬 互动:屏幕先别往下滚,下面那行加粗的字就是答案。停五秒,等两三个人报数。期望答案:约 5 毫秒(37 ÷ 7.37)。有人报「五秒」,提醒一句:分母是 TB,单位差一千。

🖥 屏幕:滚到「一个人解码一步:5 毫秒在读,0.016 毫秒在算」,fig-s1-b1,先指上面「读权重」那根长条,再指几乎看不见的橙条,最后指红字「算力利用率 0.32%」。

「读一遍,约五毫秒。算呢?只要零点零一六毫秒。算的一侧按 W8A8 计,就是权重和激活值都用八位。
其余时间,MXU 都在等数据。」

⭐⭐ 下面这块是开场第二道题的揭晓,停一拍再说。

「开场第二道题的答案:零点零一六除以五点零二,算力只用上百分之零点三二,正好是三百一十三分之一。
猜十分之一的,也猜高了三十多倍。」

「所以换更快的 MXU 毫无用处,这一步的下限是显存带宽定的。
这五毫秒是理想下限:只算权重,不算 KV、通信和 kernel 开销;按每芯片规格算,摊到多颗芯片上比例不变。实测离它越近,带宽用得越满。可这一趟,只出了一个字。」

🖥 屏幕:滚到「1.2 KV 和 MoE:拼好的 batch 又被拆薄」,fig-s1-wkv,先指图例蓝段、紫段,再按 Ⓐ 最上面一组「1 人同时解码」、Ⓑ 中间一组「64 人同时解码」、Ⓒ 最下面一组「256 人同时解码」往下走。

「一个人用不满,那就拼人。可权重一次读完能分给一整批人,KV 却是每人自己的历史。还记得逐层图上的蓝绿条和紫条吗:那张图是一个人的量。
这张图每根条是一步里分到每个字的字节:蓝段是一步读的权重除以人数,人越多越短;紫段是这个人自己的 KV,只跟上下文走。」

「先看最上面一组,一个人:整份三十七 GB 只给他一个,KV 是零头,到 128K 也才两成。
中间一组,六十四人:每人摊到的权重,并没有缩成六十四分之一。每人挑的专家不同,一步里八成七的专家都会被碰到。」

「这八成七怎么来?一个专家,六十四个人都不挑它的概率,是一减二百五十六分之八,再自乘六十四次,约一成三;剩下八成七都被碰到。这是本课按均匀路由推的。
这一组到 128K,KV 已经占一半。」

「最下面两百五十六人:权重摊得更薄,128K 时 KV 占到七成八,主角换了。KV 是每人自己的历史,拼多少人都不变,而且这还是 MLA 压过的。
光拼人摊不动了,再往后省的就得是 KV 本身,第四、七节。」

🖥 屏幕:滚到「MoE 把拼好的 batch 又拆散」,fig-s1-moe,先指 Ⓐ 左边「稠密层:256 人共用一块权重」,再指 Ⓑ 右边「MoE 层:一个专家」那条细线,最后指底下「256 × 8 ÷ 256 = 8」。

「MoE 再拆一刀。拼 batch,就是让读一次的权重多喂几行。可 V3 每层有两百五十六个路由专家,每人只挑八个。同样来两百五十六个人,摊到每个专家,平均只剩八行。
方块是 v7 的 MXU,做矩阵乘的单元,一边正好宽两百五十六。」

「左边稠密层,两百五十六人共用一块权重,正好填满一边,强度约两百三十九,仍在线下,但离三百一十三差得不多。
右边一个专家只剩一条细线,占一边的三十二分之一,强度约八,跟稠密层差三十倍。读一遍权重只算几行,更卡带宽。八是均匀路由下的平均数;共享专家大家都走,不受影响。」

🖥 屏幕:往下停在绿框「这一节只要带走一件事」。

「让专家吃饱,得把很多卡上的人收到一起,那是第五、六节的事。
这一节带走一句:prefill 卡算力,decode 卡带宽;decode 每一步都要把权重和 KV 搬一趟。要让这一趟分给更多人,先得让批一直坐满、装下更多人的 KV,那是第三、四节;再把被 MoE 拆散的行收回来,第五、六节。」

🖥 屏幕:回到 fig-s0-map,指最下面「量这一趟」和「第二节」。

「回到地图,这一节没拉杠杆,讲的就是中间那一趟本身。后面每一节都拿倍数说话,倍数先得有把准尺子。所以动手之前,第二节,先校准尺子。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 强度只推到「2M ÷ 2 = M」这一步(课件正文就到这儿);曲线为什么比 M 低,只说「输入输出也要读写,本课推的」,更细的式子在图的「出处与口径」里,被问再写。
⚠️ 五毫秒、百分之零点三二是按规格推的理想下限,不是实测,台上要说出来。原数:5.02 ms = 37 GB ÷ 7.37 TB/s;0.016 ms = 一个字约 740 亿次运算 ÷ 每秒 4,614 万亿次(W8A8)。FP8 屋脊约 626 那句挪进备答。
⚠️ 1.2 口播只留「两成 → 一半 → 七成八」和 87% 的来历;省掉的原数:1 人时 KV 占比 4K 0.8%、32K 6%;64 人每人摊 9.14 GB;256 人每人摊 2.62 GB;128K 每字 KV 9.21 GB(=0.2 的 8.58 GiB)。
⚠️ 图上「1/32」只表示占了 MXU 一边的多少,别讲成「专家慢三十二倍」;跟稠密层比的是强度,差三十倍。
⚠️ 「八成七的专家被碰到」是均匀路由下的推算;被问「真实路由呢」,答「课件只算了均匀路由;不均时专家那步要等最慢的卡,第六节讲」。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「屋脊点到底是什么?」→ 算力除以带宽:每读一个字节至少做这么多次运算,算力才不闲。v7 按 bf16 是 313。
🛠 GPU 老兵「H100 上也是这样吗?」→ 道理一样,只是比值不同;课件只算了 v7,别现场报 GPU 的屋脊数。decode 拼满 256 人还在线下,这个方向两边都成立。
🛠 GPU 老兵「为什么 bf16 屋脊 313,FP8 那里又说 626?」→ 同样的带宽,FP8 算力翻倍、每个数只占一字节,所以每字节要做的运算多一倍;图下那句就这么写。
💰 管预算的「那 decode 是不是该买带宽大的卡?」→ 下限确实由带宽定,但先让一趟分给更多人往往更便宜:第六节换拓扑,同样的并发,每卡吞吐就是 TP4 的两倍多。
🧑‍🎓 新人「MoE 为什么不让所有专家都算?」→ 每个 token 只挑 8 个,是为了每个字算得少;代价就是 1.2 那张图,batch 被拆散到各个专家。

第二节 先校准尺子(13′)计划 13′ · 含互动 11.8′

🖥 本节主屏:课件 第二节 先校准尺子 · 主图 fig-s2-rulers

🎯 这一节只留一句:报一个吞吐,要连同口径一起报;先定交互档,再比吞吐。

🖥 屏幕:滚到「同一次测量,换一种数法」那句开头。

「这四年多里每一招都号称快了几倍。要说清每一招省了多少,先得有把尺子。
卖个关子:这套部署 prefill 和 decode 分在不同的卡上。同一次测量,报告里一处写每卡五千二百七十;翻到另一处,写的是一万一千八百八十。谁错了?先记着,这一节后半揭晓。」

🖥 屏幕:滚到「2.1 四个时间指标,一条吞吐—交互性曲线」,fig-s2-metrics:先指 Ⓐ「TTFT:进门 → 第一个字」那段,再指 Ⓑ 带 3 个字的那一格「ITL:这一次间隔」,最后指 Ⓒ 下面「TPOT = 这一段 ÷ (字数 − 1)」和「≈ 1000 ÷ TPOT(ms)」。

「从时间指标说起。这条时间线:排队、prefill,然后一个个绿块,每块是一次到手的一段字,宽度按字数画。
TTFT 是进门到第一个字,含排队、prefill、网络;四个指标里只有它从进门算起。压测时它往往大半在排队:同一个 Gemma4-31B,一个人时不到一百毫秒;两百五十六人一起,将近八秒。」

「TPOT 是首字以后这一段,除以字数减一,每个请求一个平均数。每用户每秒拿到几个字,约等于一千除以 TPOT 的毫秒数。
ITL 是每一次的间隔。开了投机解码,一次能吐好几个字,带三个字的那一格间隔最长。要看最慢的那几次、看 p99,就得看它。」

「同一个词,两家定义可能不同。NVIDIA NIM 的 ITL 是平均值,它自己注明也叫 TPOT;vLLM 的 ITL 是逐次间隔的列表。
拿到一个 ITL,先问是哪一种:平均值看不出最慢的那几次。」

🖥 屏幕:滚到「吞吐和交互性是一条曲线」,fig-s2-pareto,先指绿色三点「9,759 @ 68」「3,816 @ 121」「895 @ 173」,再指「先定档:每用户 50 tok/s」那条竖线,再指线上的 2,200 和 11,200,最后指最左边「9,168 @ ≈ 17」。

「横轴是每用户每秒几个字,越右越跟手;竖轴是每张卡每秒几个字,只数输出、只除 decode 卡。
绿色三点是公开基准 InferenceX 上 Dynamo 加 vLLM 的同一条曲线:每用户从六十几个字提到一百七十几,每卡吞吐掉到原来的不到十分之一。每人等久一点,一步就能多拼几个人,每卡吞吐就涨。所以先定档,再在这一档上比吞吐。」

「看竖线,每用户五十个字这一档,蓝的两点出自 SGLang 那篇博客。同一套 GB300、同一个 V4-Pro,首发日每卡约两千二,没开 MTP;二〇二六年六月再测,涨到一万一千二,开了 MTP。开场那道题,心里除一下,先别喊,最后一节对答案。
它跟开头那个一万一千八百八十只差几百,却不是一回事:那个数换了一把尺子,下面揭晓。」

「这一档上,一万一千二除以五十,每卡约两百二十四个用户同时在线。
最左边橙色那个点是我们自己实测的 SGLang dep8,数看着离一万一千二不远,可它落在每用户约十七个字的低档。档不同,不能直接比高低。其余的点分属不同框架和配置,也不在一条线上。」

「DistServe 二〇二四年把『先定档』做成一个指标,叫 goodput:规定比例的请求,比如九成,首字和字间隔都同时达标时,每张卡能扛的最大请求速率。
后面说哪种配法『赚』,都按它算。」

💬 互动:先别切图(四把尺子那张图的框格就是答案),屏幕停在曲线图上问「这一节开头那两个数都没错,差在哪?提示一下:这套部署 prefill 和 decode 分在不同的卡上」。期望答案:分子(只数输出,还是输入加输出)和分母(只数 decode 卡,还是全部卡)。有人答出一半就补另一半。

🖥 屏幕:滚到「同一次测量,四把尺子」,fig-s2-rulers,先指上面图例「decode 卡 16 张」「prefill 卡 48 张」,再从上往下四根条,最后指「最大 ÷ 最小 = 36 倍」。

「回到这一节开头那两个数:谁也没错。两段放在不同的卡上,每卡每秒多少字就有两处能挑:分子数不数输入,分母算不算 prefill 卡。
这次部署是八 K 进、一 K 出,decode 卡十六张,prefill 卡四十八张。先比框住的格子再看结果条:分子框得越多、分母框得越少,数越大。」

「实心两根,是我们自己那次跑、按公开基准 InferenceX 的两种口径报出来的:只数输出、只除 decode 卡,五千二百七十;输入加输出、除以全部六十四张卡,一万一千八百八十。
虚线两根是本课补算的,没有工具这样报;最大和最小差三十六倍。」

「这个三十六,本课按图上的数推:每个请求输入是输出的八倍,分子差约九倍;卡数六十四比十六,分母差四倍;九乘四。
官方标称的一万一千二,官方没写怎么数,本课按第一种读:只数输出,只除 decode 卡。」

「所以看到每卡吞吐,先问分母。只数 decode 卡,prefill 的成本就藏起来了。
TPU 上还多一层:一颗 v7 芯片显示成两个 device,按 device 报的,只有按芯片的一半。」

🖥 屏幕:滚到「2.2 尺子以外的四个坑」,fig-s2-traps,先指 Ⓐ 左格「峰值当稳态」上下两根,再指 Ⓑ 右格「没预热」上下两根。

「尺子以外还有坑,每一个都能单独让数差出一截。每格上面是坑里的数,下面是改对之后的数。
左边,峰值当稳态:同一轮,引擎自报的峰值比整轮端到端虚高一成多。峰值只是某一刻的最高值,对标要报端到端。」

「右边,没预热:同一套配置,第二轮是第一轮的两倍。第一轮要编译、把缓存填热,报第二轮。
左边的坑让数虚高,右边的坑让数虚低。两组是各自独立的实测。」

🖥 屏幕:往下指图下那四条「上限依赖负载」「峰值和稳态」「温度」「预热和闭环」。

「图下四条里还有两个坑。上限依赖负载:换一组请求或一项配置,最大吞吐就变;第四节只挪了两个 KV 池之间的隔板,每卡就涨百分之五十四。
温度,是选字的随机程度,零就是永远挑最可能的那个字。压测和线上不对齐,投机解码的接受率会差一大截,为什么,第十一节讲。」

「还有开环和闭环:闭环是答完一个才发下一个,开环按固定节奏发。闭环会把吞吐压低,对标官方的数要用开环。」

🖥 屏幕:滚到「2.3 落到钱上」,指第一段那条成本式子。

「最后落到钱上。每百万输出 token 的成本,等于每卡每小时的价,除以每卡每秒的字数乘三千六百,再乘一百万。
式子不用记,记一句:卡价不变,每卡涨几倍,每个字就便宜几倍。二点一那一档,每卡从约两千二到约一万一千二,正是开场那道题的数据;倍数和成本,第十五节一起对账。」

🖥 屏幕:往下指「线上真有人选吞吐那头」那一段。

「线上真有人选吞吐那头。DeepSeek 公布过一天的线上数:decode 时每个节点每秒输出约一万四千八百个字,可每个用户只有二十到二十二个。
便宜,是拿交互档换来的。」

🖥 屏幕:往下停在绿框「这一节只要带走一件事」。

「所以报一个吞吐,要连同五样一起报:分子分母、交互档、峰值还是稳态、温度和采样、有没有预热和是不是开环。缺一样,差距可能全是口径。」

🖥 屏幕:滚到「考考自己」,先不展开。

💬 互动:念题「一份材料写每卡 12,000 tok/s,超过官方。你要先问哪三件事?」停十秒再展开。期望答案:分母只算 decode 卡还是全部、分子含不含输入;在每用户多少 tok/s 的档位测的;峰值还是稳态。TPU 上再加一问:卡按芯片还是 device 数。

「三件事:分母只算 decode 卡还是全部,分子含不含输入;在每用户多少字的档位测的;峰值还是稳态。TPU 上再问一句:卡是按芯片数,还是按 device 数。
尺子对齐了,接下来量第一节那件事:一趟搬运能分给几个人。先看谁在什么时候上车,第三节。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 四把尺子:实心两根(5,270、11,880)是我们自己那次 SGLang V4-Pro 跑、按 InferenceX 两种口径报的,台上念;虚线两根(1,318、47,520)是本课补算,台上只说「差三十六倍」,被问再报。「三十六 = 约九 × 四」是本课按图上的数推,台上要说出来。
⚠️ 11,200 的分母官方没写明,本课按 output ÷ decode 卡读;被问就照这句答,别说成官方口径。
⚠️ 口播取整(R11):Gemma4-31B 首字 86 ms → 7,756 ms 说「不到一百毫秒 → 将近八秒」;曲线三点 9,759 @ 68、3,816 @ 121、895 @ 173 说「六十几 → 一百七十几、不到十分之一」;本仓库 9,168 @ 约 17(TPOT 约 60 ms)不报数;峰值 12,070 对端到端 10,704(虚高 13%)说「一成多」;预热 13,585 → 27,803(2.05 倍)说「两倍」。
⚠️ 温度那个坑只讲到「接受率会差一大截」,为什么掉留给第十一节。
⚠️ 2.3 只讲课件正文那两段:成本式子和 DeepSeek 一天的线上数(每节点约 14,800、每用户 20–22)。理论成本利润率那个百分比是价格口径,课件正文不引用,台上也不说。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「goodput 和吞吐差在哪?」→ 吞吐不管延迟,goodput 只数首字和字间隔都达标的那部分。比如九成请求达标时一张卡最多扛多少。
🛠 GPU 老兵「vLLM bench 的 ITL 和 NIM 报的 ITL 是一回事吗?」→ 不是:NIM 那个是平均间隔,自己也说就是 TPOT;vLLM 给的是每一次间隔的列表,看 p99 只对后者有意义。
🛠 GPU 老兵「11,200 的分母是 decode 卡还是全部卡?」→ 官方没写明,本课按输出除以 decode 卡读;而且 11,200 开了 MTP,Day-0 那个没开。
💰 管预算的「一张卡能同时服务多少人?」→ 看档位:每用户 50 tok/s 那档,11,200 ÷ 50 约 224 人,课件 14.3 用它算 decode 卡数。
🛠 GPU 老兵「5.1 倍是厂商自己报的吧?」→ 是自报:出处是 PyTorch 博客那篇 SGLang 部署文,Day-0 基线同出一篇,本课没复测;口径倒干净:同卡同模型同档。

第三节 批处理与调度(31′)计划 31′ · 含互动 28.3′ · 跳后 27.8′

🖥 本节主屏:课件 第三节 批处理与调度 · 主图 fig-s3-gantt

🎯 这一节只留一句:逐步调度是「一趟分给更多人」的地基;槽位满了,吞吐就钉死,再加并发只加排队。

🖥 屏幕:滚到「3.1 每一步都重新排一次」,先停在节首那段引言,再往下到 fig-s3-gantt,指上半「静态 batch:凑满一批,等最慢的跑完」。

「第一节算过:decode 每走一步,都要把权重从显存搬一遍;同一趟坐的人越多,每人摊到的就越少。
所以这一节问的是:这一趟,能不能一直坐满?
最早的服务是一批人一起进、一起出。先答完的人座位空着,得等最慢的那个。」

「先看图上半。四个槽位,八个请求,每个请求一种颜色,字母写在它的第一格;每一列是一步 decode。
彩色实心格是这个人这一步出了一个字;虚线格是槽位空转,这一趟权重白搬。
第一批 A、B、C、D 一起上。看 C:第二步就写完了,可它要陪 B 跑到第八步才能一起返回。
第二批 E 到 H 要等到第八步之后才进得来。整串做完十五步,空转二十三格。」

🖥 屏幕:指下半「逐步调度(Orca):每一步都看一次,空出来就补人」,再指「12 步做完」「空转 11 格」。

「下半是同样四个槽位、同一串请求,只换排法:每一步都看一次,谁写完谁让位,排队的人下一步就补进来。
C 一写完,E 马上坐进它的位子。空格只在队列空了以后才出现。
同样三十七格活,下面十二步做完,空转十一格;上面十五步,空转二十三格。
⭐ 记住那句话:空着的每一格,照样搬一趟权重。」

🖥 屏幕:往下放 anim-contbatch,先闭嘴看完一圈(18 秒),最后一帧停住指两个计数器。

「动画里队列一直不空,十六个请求排着。同样十五步:上面静态批做完八个,空转二十三格;下面连续批做完十四个,一格不空。
图注说了,请求长度是编的,每步按一样长算,进门那一步的 prefill 没画进去,后面 3.2 那支动画补上。」

💬 互动:动画看完问「每一步重排一次,同样延迟下吞吐能是原来的几倍:两倍、十倍、三十倍?」举手投票,跟开场一样数人头。期望答案:三十多倍。

🖥 屏幕:停在「Orca 是 2022 年 OSDI 上的一篇论文」那段。

「三十六点九倍,在 GPT-3 上测的。
二〇二二年 OSDI 上的 Orca,改成每一步结束都看一次。论文里叫迭代级调度,业界后来通称连续批,continuous batching。
对照的是 FasterTransformer,英伟达早年的推理库,用的是静态批。下一节 vLLM 那个倍数,比的也是这两家。」

「⛔ 图上明明只差两成多,十五步对十二步,怎么到论文里成了三十多倍?
图是四个槽、长度编得差不多的玩具。论文比的是:两家都守同一条「每个字平均摊到多少延迟」的线,看每秒能服务几个请求。
所以三十多倍是「守同一条延迟线」时的倍数,换一条线,倍数就变。」

🖥 屏幕:指下面列表第一条「原来卡在哪」。

「原来为什么做不到?老引擎对外只有一个接口:整批跑完再还你。调度器看不见中间的步。
而且一批摞成一个方块,人数乘最长长度,短的补零,中途换不掉其中一行。」

🖥 屏幕:指第二条「Orca 第一招,只跑一步就交回」,再指第三条「第二招,选择性批处理」。

「Orca 两招。第一招:只跑一步就交回调度器。写完的马上返回、让座,排队的装得下就补进来。
第二招叫选择性批处理。矩阵乘、归一化这些,不管 token 属于谁,就把这一步所有人的 token 接成一长条,一起乘权重;只有注意力按人切开,各读各的 KV。
⭐ 这一条是后面所有拼批的地基:乘权重大家合伙,注意力各算各的。」

「Orca 是论文里做的一套系统,今天没人直接跑它,跑的是它的招:vLLM、SGLang 都按步调度。
可它的 KV 还按最长长度给每人预留一整段,座位白白占着,这个坑留给下一节的 PagedAttention。两样凑齐,才是今天引擎的底座。
代价是:新人进门那一步要做 prefill,这是 3.2 的事。」

🖥 屏幕:指第四条「挂不同 LoRA 的人也能拼」。

「顺着第二招再往前一步:每个人挂的 LoRA 不一样,也能拼进同一趟。
LoRA 是在大模型旁边挂一对小矩阵做定制。基座权重照样大家共享一趟,只把各人那对小矩阵另算。
二〇二三年的 S-LoRA 同时服务几千个适配器,吞吐最多是简单做法的四倍。」

🖥 屏幕:滚到「3.2 新人进门:chunked prefill,一步里装了什么」,fig-s3-chunk,先指上一行「不切:一步吞下」。

「新人带着一段长 prompt 进门。一口吞下,那一步就特别长,正在出字的人都卡一下。
图上的单位是示意:decode 一步算一格,这段长 prompt 的 prefill 算八格。
上一行不切:中间那一步八格加一格,老请求两个字之间最长隔了九格;新请求的首字在第九格出来。」

🖥 屏幕:指下一行「切成 4 块」,再指「最长字间隔 3 格」「新请求首字在第 12 格」。

「下一行切成四块,每块两格,每步只带一块,和 decode 拼着走。
老请求最长间隔从九格降到三格;代价是新人首字从第九格挪到第十二格,晚了三格。两行在十二格里都出了四个字。
图注说混合步按两者相加计时,这是偏保守的算法。」

🖥 屏幕:指图底「token 预算是一个旋钮,两头各拧一边」,再指最后一句「这只解决一半」。

「每步塞多少 prefill,是一个旋钮,vLLM 里叫 max num batched tokens。调小,字间隔稳;调大,首字快。
⛔ 它只解决一半:prefill 和 decode 还挤在同一批卡上抢算力。彻底分开,要靠 PD 分离,把两种活放到两批机器上,那是第八节。」

🖥 屏幕:停在图下正文「Sarathi(arXiv 2308.16369)」那段。

「这招叫 chunked prefill,出自 Sarathi 和后来的 Sarathi-Serve。Sarathi-Serve 报:延迟达标时,能接的请求是 vLLM 的两倍半到将近四倍。
二〇二四年 vLLM、SGLang 先后合入,vLLM V1 默认打开,decode 先上车。」

🖥 屏幕:停在「块多大,看每步的 token 预算。」

「块切多大?引擎定的不是块长,是每步的 token 预算。
decode 的人先占位,每人一个 token,剩下的额度才给 prefill。所以块长跟着车上的人数浮动:车上人多,块就短。
两家的默认都按显存分档,大约八千到一万六。」

🖥 屏幕:停在「后面的块要读前面全部的 KV,算得更慢。」

「切出来的块,后面的比前面的重。矩阵乘那部分每块一样;注意力那部分要和前面所有 token 配对,越往后越重。
拿 V3 粗算,本课推的:历史超过约一万五千个 token,注意力就反超矩阵乘。所以十二万八的 prompt 切成八千一块,最后一块大约是第一块的七倍重,带着它的那一步也随之变长。推导在课件那段里。」

🖥 屏幕:停在「切块不会多读 KV。」

「⛔ 有人担心:切成十六块,前面的 KV 不就被反复读了十六遍?
不会多读。FlashAttention 本来就把 query 切成一百多个 token 的小块,每个小块各扫一遍前面的 KV。
切不切块,扫的次数和内容都一样,只是分到了不同的步里。注意力的总运算量也不变。」

🖥 屏幕:停在「块不能太小,代价在权重。」

「那块能不能切得很小?代价在权重:每走一步,权重都要从显存读一遍。
本课推的:H100 按 bf16 算,一步至少约三百个 token 一起做矩阵乘,才喂得饱读进来的权重。
MoE 更苛刻:每个 token 只去少数几个专家,要每个专家都凑够三百,一步得有九千多个 token。默认预算落在八千到一万六,正好对得上。」

🖥 屏幕:滚到「一步里装了什么:新人怎么接上」,fig-s3-stepmix,先指图例「实心:decode,每人 1 格、出 1 个字」和「浅色:prompt 块,最后一块那步出首字」。

「把一步拆开看。这张图每一行是一趟前向,也就是一步。
每步预算十格,一格一个 token;真实部署是八千到一万六。同一个人同一种颜色。
实心格是 decode,每人一格、出一个字;浅色格是 prompt 块,只有最后一块那一步出首字。
规则就一条:每一行先排实心,剩下的才轮到浅色。」

🖥 屏幕:从「第 1 步」逐行指到「第 4 步」,每行指右边那句注。

「第一步:车上 A、B、C、D 各占一格,剩六格切给 E,E 这步不出字;D 出完最后一个字,下车。
第二步:车上三个人,剩七格,E 剩下的七个正好装完,这一步就出首字;F 排不上。
第三步:E 已经是实心格,坐上车了;F 的四个一块装完,也出首字,空着两格。
第四步:没人排队,全是 decode,空着五格照样跑。预算是上限,没人排队就不凑。」

🖥 屏幕:往下放 anim-stepmix,先闭嘴看完一圈(42 秒);第二圈在第 2 步停下,指 E 的「首字」。

「动画里每一步先从车上飞下实心格,再从门口飞下浅色格;整条一起乘权重,下面每人一段下划线,是各读各的 KV。
⛔ 有人以为 prefill 做完的人要在门口等着,并进 decode 的队。不用:最后一块算完那一步,前向末尾已经有下一个字的概率,首字当步采样;下一步它就是一格普通 decode,中间没有停靠站。」

「vLLM V1 就像动画里这样,一步里混着跑。SGLang 默认不混:一步要么跑一块 prefill,要么全员 decode,加 enable mixed chunk 这个开关才混。
不混也不用等:prefill 那一步照样出首字,下一个 decode 步就带上它。」

🖥 屏幕:停在「真要等,是 KV 池满了。」,再指下一条「只有 PD 分离才有交接。」

「真要等,只有两种情况。
一是 KV 池满了:格子有剩、KV 装不下,新人只能在门口排;连车上的人都装不下,就按 3.4 请人下车。
二是 PD 分离:prefill 机器出了首字,KV 要整段搬到 decode 机器,搬完才接着出字,第八节讲。
混部的时候 KV 本来就在同一个池里,不用搬。」

🖥 屏幕:停在「门口一步只进一两个,车上怎么坐满三百人?」

「那门口一步只进一两个,车上怎么坐满三百人?
一个人进门只占一步,坐下却要待几百上千步。设每人出一千个字,要车上一直有三百人,平均每三步多补进一个就够;八千的预算一步能塞两条四千的 prompt,门口绰绰有余。
⭐ 门口不是瓶颈,真卡座位的是 KV 池。」

💬 互动:问「同一步里,一边是两条 4K prefill,一边是三百人各出一个字、各带 4K 历史。乘权重两边一样贵;读 KV 谁多、多几倍?」期望答案:decode,约九倍;摊到每格约两百五十倍。

🖥 屏幕:停在「预算里一格算一格,搬的 KV 不一样。」

「乘权重是一格算一格,三百人接成一条长条共用一遍权重,decode 几乎是搭车。
注意力不一样:prefill 读进一块 KV,一组一百多个 query 一起用;decode 读进来只喂自己那一个字。
decode 那边读的 KV 是 prefill 的九倍;摊到每格差约两百五十倍。这是本课推的。
所以预算是调度旋钮,不是耗时模型。」

🖥 屏幕:停在「混着跑能凑够屋脊点,吐字还是看 decode 人数。」

「再接回第一节那条线。1.1 说一步要凑够约三百四十三行才过屋脊点,那数的是这一步乘权重的总行数,prefill 块的几千行也算。
所以混着跑,车上只有几十人,这一步也过线了。
⛔ 可过线不等于吐字多:prefill 那几千行不出字,每步出几个字还是车上几个人;decode 的注意力照样卡带宽。」

🖥 屏幕:停在「TPU 上同一套规则。」

「TPU 上是同一套规则。长短不一的 prefill 块和 decode 进同一个注意力 kernel,叫 RPA,5.1 讲。
多一层约束:这一步的格数也要落在预编译的档位上,差的补空,3.3 末尾说。」

🖥 屏幕:滚到「3.3 槽位满了以后」,只露标题,图先留在下面。

「门口不是瓶颈,座位才是。槽位,就是 KV 池装得下几个人。
那问一句:座位已经坐满了,再把负载拉到四倍半,每卡吞吐能涨多少?」

💬 互动:图出来之前问,举手猜「涨好几倍」还是「几乎不涨」。期望答案:几乎不涨,只多一成;涨的是门口排队。

🖥 屏幕:往下到 fig-s3-conc,先指标题下那行配置,再指上面那家餐厅。

「这是 GB300 上 SGLang 跑 DeepSeek-V4-Pro 的公开实测:decode 八张卡一组,八千进、一千出,吞吐按每张 decode 卡算。
上面画成一家坐满的餐厅:座位就是槽位,全坐满了,翻台速度不变。并发从六百到一千八,门口的队越排越长,队就是首字等待。」

🖥 屏幕:指左下绿柱「翻台速度:总负载 ×4.5,吞吐 +11%」,从左到右过五根柱。

「左下绿柱是每张 decode 卡的吞吐,五根柱几乎一样高:负载拉到四倍半,吞吐只多一成一,字间隔一直在六十毫秒上下。
并发是按每个前端算的,不是全集群总数。」

🖥 屏幕:指右下那排红柱,从「45 秒」到「253 秒」。

「右下红柱是首字等待的中位数,含排队:从四十五秒一路涨到四分多钟。
⭐ 座位数和翻台速度定了,吞吐就定了;多来的人都在门口排队。」

🖥 屏幕:停在图下「Little 定律(见词表)」那段,再指下一段「GB300 上 V4-Pro 的 dep8」。

「餐厅那句话有个公式版,排队论里的 Little 定律:批里的人数,约等于吞吐乘字间隔。
反过来,吞吐约等于槽位数乘一千,除以以毫秒计的字间隔。座位数是槽位,翻台速度是字间隔。」

🖥 屏幕:停在「Little 定律核一遍」,点开折叠。

「拿同一套部署的基线核一遍:每卡九千出头、字间隔六十毫秒,反推出 decode 批里每卡约五百四十人。
客户端开的路数里,真正进批的只有一半左右,其余在 prefill 那边排队,两头对得上。」

🖥 屏幕:停在「槽位也不白给」那段。

「槽位也不白给。同一组实测多给 KV 池一成三的显存,每卡多装了一成三的人,端到端吞吐只多千分之八。
⛔ 人多了,每一步就长了,吞吐几乎原地。」

🖥 屏幕:停在「TPU 上多一层:batch 大小要落在档位上」。

「TPU 上多一层。XLA 按静态形状编译,batch 大小也是形状。
所以提前编好几档,人数不在档上,就补到最近的一档,补的行照样计算。为什么是编译期定形状,专题二「运行时,还是编译期」讲过;档位怎么选,14.1 讲。」

🖥 屏幕:滚到「CPU 那几毫秒也要藏起来。」,fig-s3-overlap,先指上面「串行」那两条泳道的「空等」格。

「每步之前,CPU 要挑人、拼 batch、准备输入。串着走,加速器每步都要等它。
图上两条泳道,上面是 CPU,下面是 TPU。串行那一组:CPU 排第 N 批,TPU 算第 N 批,然后 TPU 空等 CPU 排下一批。
decode 一步越短,CPU 那几毫秒占得越多;批越大,CPU 要拼的东西也越多。」

🖥 屏幕:指下面「重叠」那一组,再指「空档 ≈ 12 ms」和「空档 ≈ 38 µs」。

「重叠那一组:TPU 算第 N 批的时候,CPU 已经在排第 N 加一批,还提前为不同 batch 大小编好了计算图。
SGLang-JAX 在 Qwen3-32B 上,prefill 和 decode 之间的空档从十二毫秒降到三十八微秒。时间线是示意,只有这两个数是原文的。」

「GPU 上是同一招:SGLang 的零开销调度把下一批的 CPU 准备和这一批的计算重叠;vLLM V1 把分词、回传这些 CPU 杂活挪到别的进程,这是它比 V0 快的原因之一。」

🖥 屏幕:滚到「3.4 显存不够时踢谁」。

「批开大了,KV 可能中途装不下:每个人都在长,KV 一步一步往上涨。这时只能先请出去几个。
回来有两种办法。一种叫 swap:把 KV 换到主机内存,回来时再搬回显存。另一种叫 recompute:KV 直接丢掉,回来重算一遍 prefill。
vLLM V1 默认重算,文档的说法是 V1 里重算的开销更低。」

🖥 屏幕:停在「这一节只要带走一件事」。

「这一节带走一句:逐步调度是「一趟分给更多人」的地基。槽位满了,吞吐就钉在槽位数乘一千、除以字间隔上,再加并发只加排队。
chunked prefill 只摊平打扰,拆到两批机器上是第八节的事。
回到地图,这是车上多坐人的第一招。」

🖥 屏幕:停在「显存只装得下 300 人时会怎样」那道考考自己,先别点开。

💬 互动:念题「字间隔稳定在五十毫秒,想让每张卡出一万 tok/s,批里至少坐多少人?显存只装得下三百人呢?」期望答案:五百人;只装三百人,吞吐钉在约六千。⏭ 时间紧可跳,答案在折叠里。

「一万乘零点零五,五百人。只装得下三百人,吞吐钉在三百乘一千除以五十,约六千。
出路两条:要么少搬,第十二节末尾的 FP8 KV 让每条 KV 减到约六成一,含索引键;要么换个交互档,字间隔放宽。」

「可座位有几个,是显存里的 KV 定的;Orca 又按最大长度给每人预留一整段,只用上两成到近四成。
所以接下来第四节,KV cache。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 三十多倍的基线是 FasterTransformer,台上必须带出来;别把它和 vLLM、Sarathi-Serve 的倍数连乘。
⚠️ chunked prefill 别讲成「解决了 prefill 打扰」:它只是摊平,彻底分开是第八节。
⚠️ 740 亿、500 万、1.5 万交叉点、末块 7 倍、H100 约 300 token、MoE 九千多都是本课推导,台上说「推出来的」。
⚠️ 9.5 GB / 86 GB / 约 250 倍是本课推导:V3 每 token 70,272 B,query 每块按一百多行;台上别说成实测。
⚠️ Little 定律那段反推(9,032 × 8 × 0.060 ≈ 4,335,每卡约 542)用的是课件折叠里的数;被追问「为什么只一半进批」,答课件原句:其余在 prefill 端排队。
⚠️ 图上并发按每个前端计,共 14 个前端;别把「并发 1,800」说成全集群总并发。
⚠️ R12 口径(口播取整,原数在此):Orca 守的线是每 token 中位延迟 190 ms,FasterTransformer 0.185 对 Orca 6.81 req/s,GPT-3 175B;Sarathi-Serve 2.6–3.7 倍;vLLM 2024-04 合入、SGLang 2024-07 跟进;默认预算 16,384(大显存)/8,192(中档);交叉点推导:线性 740 亿次/token(37B × 2),注意力每历史 token 约 500 万次 = 2 ×(192+128)× 128 头 × 61 层;H100 SXM 989 TFLOPS ÷ 3.35 TB/s ≈ 300;V3 256 选 8;读 KV 9.5 GB 对 86 GB;绿柱 8,777 → 9,745,字间隔 58–63 ms;红柱 45/150/253 s(「四分多钟」= 253 s);基线 9,032 tok/s、60 ms、8,400 路,9,032 × 8 × 0.06 ≈ 4,335,每卡约 542;槽位 886 → 999,字间隔 77.7 → 85.3 ms;SGLang 零开销调度 1.1 倍(2024 年底),vLLM V1 最多 1.7 倍于 V0(2025)。S-LoRA 的「简单做法」指 HF PEFT 和 vLLM 简单做法;Gemma4-31B 那组在备答。
❓ 台下可能问(备答,不计地板;数都在课件上)
🛠 GPU 老兵「CPU 提前一步排车,怎么知道上一步谁写完了?」→ 不等。先假设人人都接着写,上一步吐的字留在显卡上凭占位接力;谁写出结束符,等上一步结果回到 CPU 才认出来,下一轮排车才请下去,晚一步(3.3)。
🛠 GPU 老兵「V4 两个池能不能不手调?」→ 比例大致 = 每请求固定的滑窗槽数 ÷ 平均长度;十月的 SGLang 不传比例、给了请求上限时会按最坏情况自动留滑窗池,剩下全给全长池(4.2)。
🧑‍🎓 新人「continuous batching 和 chunked prefill 什么关系?」→ 前者决定每一步谁上车,后者把新人的长 prompt 切块混进 decode 的步里;先有前者,才有后者要解决的打扰。
🛠 GPU 老兵「Sarathi-Serve 报了多少?」→ 达标容量是 vLLM 的 2.6–3.7 倍,基线是 vLLM,别和 Orca 对 FasterTransformer 的倍数连乘。
💰 管预算的「并发开多少合适?」→ 用 Little 定律反推:每卡 10,000 tok/s、字间隔 50 ms,在飞约 500 人;只装得下 300 人,吞吐就钉在 6,000,再加只加排队。
🛠 GPU 老兵「vLLM 显存不够踢人,默认 swap 还是重算?」→ V1 默认重算:丢掉 KV、回来重跑 prefill;文档说 V1 里重算开销更低(3.4)。
🛠 GPU 老兵「SGLang 零开销调度省了多少?」→ 把下一批的 CPU 准备和这一批的计算重叠,吞吐 1.1 倍;TPU 上 SGLang-JAX 在 prefill 与 decode 之间的空档从 12 ms 降到 38 µs(3.3)。
🛠 GPU 老兵「chunked prefill 每块切多大?」→ vLLM V1 默认开,由 max_num_batched_tokens 控制;TPU 上 Gemma4-31B 的公开记录设 16,384,256K prompt 切 16 块(3.2)。
🛠 GPU 老兵「多 LoRA 怎么拼批?」→ 基座权重共享一趟,各人的小矩阵另算;S-LoRA(2023)几千个适配器,吞吐最多是 HF PEFT、vLLM 简单做法的 4 倍;vLLM 用 --enable-lora、--max-loras(3.1)。

第四节 KV cache:账、池、复用(31′)计划 31′ · 含互动 28.7′ · 跳后 27.2′

🖥 本节主屏:课件 第四节 KV cache:账、池、复用 · 主图 fig-s4-batch

🎯 这一节留两样:KV 一人一份,它定了一趟最多分给几个人;复用和卸载是少算、少搬。

🖥 屏幕:滚到「4.1 一个 token 留下多少字节,batch 就能坐多少人」,先停在节首那段引言。

「上一节留的坑:Orca 已经能每步换人,座位却卡在 KV 上。每条在跑的序列,都在显存里单独占一块 KV。
⭐ KV 池装得下几条序列,decode 每一趟搬运最多就分给几个人。从二〇二三年 vLLM 的 PagedAttention 起,几招都是在同样的显存里多装人、少重算。」

「先把 KV 压薄。同一个 device、同样四千的上下文,只换一种存 KV 的记法,能服务的人就差四倍多。
这张表四行,从上往下越来越省。线性注意力其实二〇二〇年就有了,排最后,是因为它省得最彻底。」

🖥 屏幕:指表头「每 token 字节」那一列,再从第一行「MHA(2017)」开始往下。

「第一行 MHA,二〇一七年:每个头各存一份 K、V。拿 V3 的形状假如用 MHA,每个 token 留下约四百万字节。
第二行 GQA,二〇二三年:几个头共用一组 K、V。Llama-3.1-70B 每 token 三十二万多,薄了一个数量级。」

「第三行 MLA,二〇二四年:只存一条压缩向量,所有头都从它解出 K、V。DeepSeek-V3 每 token 七万多,又薄了四倍多。
第四行线性注意力,二〇二〇年:不按 token 存,每条序列交一份大小固定的状态。Qwen3.5 只有四分之一的层还是全注意力,按 token 存的那份更薄。」

🖥 屏幕:指表下那行小字「按 bf16、所有层合计」。

「口径说一下:每个数都按 bf16 存、所有层加在一起算;改存 fp8 大约减半,MLA 存 fp8 的具体布局在十二点四。
字节数取自各模型自己的 config.json,是本课推的;Qwen3.5 的线性层状态按单精度浮点算,因为它的配置文件里,状态那一项的数据类型写的就是单精度。」

🖥 屏幕:停在「GQA 省下的不只是字节」那段。

「GQA 省下的不只是字节。原论文二〇二三年在 TPU v4 上,把 T5-XXL 改成八组:解码快了五倍多,这个比值是本课算的;平均分几乎没掉。
走到头,所有头共用一组,叫 MQA:再快一点,掉分多一些。」

🖥 屏幕:停在「DeepSeek 自家这条线后来又改了三代」那段。

「MLA 之后,DeepSeek 自家这条线又改了三代。
V3.2 的 DSA 存的一点没少,省的是读:先用小打分器扫一遍历史,只读挑中的。
V3.2-Exp 报告说架构上只改了这一处,基准和改之前基本持平。省了多少,报告只画了成本曲线,没给比值。」

🖥 屏幕:往下到 fig-s4-lineage,先指图例「黄框:这一代改的是这一排」,再指最左两列。

「这张图一代一列。上排是每个 token 存下多少 KV,下排是生成一个字时读回多少;方块只是示意,不按比例。黄框标的是这一代改了哪一排。
最左 V3,二〇二四年:每个 token 存一条;每个字读全部历史。
第二列 V3.2 实验版,二〇二五年九月:照 MLA 存,一条不少;黄框在下排,只读挑出的两千零四十八个。打分器仍然扫全部,但它头少、用 FP8。」

🖥 屏幕:指右边两列上排的黄框,再指下排「CSA 只挑一部分读,HCA 全读」。

「第三列 V4,二〇二六年四月,黄框回到上排,存也省了:沿 token 方向把相邻几个并成一条。CSA 四个并一个,HCA 一百二十八个并一个,另开滑窗池原样留最近一小段。
读这一排:压得轻的 CSA 层还照 V3.2 只挑一部分读,HCA 全读。
第四列 V4.1-Flash,二〇二六年九月:几层共用一份,主 KV 存 FP4,每 token 约是 V4-Flash 的四分之一;索引键也跨层共用。」

🖥 屏幕:滚到「batch 上限 = KV 池 ÷ 每条序列的 KV」,fig-s4-batch,先指顶上那条从「一个 device 可用的 94.75 GiB」到「KV 池:46.2 GiB」,172 和 21 等台下答完再指。

「字节有了,能装几个人?账要按 device 算:一颗 v7 芯片在软件里是两个 device,各管各的显存。V3 的 FP8 权重铺在十六个 device 上,每个分将近四十 GiB,再留一成给激活值,剩下约四十六 GiB 给 KV。这是本课推的。
每条序列的 KV 整条住一个 device,因为注意力走数据并行,第六节讲。所以池子除以每条的 KV,就是装几条。」

「⚠️ 这里权重按全切粗算。实际非专家权重每个 device 各存一份,池子更小,10.2 有细账。
按 V3 的 MLA 记法,四千的上下文装得下一百七十二条。上下文拉到三万二,是原来的八倍,还剩几条?」

💬 互动:让台下报。期望答案:二十多条,长到八倍,人降到八分之一。

「二十一条,只剩八分之一。纵轴是对数,横轴每格翻倍:纯注意力的线,往右一格人数就减半。」

🖥 屏幕:指「GQA · Llama-3.1-70B」那条线上的 36,再指红线「MHA:16K 起一条都装不下」。

「GQA 同样四千只装三十六条,就是开头说的四倍多。MHA 那条假想的线,一万六起一条都装不下。」

🖥 屏幕:指紫线「线性+全注意力 · Qwen3.5 形状」,从 157 到 11。

「紫线不一样。线性层每条序列先交一份固定状态,所以四千时反而比 MLA 略少装。
可它每 token 只涨那几层全注意力的份,往右少得慢,到十二万八还剩十一条,是 MLA 的两倍多。
所以标题说:上下文长到八倍,纯注意力只装得下八分之一,线性混合还剩四分之一以上。」

「⭐ 人少,一趟分到的 token 就少:这是长上下文贵的第一个原因。」

🖥 屏幕:滚到「4.2 PagedAttention 分页,混合模型分两个池」,往下放 anim-paged,先闭嘴看完一圈(18 秒)。

「这还是装满的理想账。早先按最大长度给每条序列预留一整段连续显存,没写到的位置也一直占着。
二〇二三年的 PagedAttention 学操作系统:把 KV 切成固定大小的块,写满一块才去空闲池领下一块,页表记着每块住在哪,请求结束就还。
动画里左边十六块显存,右边是页表。领到哪块算哪块,一个请求的块东一块西一块,页表记住先后。」

🖥 屏幕:第二圈停在请求 2 结束那一帧,指块 2 和块 5。

「盯住块二和块五:请求二一结束,这两块立刻还回空闲池;新请求四进来,马上就住了进去。
到第十二步,浪费只剩每个请求最后一块的空尾巴,那一刻一共八格。
vLLM 论文测得,旧系统 KV 显存只用上两成到近四成,分页后九成六。」

🖥 屏幕:指列表那条「按需领块」。

「同样延迟下,吞吐是 FasterTransformer 和 Orca 的二到四倍,二〇二三年 SOSP 的论文。
注意这里的 Orca 是作者自己复现的版本,Orca 本身就是 3.1 那篇。」

🖥 屏幕:往上到静图 fig-s4-paged,先指左边「逻辑上:每条序列以为自己是连续的」,再指右边「物理上:显存里零散的块」。

「静图上还有一招。两条采样共用同一个 prompt,「请写一首关于秋天的诗」。
左边是逻辑上:每条序列以为自己是连续的。右边是物理上:显存里零散的块。中间是两张页表。
A 的第零块指物理块一,第一块指块三;B 的前两块也指块一和块三。绿色这两块,两条共用,只存一份。」

🖥 屏幕:指橙色「块 7」和旁边「B 要往里写,先复制一份」。

「prompt 十个字,第二块只装了「的诗」两格,两条还共用着;后两格开始分叉:A 要写冒号、「落」,B 要写句号、「枫」。
B 要往共用的块里写,先复制一份,就是橙色的块七,再往自己那份里写。谁要改谁复制,这叫写时复制。
每块四个 token 只为画得下;真实系统 GPU 上常用十六,TPU 上 Qwen3.5 那次调优,一块从十六调到两百五十六个 token,第五节讲。」

🖥 屏幕:滚到「混合模型有两个池,预算要分」,fig-s4-pool,先指标题下那行说明。

「DeepSeek-V4 每层两种 KV。滑窗池只留最近一百二十八个 token,每条用量封顶;全长池存压缩后的整段,随输入变长一直涨。
SGLang 让两个池共用一份显存预算,用 swa full tokens ratio 这个参数定隔板:滑窗池除以全长池。
因为一个封顶、一个随输入涨,隔板得跟着输入长度挪。」

🖥 屏幕:先指左格「输入 4K · 全长池先满」,再指中格「输入 4K · 两个一起快满」和「+54%」。

「左格,输入四千:全长池满了,滑窗池还空着三成多。
中格,同样四千,隔板往滑窗池那边挪一点:两边一起快满,每卡吞吐高了五成多。
⭐ 一边先满,另一边就空转。」

🖥 屏幕:指右格「输入 8K · 滑窗池先满」;这一格输入长度不同,不跟前两格比吞吐。

「右格输入换成八千:这回反过来,滑窗池先满,全长池还空着两成多。
输入不同,吞吐不跟前两格比。这是 GB300 上的 SGLang 实测,关了前缀缓存。」

💬 互动:「输入更长了,全长池应该更吃紧才对,为什么反倒是滑窗池先满?」期望答案:隔板已经挪了,从零点二零挪到零点一零,挪得稍多。⏭ 时间紧可跳,直接讲下面那段。

🖥 屏幕:滚到「第三格为什么反过来是滑窗池先满」,指那一段。

「⛔ 先挡一个误会:第三格不是同一块隔板。输入翻到八千,每条在全长池里的用量跟着涨,滑窗池每条还是只留一百二十八个,所以人家把隔板往滑窗池那边挪,零点二零挪到零点一零,预算让给全长池。
这一挪挪得稍多,滑窗池先满,但两边已经接近平衡。同样八千放在零点一五,两个池都没满,滑窗池才用三成多。实测八千的甜点在零点一零到零点一二之间。
⭐ 所以隔板跟着输入长度走:输入越长,越要往滑窗池那边挪。」

「两边都满之后,再多给池子显存、多装一成多的人,吞吐几乎不动,就是 3.3 那组数:瓶颈从装不下,换成了算不动。
⛔ 池子算错,不一定报错。tpu-inference 跑 Qwen3.5 时,块编号池大了约三点五倍,越界的写入被静默钳回末尾,输出乱码,14.1 讲。」

🖥 屏幕:滚到「4.3 前缀复用:算过的不再算」。

「后半节把 KV 当存储用:少算、少搬。
很多请求开头一样:同一段 system prompt,多轮对话的前几轮。这段的 KV 算好了留着,下一个请求开头对上,就叫命中,直接接着往后算。」

🖥 屏幕:停在「RadixAttention」那条,再指下一条「默认就开。」

「二〇二三年 SGLang 的 RadixAttention,把前缀存成一棵基数树:开头相同的共用一段树枝,新请求沿着树匹配最长的前缀。论文报吞吐最多是当时其他系统的六点四倍,那是整套运行时的成绩。
vLLM 早先的前缀缓存,命中率低时反而拖慢,所以默认关。二〇二五年一月 V1 改了数据结构,命中率为零也只掉不到百分之一,才默认打开。」

🖥 屏幕:往下到 fig-s4-disk,先指上面「不命中」「命中」两根条,再指下面那条「56.3% 命中磁盘上的 KV」。

「命中率可以很高。DeepSeek 线上把算好的 KV 存在磁盘上。
上栏是一条很长、复用度高的 prompt:不命中,重算整段前缀,首字十三秒;命中,从磁盘读回 KV,含读盘半秒。
下栏是另一份统计:一天的输入 token 里,五成六命中磁盘上的 KV。两份统计不是同一时间的。」

🖥 屏幕:停在「命中按块算,不按 token。」

「命中不是一个字一个字比。vLLM 每写满一块,GPU 上默认十六个 token,算一次哈希,喂进去的是本块的 token 编号,加上 LoRA、图片这类标签。
没写满的尾块不参与,所以命中长度按十六对齐。SGLang 沿基数树比对 token 编号,粒度是一页。」

🖥 屏幕:停在「命中只认一字不差的前缀。」

「⛔ 命中只认一字不差的前缀。vLLM 每块的哈希连着前面所有块一起算,开头改一个 token,后面整段都对不上,而且不报错。
LMCache 论文报:业界常用的截断上下文,就是删掉早先几轮,开头就变了,能让前缀命中率掉一半。」

💬 互动:问「有人在 system prompt 第一行写上当前时间,精确到秒。前缀缓存会怎样?」期望答案:几乎全不命中,开头每秒都在变,后面整段都对不上。⏭ 时间紧可跳

🖥 屏幕:往下放 anim-kvstore,先闭嘴看完一圈(27 秒)。

「KV 当存储,就有层级。动画里三层:显存最小最快,三格;主机内存大一些慢一些,五格;SSD 最大最慢,七格。每层从左到右是最近用过到最久没用。
请求一要前缀 A,就在显存,直接用。请求二要 D,在主机内存,拉回显存,比重算快;显存满了,最久没用的 C 往下放。」

「请求三要 H,前两层都没有,在 SSD,拉回来也比重算快,就是刚才 DeepSeek 那个十三秒到半秒。
请求四要 L,哪层都没有,只能重算 prefill,橙色那条最长;算完的 L 进显存,A 往下放,主机内存也满了,G 再推到 SSD。
⭐ 先找、再搬、最后才算;显存满了,冷的 KV 一层层往下放。」

🖥 屏幕:停在「线性注意力和滑窗难复用」。

「有两种层难复用。线性层的状态截不回任意位置:它把整段历史揉成一个固定状态,没法切回第一千个 token 那一刻。
滑窗层早先的 KV 已经丢了。两种都只能隔一段存一份快照,第十三节讲。」

🖥 屏幕:滚到「4.4 分层卸载:搬回来,还是重算」,停在「盈亏带宽」那个框。

「显存留不下所有想复用的 KV,就往下放:主机内存、磁盘,乃至远端存储,用时搬回。可搬回来不一定比重算快。
像作业本丢了:重写一遍,还是找人借来抄?重写费算力,作业越长越费;借来抄要走路,本子越厚越慢。路快过某个速度就该借,这个速度叫盈亏带宽。」

「怎么算:每 token 要搬的 KV 字节,除以每 token 重算要花的时间。链路比它慢,就不如重算。
这只算了线性部分;注意力那项随长度平方涨,越长越该下放。负载高时重算还会挤占别人的算力,盈亏点再往慢链路那边移。」

🖥 屏幕:往下到 fig-s4-offload,先指图例四条线,再指「交点 ≈ 35K token」。

「横轴是命中的前缀有多长,纵轴是把这段 KV 准备好要多久,都是对数,每芯片口径、DeepSeek-V3。
红线是重算;绿线从每秒二十 GB 的地方搬回,始终在红线下面,多长都该搬。灰虚线是每秒二点一九 GB,盈亏线。
每秒一 GB 那条,短前缀不如重算,过了约三万五千个 token 反而划算。」

🖥 屏幕:指左下「短前缀:两条重合」,再指右边「注意力的平方项接管」。

「左边短前缀,几条线挤在一起;往右重算变陡,是注意力的平方项接管了:作业越长越难重写,慢路也值得借。
V3 的 KV 省,就是本子薄,路每秒两 GB 多就该借。
有效算力按 FP8 峰值的一半假设,两档带宽是示意值,整张图都是本课推的。」

🖥 屏幕:停在图下「GQA 的 Llama-3.1-70B」那句。

「换成 GQA 的那个七百亿参数的 Llama,本子厚得多,每次运算摊到的 KV 字节多得多,链路至少每秒五点三五 GB,搬回来才划算。
⭐ KV 越省,越容易往下放。」

🖥 屏幕:指列表第一条「llm-d」。

「几个已经在跑的。llm-d 二〇二六年在 TPU7x 上,把 Qwen3-32B 的 KV 卸到主机内存:平均首字从将近一秒降到半秒多,慢的那一成从两秒多降到半秒,总吞吐多近一成。」

🖥 屏幕:停在「Mooncake Store」那条。

「Mooncake Store:把集群各台机器的内存拼成一个 KV 池,按块哈希存取,冷数据可以再下放到 SSD。
字节走 RDMA 搬,就是网卡直接读写对方内存,不经过 CPU。
SGLang 的 HiCache、vLLM 都已经能接它当后端。」

🖥 屏幕:指「LMCache」和「SGLang HiCache」两条。

「LMCache 接在 vLLM、SGLang 下面分层存 KV,二〇二五年十月的论文报,多轮问答、文档分析下吞吐最多是单跑 vLLM 的十五倍;TPU 上的同类工具见 8.2。
SGLang HiCache 把分层做进引擎:一级显存、二级主机内存、三级外接存储,比如磁盘、远端内存。官方博客报吞吐最多六倍,首字最多降八成,但没写明跟什么比。vLLM 0.11 也自带 CPU 下放,两大引擎都有了。」

🖥 屏幕:停在「这一节只要带走两件事」。

「这一节两件事。一,KV 池定了 batch 上限:KV 一人一份,它定了一趟最多分给几个人。二,复用和卸载是少算、少搬,下放之前先算清搬回来是不是比重算快。
回到地图:记法越省是货变轻,分页腾出座位是车上多坐人。分页这一下,同样延迟,吞吐是 FasterTransformer 和 Orca 的二到四倍。」

🖥 屏幕:停在「V3 跑 64K 上下文能装几条」那道考考自己。

💬 互动:念题「一个 device 的池子四十六点二 GiB,V3 跑六万四的上下文能装几条?存成 fp8 呢?」期望答案:十条;fp8 约十八条。⏭ 时间紧可跳,答案在折叠里。

「每条七万零两百七十二乘六万五千五百三十六字节,约四点二九 GiB,装十条。
存 FP8 按 12.4 的布局,每 token 四万零十六字节,约装十八条;严格减半才是二十一条。」

「可装得下几百人、也坐满了,一步本身还是慢:每人自己的 KV,和 MoE 拆散后每个专家那几行,都没摊下去。
所以接下来第五节,注意力和 MoE,两块硬骨头。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 4.1 表里的字节数(3,997,696、327,680、70,272、30,720)台上用汉字读「约四百万」「三十二万多」「七万零两百七十二」,都是本课推导(取自 config.json)。
⚠️ 46.2 GiB、172 条、2.19 GB/s、35K、5.4 倍、1/26 都是本课推导,台上要说「推出来的」。
⚠️ 账按 device 算(一颗芯片=两个 device),被问「为什么不按芯片」答「两个 device 各管各的显存,序列的 KV 只住一个 device」;46.2 GiB 是按权重全切粗算的;被问「DP attention 下呢」,答「非专家权重每个 device 各要一份,池子更小,10.2 有细账」。
⚠️ fig-s4-pool 第三格输入 8K,和前两格输入 4K 不同,吞吐不横比。
⚠️ 磁盘缓存两组数来自不同时间的两份统计(API 文档 2024-08、open-infra-index 2025-02),别说成同一天。
⚠️ R12 口径(口播取整,原数在此):MHA 按 DeepSeek-V2 口径 K、V 各 128 维 × 128 头;GQA 8 组 × 128 维 × 80 层;MLA 512 + 64 维 × 61 层(不含 MTP)= 70,272 B;Qwen3.5 45 层线性 180 MiB/序列 + 15 层全注意力 30,720 B/token。GQA 论文 1.51 → 0.28(≈ 5.4 倍)、47.2 → 47.1,MQA 0.24、46.6。V3.2-Exp 对 V3.1-Terminus:MMLU-Pro 85.0 持平,HLE 21.7 → 19.8;成本曲线按租卡价。V4 滑窗池 128 个;V4.1-Flash 890 B/token。device 账:94.75 GiB,权重 39.1,激活 9.5,KV 46.2 GiB。容量曲线:MLA 172/21/5(4K/32K/128K),GQA 36/4/1,MHA 1K 12、4K 3、16K 起 0,Qwen3.5 157/41/11。分页前利用率 20.4–38.2%。隔板:0.20 时全长 93%/滑窗 63%、6,887 tok/s;0.15 时 92%/89%、10,614(+54%);8K 输入 0.10 时滑窗 96%/全长 78%、9,354;8K 放 0.15 滑窗 37%、410 条;单卡计、输出 1K。3.3 那组 886 → 999。磁盘:128K prompt,13 s 对 0.5 s(≈ 1/26,本课算),一天 6,080 亿输入 token,56.3% 命中。vLLM 哈希默认 sha256,128K 约 8,192 次(本课算)。llm-d:0.98 → 0.56 s,P90 2.1 → 0.5 s,+8.9%。HiCache 2025-09、vLLM 2026-05 接 Mooncake。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「KV cache 为什么非存不可?」→ 不存,每出一个字都要把整段历史重算一遍;存了,每步只算新来的那一个 token。
🛠 GPU 老兵「SGLang 的 RadixAttention 和 vLLM 的前缀缓存差在哪?」→ 都是算过的前缀不再算;RadixAttention(SGLang 2023 年)存成基数树、沿树匹配最长前缀;vLLM 早先命中率低时反拖慢,V1 改了数据结构才默认开(4.3)。6.4 倍是 SGLang 整套运行时对当时别家,不全是前缀树的功劳。
💰 管预算的「前缀缓存值不值得上?」→ 看命中率:DeepSeek 一天的线上统计,五成六的输入命中磁盘上的 KV;多轮对话、长 system prompt 越多越值。只认一字不差的前缀,开头改一个 token 后面全不命中,也不报错(4.3)。
💰 管预算的「KV 往下放要不要另买存储链路?」→ 看链路是否快过重算:本课推的盈亏带宽,V3 是每秒 2.19 GB,GQA 的 Llama-3.1-70B 要 5.35 GB/s。
🛠 GPU 老兵「Mooncake Store 是内存加 SSD 一个池吗?」→ 池是各机内存拼的,按块哈希存取,冷数据再下放 SSD;Master 只管元数据,字节由 Transfer Engine 走 RDMA 搬(第八节)。
🛠 GPU 老兵「LMCache 值不值得接?」→ 论文报多轮问答、文档分析下吞吐最多是单跑 vLLM 的 15 倍。主要在 GPU 上用,TPU 上的同类工具见 8.2。
🛠 GPU 老兵「vLLM 早就分页了,有什么新的?」→ 不新,4.2 引的就是 vLLM 论文。讲它是因为后面的 KV 账都按块算;TPU 上块大小还是第五节那个旋钮。
⚙️ TPU 工程师「Qwen3.5 在 tpu-inference 上能开前缀缓存吗?」→ 不能,得显式加 --no-enable-prefix-caching,否则断言错误:线性层的状态截不回任意位置(4.3)。
🛠 GPU 老兵「MQA 不是更省吗,为什么都用 GQA?」→ GQA 原论文:MQA 解码 0.24、平均分 46.6;GQA-8 是 0.28、47.1;MHA 1.51、47.2。快一点,掉分多(4.1)。

第五节 两块硬骨头(22′)计划 22′ · 含互动 22.4′ · 跳后 21.9′

🖥 本节主屏:课件 第五节 两块硬骨头 · 主图 fig-s5-amortize

🎯 这一节留一句:攒人只摊得薄共用的权重;每人自己那份 KV、MoE 拆散后的那几行,要靠布局和算法把没人要的字节去掉。

🖥 屏幕:滚到「单卡里的两块硬骨头:decode 注意力与 MoE」,停在开头那段。

「座位坐满了,权重一趟已经分给几百人,可每一步本身还是慢。
一张卡上的 decode 有两块最难啃:一块是注意力,读的是每个人自己的 KV;一块是 MoE,每个专家只分到几行。
⭐ 两块说穿了都是搬运问题。最后再补一条小 AllReduce,它卡的不是字节,是延迟。」

🖥 屏幕:滚到「5.1 注意力 kernel:攒 batch 救不了,只能把搬运做顺」,先别往下滚。

「先啃第一块:每人自己的 KV。猜一道。」

💬 互动:图出来之前问「batch 从 1 攒到 128,注意力每读一个字节做的运算,会是原来的几倍?」举手猜「多很多」还是「不变」,不点人答。期望答案:不变。多数人会猜「多很多」,正好拿来讲共用的货和自己的行李。⏭ 时间紧可跳:题当设问念一遍,不举手,直接接下一块「不变」。

🖥 屏幕:fig-s5-amortize,先指每根柱底下的蓝色权重段,再指上面的紫色 KV 段,最后沿柱顶那排「每 token」的数从左指到右。

「不变。权重是大家共用的货,拉一趟,坐几个人都能用;KV 是每人自己的行李,多一个人就多一份。
所以攒 batch 摊薄的只有权重。长上下文除了占座位,还让每人每步要读的行李更长,各读各的,摊不薄。」

「看柱顶,摊到每个 token 头上要读的字节:batch 从一攒到十六,降了十二倍;再从十六攒到一百二十八,只降到三分之一。
⭐ 越降越慢。蓝色那段一趟分给所有人,越摊越薄;紫色那段人翻倍它也翻倍,batch 一百二十八时已经三百四十多 GB,比权重还重。」

「说到这儿点个名:几个查询头共用一个 KV 头,这个「几」叫 G,这种做法就是 GQA。
注意力每读一个字节只做 G 次运算,推导在专题三。Llama-3.1-70B 是六十四个查询头配八个 KV 头,G 等于八;v7 的屋脊点是三百一十三,是它的近四十倍。
⛔ 所以别说「batch 够大,注意力也会变成算力受限」。权重会,KV 不会。后面 DEP、DCP 全立在这一条上。」

「本课按它的 config 推过一笔:上下文 8K 时,batch 五十出头,行李就和共用的货一样重,就是图右边那个约五十三。全模型合计,没按卡切。」

「还有一层浪费不在字节上。batch 小、序列又长的时候,注意力的活只按 batch 和头分给计算单元,份数太少,单元大半闲着。
二〇二三年十月,斯坦福 CRFM 的博客提出 Flash-Decoding:把每条序列的 KV 切成几段同时读,最后合并,怎么合第七节有图。博客报单请求、序列很长时最多是旧实现的八倍。
⛔ 它治的是活分不开;每读一字节做 G 次运算这个比值,切几段都不变。」

🖥 屏幕:滚到「一个 kernel 装下 prefill 和 decode」,fig-s5-rpa,先指左边三根箭头,从左往右,各落到一份版本。

「摊不掉,就只能读得更省。先说前提:chunked prefill 让一步里混着 prefill 和 decode。
kernel 是芯片上的一个计算函数。RPA,全名 Ragged Paged Attention,二〇二五年进了 vLLM 的 TPU 后端,把 prefill 和 decode 放进同一个注意力 kernel。
看左边:一批先按成分切三段,纯 decode、定长分块的 prefill、长度不定的混合段,各派一份预编译版本,每份带着自己的块大小。」

「效果:RPA 在 TPU7x 上跑 Llama 3 8B,decode 最多用到峰值带宽的百分之八十六,prefill 最多用到峰值算力的百分之七十三。三招拆解在专题三。
GPU 上做同一件事的是 FlashInfer,MLSys 二〇二五,已经是 SGLang、vLLM 的注意力后端之一。」

🖥 屏幕:同一张图,指右边两根条,先「页 16 个 token」,再「页 256 个 token」,最后指底下那行小字。

「右边是另一个便宜的旋钮:KV 页大小。Qwen3.5 在 TPU7x 上,页从十六个 token 调到两百五十六个,这个注意力 kernel 的 decode 一步少了三分之一。
为什么?页太小,查索引让向量单元频频停顿。
⛔ 看底下那行小字:这是这个 kernel 的 decode 一步,不是整步。」

🖥 屏幕:滚到「KV 一页页怎么搬上芯片」,停在图上面那段。

「先说注意力为什么特殊。MLP 和专家那边,一批里的 token 不分是谁的,都是矩阵的一行,权重搬一次全员算完。
注意力不行:每条序列的 KV 是它自己的私货,并发五百一十二就是五百一十二份,谁也替不了谁。
⭐ 所以注意力 kernel 能做的只剩一件:每个字节只搬一次,搬的时候别让计算单元等。」

🖥 屏幕:fig-s5-kvload,先指左边页池的十六个格子,再指下面三张页表。

「看左边,显存里的 KV 页池。A、B、C 三条序列,同一条一个颜色,页散在十六个格子里,不连号,中间还夹着空格。
怎么找?靠下面的页表。A 的页表写着:格七、格二、格十二、格五,按这个顺序取,就是 A 的第一到第四页。」

🖥 屏幕:同一张图,指中间两个槽,再指右边四个查询头。

「中间是片上的两个槽。槽一正在算 A 的第一块,八个 token;槽二同时在搬 A 的第二块。两页散页取来,在片上挨着放,拼成连续的一块。
再看右边:这一块 K、V 片上只放一份,四个查询头摞成四行,一起乘这一块。搬一次,用四次。」

🖥 屏幕:同一张图,指底下时间轴,停在「A 还没算完,B 块 1 已经在路上」。

「底下时间轴,上一行搬,下一行算。⭐ 搬总比算早一格。
看箭头那一格:A 还没算完,B 的第一块已经在路上,序列交界处也不停。
再看 B 的第二块只有两个 token、C 只有三个,就只搬两个、三个。」

🖥 屏幕:往下放 anim-kvload,让它转一圈(30 秒)。

「动画换个比方:工位旁只有两个台面,一个在拆,一个已经在装下一箱,换人也不停。规矩就一句:每个字节只搬一次,别让工位等。」

🖥 屏幕:滚到「RPA 的做法」,沿五个加粗段首往下指。

「论文把这套做法写成五件事,前四件刚才都看见了:按页表取,只搬有效长度,边算边搬,一块喂一组头。
补两句图里看不出的。为什么非要两个槽?TPU 只有一条指令流,不像 GPU 能靠大量线程轮换来掩盖等待,并行全靠异步 DMA,所以得自己排好「这块算、下块搬」。
第五件图里没画:本步新算的 K、V 拼进同一块参与计算,同时异步写回页池,不另起一趟。」

「算一笔,本课推的:并发五百一十二,每条两千到八千个 token,平均五千的话,decode 一步每层要把约两百五十六万个 token 的 KV 过一遍。
这个量躲不掉,能抠的是每趟搬运的效率。两个办法:页调大,查页表的次数少了,就是刚才那三分之一;K 和 V 并进一趟搬,下面马上讲。」

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

🖥 屏幕:往下指「稀疏注意力的 prefill:挑出来的,反而按稠密算。」,回指 4.1 那句「每字只读 2048」。

「这句话有个反直觉的推论,落在稀疏注意力上。DSA 每个查询只挑两千零四十八个位置,第四节讲过,decode 一次一行,照着挑的去取,正合适。
prefill 一次几千行,各挑各的,挑中的大半重叠。照旧一行一行去取,同一行会被搬上千遍。
⭐ 一篇公开工程博客在 TPU v7 上量过:为了取不到两千个不同的行,搬出来四百多万行,稀疏那条路的时间几乎全耗在取数上。」

「改法是干脆不取。先在 SparseCore 上画一张位图,标出每行挑中了谁;然后整块按稠密算,没挑中的盖掉,结果跟稀疏一样。
⭐⭐ 挑出来的反而按稠密算,因为 prefill 吃的是算力,矩阵单元最擅长整块算。四 K 输入的首字时延,一千三百多毫秒降到七百多。
当然 KV 太长时整块算不划算,所以在设备上按成本模型选路。」

🖥 屏幕:指「位图还能跨层共用。」

「还能再省一步:挑位置不必每层都挑。这个模型七十八层,只有二十一层真的算 top-k,其余层沿用前面挑好的。
位图跟着一起借用,高并发时又多挣一点吞吐。」

🖥 屏幕:滚到「布局:窄维被补成整块」,fig-s5-tile,先指顶上那只 4 KiB 的标准箱和那双袜子。

「行李还有一层浪费,在装箱上。TPU 的显存按 tile 存,图里叫标准箱:一箱四 KiB,横一百二十八格、竖十六行,装不满也算一整箱。
最内层,就是内存里连续排的那一维,和次内层都要补齐。要装的只有一个 token、一层的 K 加 V:两个头、一百二十八维、bf16,共一 KiB。像一双袜子。」

🖥 屏幕:同一张图,指 A。

「A:头数落在横的一百二十八格那一维,每行一百二十八格只用两格。要十六箱、六十四 KiB,是真数据的六十四倍。」

🖥 屏幕:同一张图,指 B,再指 B 旁边「换成 FP8」那行。

「B:头数落在竖着凑行那一维,每箱十六行只用两行,K、V 各一箱,八 KiB,八倍。
换成 FP8 呢?fp8 的次内层要补到三十二行,还是两箱、八 KiB,一个字节都没省。
⛔ 量化压不掉空位。」

🖥 屏幕:同一张图,停在 C。

「C:RPA 加一个打包维,把 K 和 V 沿头维并起来,逼编译器选最小的 tile。小箱是标准箱的八分之一,两只正好装满,一 KiB,一点不浪费。
口径:这张是按默认 tile 推的。XLA 对极窄的数组有时会自己改用小 tile,选哪种由它决定。」

🖥 屏幕:滚到「5.2 V3 专用:MLA 一个阶段一套算法,MoE 全算比排序便宜」,fig-s5-mla,先指上栏「吸收」。

「第二块骨头之前,先补一个 V3 专用的。专题三推过吸收:把投影并进查询,所有头直接对同一条压缩后的潜向量算,K、V 不展开。那是 decode 用的,prefill 呢?
看上栏:缓存里一个 token 只存一条五百七十六维的短向量,一百二十八个头一起读这一条,读一次。本课按 config 推,每读一个字节做两百四十二次运算。decode 缺带宽,就用它。」

🖥 屏幕:同一张图,指下栏「展开」,再指右边那个大大的 1。

「下栏:先复制、还原成一百二十八份,每份 K 加 V 三百二十维,每个头读自己那份,每字节只做一次运算。
prefill 为什么反而用它?prefill 缺的是算力,要的是少算。每个头对每个历史 token,吸收要做的乘加是展开的三点四倍。展开多读的字节,prefill 有富余带宽兜着。
这两个比值是本课按 config 推的。引擎里两套都留着,按阶段挑。」

🖥 屏幕:滚到「decode 的 MoE:全算比排序便宜」。

「第二块骨头:MoE 拆散后的那几行。第一节算过,decode 时每个专家平均只分到几行。」

💬 互动:问「每个专家只分到 8 行。按专家排序、把行搬过去算,和让所有 token 都过一遍、没选中的乘 0,哪个便宜?」举手二选一。期望答案:全算便宜,它藏在读权重的时间里。

🖥 屏幕:fig-s5-dense,先指 BF16 那组「读权重」那根,再指「全算」那根,最后指「只算 8 个」那根。

「图上是 V3 的一个路由专家,TPU v7 单 device。一批两百五十六个 token,平均每个专家只分到八个。
BF16 那组:读一遍权重二十四微秒,全算一遍反倒更短,不到二十;只算那八个几乎看不见。FP8 那组都减一半。
⭐ 两种精度,全算都比读权重短。」

「为八行去排序、搬过去、再搬回来,搬的比算的还贵。车反正要把这个专家的权重拉来:均匀路由时,两百五十六个 token 里,每个专家至少被一个人选中的概率超过百分之九十九点九。这段时间全算一遍还富余。
本课推的口径:全算除以读权重,两种精度都是两百五十六除以三百一十三。batch 不到三百一十三,全算都藏在读权重的时间里。」

「两个前提要说清。
一,FP8 那组假设激活值也是 FP8;只有权重是 FP8、激活值还是 BF16,读权重减了半、全算没减,就不划算了。
二,看图右下:零乘 NaN 还是 NaN。没选中的 token 要是算出 NaN 或 inf,乘零盖不住,得用选择清掉。」

「搬行本身也能这么换。tpu-inference 二〇二六年五月合入一项改动:batch 小的时候,把排序和还原换成 one-hot 矩阵乘隐状态,一次规整的矩阵乘,代替按下标取行。
Qwen3.5 并发六十四实测,总吞吐涨了百分之七到十五,看输入输出谁长。合入后默认关,要手动开。」

🖥 屏幕:滚到「5.3 小 AllReduce 是延迟问题」,fig-s5-allreduce,先指最上面那根灰条「24 ns」。

「最后一块,卡的不是字节,是延迟。AllReduce 就是把各卡的部分和加起来,再发回每张卡。
batch 一的时候,V3 每层一次只有一万四千多字节,十四 KiB。本课按带宽推,四张 GB200 做环形求和,带宽项二十四纳秒,就是最上面那根灰条。」

🖥 屏幕:同一张图,从「硬件下限(论文推算)」往下指到最长那根「NCCL 环形(论文实测)」。

「再往下三根是论文的。硬件下限推算一点四微秒,NCCL 环形实测十一微秒,是带宽项的四百多倍。注意横轴是对数,一格十倍。
⭐ 就算做到硬件下限,带宽项也只是零头。时间几乎全花在启动和互相等待上,加带宽没用,要省的是同步的次数。」

「这条账留到下一节:小 batch 下 TP 切得越细,每层同步越多,加带宽也救不回来。
TPU 这边:ICI 上同口径的小消息延迟,课件没找到公开数据。」

🖥 屏幕:停在本节末尾「从 2022 年的 FlashAttention」那一段。

「回到第零节那张地图,这一节归在货变轻那根杠杆下:让每一趟少搬。从 FlashAttention 到 RPA,单卡 kernel 一直在做一件事:补齐的空位、展开的 K/V、搬来搬去的行,都是没人要的字节,先去掉再谈量化和加卡。
可一张卡上每个专家只分到几行,batch 攒得再大也喂不饱。KV 只有一个头的模型切到四张卡上,那份行李会不会被复制四遍?第六节算这笔账。」

⚠️ 这一节最容易跑偏的地方 ⛔ 别把 KV 也算进「攒 batch 能摊薄」:立足点就是行李跟人走。说成「batch 够大注意力也会算力受限」,后面 DEP、DCP 全立不住。
⚠️ 「batch 五十出头两块一样重」是本课按 config 推的,台上要说「推过」;全模型合计、没算激活值。
⚠️ 「decode 一步少了三分之一」是 RPA 这个 kernel 的(428 → 283 µs),原文说是 kernel 级,不是整步。
⚠️ 全算专家那招有前提:两边都按峰值算,且 FP8 那组要求激活值也是 FP8;只有权重 FP8 时不划算(图下有),别说成「永远更快」。
⚠️ tile 那张图按默认 tile 推:XLA 对次内层只有 1–2 的数组有时改用 2×128 小 tile,图下出处里写了,别说成「一定浪费 64 倍」。
⚠️ Flash-Decoding 那个「8 倍」是博客比旧实现、CodeLlama-34B 单请求长序列,别当成通用加速比。
⚠️ R12 口径(口播取整,原数在此):柱顶每 token 字节 140+ GB/11.5/4.89/3.79(batch 1/16/64/128),「降了十二倍」= 140 ÷ 11.5,「只降到三分之一」= 3.79 ÷ 11.5,本课算;batch 128 时 KV 段 340+ GB。约 53 的推导:Llama-3.1-70B 每 token KV 327,680 B,8K 每条 2.68 GB,权重 141 GB,没算激活值和 logits。页大小:Qwen3.5-397B、并发 512、428 → 283 µs(RPA kernel 的 decode 一步)。DSA prefill:稀疏路九成多时间在取数;位图跨层共用 +5.6%。MLA:吸收 1,088 次乘加对展开 320。全算专家:23.9/19.5/0.61 µs,只权重 FP8 时全算 19.5 对读权重 11.95。one-hot:1K 进 8K 出 +14.5%,8K 进 1K 出 +7.3%,环境变量开。AllReduce:硬件下限 1.404 µs、低延迟实现 2.37、NCCL 11 µs(≈ 460 倍带宽项 24 ns)。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「KV 头、GQA 是什么?」→ 查询头负责发问,KV 头存着被查的历史;几个查询头共用一个 KV 头就是 GQA,Llama-3.1-70B 是 64 个配 8 个。
🛠 GPU 老兵「GPU 上有 Flash-Decoding,不是解决了吗?」→ Flash-Decoding 把一条长序列切开并行读,解决的是 batch 小、序列长时计算单元分不到活;每读一字节只做 G 次运算这个比值,它改不了。博客报的最多 8 倍,比的是旧实现,CodeLlama-34B 单请求长序列(5.1)。
🛠 GPU 老兵「GPU 上对应 RPA 的是什么?」→ FlashInfer(MLSys 2025):GPU 上同样把 prefill、decode 放进一套注意力 kernel,已经是 SGLang、vLLM 的注意力后端之一(5.1)。
🛠 GPU 老兵「全算专家在 GPU 上也划算吗?」→ 课件只按 TPU v7 峰值算了一笔,前提是激活值也是 FP8;没有同口径实测,不下结论。
💰 管预算的「这一节先做哪一招?」→ 最便宜的是 KV 页大小这个旋钮:从 16 调到 256,RPA 这个 kernel 的 decode 一步少三分之一,不用换卡。
⚙️ TPU 工程师「KV 头只有 1–2 个,布局上亏在哪?」→ tile 最内维补到 128、次内维 bf16 补到 16 行(fp8 32 行),头维落上去就补成整块;RPA 加打包维、K 和 V 沿头维并起来;量化压不掉空位(5.1)。
⚙️ TPU 工程师「RPA 的新 KV 写回会不会多一趟?」→ 本步新算的 K、V 拼进同一块参与计算,同时异步写回页池(论文 §3.3),不另起一趟。

第六节 TEP 还是 DEP(33′)计划 33′ · 含互动 31.2′ · 跳后 30.2′

🖥 本节主屏:课件 第六节 TEP 还是 DEP · 主图 fig-s6-dep-kv

🎯 这一节留一句:KV 头比 TP 路数少,TP 就只会复制 KV,每一步也多读几遍;DEP 各读各的,一步变短。专家铺出一台机器就是大 EP:每卡只放、只读自己那几个专家,代价是网络、大批和爆炸半径。

🖥 屏幕:滚到「切专家与注意力:TEP 和 DEP」,停在开头那段。

「每个专家只分到几行,那就铺到更多卡上凑,何况 V3 一张卡本来就装不下。
专家这头不用吵,按专家分卡,叫 EP。吵的是注意力:几张卡合算同一批请求,还是每张卡各算各的一批。
⭐ 选哪个,看两样:模型有几个 KV 头,要多大 batch。」

🖥 屏幕:滚到「6.1 TEP 还是 DEP:注意力怎么切」,fig-s6-fold-t5,先指上排注意力层的两组卡,再指下排专家层。

「专题五讲过:同一批卡,进注意力和进专家,可以用两套切法。
上排注意力层:四张卡一组切一份注意力,两组各管一批请求。下排专家层:八张卡各放三十二个专家,所有请求的 token 都往这儿送。同一张卡,一层里换两次身份。
为什么能各切各的?注意力是一块大矩阵,切成条合起来算;专家本来就是两百五十六个小块,整个分出去就行。训练里 Megatron 管这叫 Parallel Folding。」

🖥 屏幕:fig-s6-tep-dep-t5,先指上半张 TEP4 那四行,停在「KV 笔记」那一列。

「推理里给注意力那一半起了名字。看上半张,TEP:注意力用 TP,专家用 EP。四张卡一起算同一批,每张拿四分之一的头,出口用 AllReduce 把四份部分结果加起来。
好处是单个请求四张卡一起算,更快。坑在 KV 笔记那一列:图按 MLA 这种只有一个 KV 头的模型画,每张卡都是全部 KV,整份,白存三份。KV 头够多的模型,这一列是能跟着头切开的。」

🖥 屏幕:同一张图,指下半张 DEP4,再指「专家那一步」那一格。

「下半张,DEP:注意力用数据并行,专家用 EP。每张卡有全部的头,只管自己那批,KV 只存自己的,注意力这一步不用通信。
代价挪到专家那一步:token 用 AllToAll 派到专家所在的卡,算完再合并回来。还要防各卡忙闲不均,没请求的卡也得陪跑。
⭐ 差别全在注意力那一半:一起算同一批,还是各算各的一批。」

💬 互动:下一张图出来之前问「一个模型每层只有 1 个 KV 头,TP 开 4 路、按头切,每张卡分到几个头?」让台下自己发现切不开。期望答案:分不开,1 个头没法劈成 4 份,每张卡只能各放一整份。有人答「四分之一个」,就顺着问「四分之一个头怎么算注意力」。⏭ 时间紧可跳:不问,直接念下一块「切不开」。

🖥 屏幕:滚到「判据:KV 头数和 batch」,fig-s6-dep-kv,先指上半张 TP4 四条一样长的条,其中 3 条是红的;再指 DEP8 的 8 根短条。

「切不开,每张卡只好各放一整份。⭐ TP 开几路,同一个人的行李就复制几份,每一步也就读几遍。DEP 各存各的、各读各的。
DeepSeek-V4-Pro 不是 MLA,但每层同样只存一条所有头共享的 KV,正好是这道题。」

「图的上半张是容量轴,示意:KV 池装满时,TP4 四张卡只放一批,另外三份是副本;DEP8 八张卡放八批。每卡能放的请求,上限是原来的四倍,TP 度数四除以 KV 头数一。
⭐ 这是天花板:只有同时在跑的请求多到把池子坐满,多出的座位才换得来吞吐。
光是上下文长没用:单个请求的 KV,TP4 每卡一整份,DEP 也是一卡一整份,单请求能放多长两边一样;座位得靠并发来填。」

「这四倍到底吃不吃得到?讲我们自己测的一套部署和消融。
我们在 16 台 GB300 上用 SGLang 跑 V4-Pro,目标是官方报的每张 decode 卡一万一千二。我们两头都用 DEP:14 台做 prefill,每台四张卡跑 dep4;剩下两台拼成一组 decode,八张卡跑 dep8,TP 一、注意力数据并行八、EP 八。」

🖥 屏幕:往下指图里的 SGLang 表,先指拓扑条,再停在第一行 727。

「头一次跑通,每张 decode 卡端到端只有六千八百八十七。往下查,每卡同时在跑的只有七百二十七个请求。
病根在 3.3 讲过的那两个池子:全文一个池、滑窗一个池,按一个比例分显存。分歪了,全文池用到九成三,滑窗池才六成三,新请求进不来,座位空着。」

💬 互动:下一行出来之前问「把两个池调平,每卡从七百二十七坐到八百八十六,多两成。吞吐涨多少?」举手猜:两成以内,还是更多。期望答案:更多,涨 54%,到一万零六百一十四。十四台 prefill 一直在喂,座位一空出来就有人坐。⛔ 别顺口说成算力利用率涨了五成:decode 自报峰值只从一万一千八百五十一到一万二千零六十三。

「我们接着加:再给 KV 池多一点显存,坐到九百九十九。吞吐呢?几乎没动:人一多,每一步跟着拖长,多坐的人被抵掉了。
⭐ 所以容量这条轴的规矩:座位要有人坐、每一步别跟着拖长,才换得来吞吐。我们最后停在官方目标的九成五。」

「另一条轴,一步快不快,这套部署没拿 TP 比过。旁证只有一组 vLLM 的记录:decode 从 TP4 换 dep8,出字间隔缩到原来的四分之一左右。每卡吞吐按全部卡算两倍出头,可那次 decode 卡也从四张换成八张,只算 decode 卡就只有一点三倍。报倍数,先说分母。」

🖥 屏幕:滚到「换模型」那一行。

「换个模型呢?MLA 开 TEP 八路,KV 存八份;Qwen3.5-397B 的全注意力层三十二个查询头共用两个 KV 头,存四份;八个 KV 头的 GQA 模型开 TEP 八路,每卡正好一个头,DEP 在 KV 上就占不到便宜。
⭐ 判据一句话:TP 路数除以 KV 头数,大于一,就在复制、也在重读。」

🖥 屏幕:滚到「DEP 的代价:每个 rank 都得自己备一份」,fig-s6-dep-state,先指左边两排共八个红框(格子全满),再指右边每卡亮着的那两列。

「DEP 也有代价:每个 rank 像一家分店,是台小推理机,注意力权重、调度器、请求状态都得自备一份。凡是按请求开、又不跟着数据并行切开的东西,分店开几家,就复制几份。
Kimi K3 就栽在这:九十三层里六十九层是 KDA 线性注意力,每个请求一块固定状态。左边 DEP8,每个 rank 都得装一整池全部头的状态,两次加载都爆显存。」

「右边换 TP8,状态池按头切给八张卡,每卡只亮自己那几列,八张拼起来才是一整池。
这一维只有 TP 切,数据并行、EP、DCP 都不动它。「只有 TP 切头」是本课推的,和官方说法一致;格子数是示意。官方后来改推 TP 和 DCP,第七节讲。
另一笔代价是忙闲不均:专家那步等最慢的 rank,闲的 rank 也得陪跑空前向。热门专家多备几份,是 6.6 的 EPLB。」

🖥 屏幕:滚到「DEP 吃得快了,就得有人喂」。

「DEP 吃得快了,就得有人喂。我们后来想再进一步,把 decode 从两台宽到四台,dep16。
一步确实快了将近一倍,总输出也多了不到两成。可十六台机器,decode 占四台,prefill 只剩十二台:首字又慢了九秒,每张 decode 卡的输出掉了四成多。
反过来,dep8 配十四台 prefill 才刚好喂饱,再加到十六台只涨百分之二。
⭐ 拓扑一换,瓶颈换边。别人调好的 prefill、decode 配比,换了拓扑就得重扫,第九节细讲。」

🖥 屏幕:滚到「6.2 TPU 上也一样,先读懂参数名」,fig-s6-dep-tpu,先指两条线在 256 到 512 之间那个交叉,再沿上面那条线指到最右端「+62%」。

「TPU 上也一样。tpu-inference 有个公开 PR,二〇二六年五月合入,给带线性注意力的混合模型接上了 DP 注意力。Qwen3.5-397B,v7x-8,四颗芯片、八个 device,比 DP 等于八和 TP 等于八,专家都走 EP,只换注意力的切法。
看 decode 为主那条,一 K 进八 K 出:并发越高赢得越多,到五百一十二那档多出六成。」

「为什么?PR 没归因,课件列了两种可能。一,Qwen3.5 全注意力层两个 KV 头,八路 TP 复制四份,这是本课解读。二,TP 基线撞了参数上限:TP 从并发两百五十六到五百一十二只涨百分之三,PR 又没给 TP 的完整命令。两条都排除不了。
低并发呢?并发六十四时 decode 为主那条打平,KV 放得下,复制无妨;prefill 为主那条已经领先,长 prompt 更早挤满显存。」

「正确性也查了:mmlu_pro 上两边差一个多点。可 PR 只抽了五十道题,原话是在一个标准差以内,算冒烟测试,不算严格对齐。图底下还有一句:PR 同时改了调度,prefill 攒在一起派,免得一条长 prefill 混进 DP 批里拖慢所有 rank。
这套切法定下之后,MoE 的通信路径还要一刀刀砍,见第十四节。」

🖥 屏幕:滚到「名字别照字面套」上面那段 R1 命令。

「读 TPU 启动命令要留心。tpu-inference 跑 DeepSeek-R1 的命令写着张量并行八路,那其实是总 device 数;真正的切法在 additional-config 里:TP 一、开 DP 注意力、EP 八,就是 DEP8。
⛔ 名字别照字面套。TEP、DEP 是 TRT-LLM 的叫法,不等于训练框架 Megatron 的 ETP、EDP,后者指专家层内再分的 TP 组和 DP 组。prefill、decode 各用哪个,vLLM 部署 K3 和 TRT-LLM 的例子正好相反,专题五讲过。」

🖥 屏幕:滚到「6.3 大 EP:是什么,为什么省」,fig-s6-bigep-what,先指左边八张卡里密密麻麻的格子,再指右边那张放大的卡只剩两个路由加一个共享。

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

「看左边 EP8:每张卡三十二个专家。图下那行是本课推的:V3 按每参数一字节约六百七十一 GB,八张 80 GB 的卡加起来六百四十 GB,放不下。
右边 DeepSeek 线上 decode:EP 一百四十四,十八台机器。两百五十六个专家,再加三十二份热门专家的副本,共两百八十八份,除以一百四十四,每卡两个路由专家,外加一个共享专家。」

「prefill 那边是 EP 三十二,四台机器,每卡九个路由专家加一个共享专家。
V3 技术报告里写的 decode 配置还要更大,两份资料对不上;这里用的是 DeepSeek 开源周公布的线上配置。」

⭐⭐⭐ 下面这一块是本节最容易讲歪的地方,讲慢。

「⛔ 先挡一个误会。有人会说:每个 token 只选八个路由专家加一个共享,那每张卡本来就只用到八加一个,铺开有什么用?
⭐ 八加一只对单个 token 成立。一批里几百个 token,各选各的,合起来几乎每个专家都有人选。第五节算过:两百五十六个 token,每个专家被选中的概率超过百分之九十九点九。
所以 EP8 每卡那三十二个专家,每步都得全读一遍。大 EP 的意义就在这:每卡只放、只读自己那两个。」

💬 互动:动画放之前问「专家铺到一百四十四张卡,每张卡每层要读的专家权重少几倍:两倍、五倍、十六倍?」举手投票。期望答案:十六倍,三十二个专家变两个。

🖥 屏幕:往下放 anim-bigep,先闭嘴看完一圈(24 秒)。

「十六倍。DeepSeek 自己的说法就两句:EP 把批做大,矩阵算得更有效率;每卡只管一小撮专家,访存少,延迟低。V3 每层两百五十六个专家只激活八个,不铺大,总批凑不起来。
动画把这条链拆成了三格,一格一格看。」

「第一格,车坐得满。本课推的式子:每份专家分到的行数,等于卡数乘每卡请求数乘八,再除以专家份数,负载均匀时。
每卡三十二个请求:EP8 每份专家八行,正是第一节算的平均数;EP 一百四十四涨到约一百二十八行。
⭐ 每卡带的请求一样多,专家铺得越开,同一个专家收到的行就越多。」

「第二格,读得少。每层每卡要读的专家权重,从一点四一 GB 降到八十八 MB;读进来的每个字节,也被更多行用上。
第三格,腾出显存。光放路由专家,EP8 每卡就越过 80 GB 那条红线,根本放不下;EP 一百四十四只要五 GB 出头,剩下的装 KV,批还能再大。」

「实测:二〇二四年十二月,SGLang 先给 DeepSeek 模型开了 DP 注意力,decode 吞吐最多是原来的一点九倍。后来用九十六张 H100 复现大 EP,输出最多是同卡数纯 TP 的五倍。
⛔ 那个五倍含第八节的 PD 分离,几招叠起来的,不全算注意力切法的功劳。」

🖥 屏幕:滚到「6.4 大 EP 的代价:网络、大批、一卡出事全组陪着」,fig-s6-bigep-net,先沿左图两条线从左指到右。

「代价先在网络。大 EP 每层传两趟:先把 token 分发到专家所在的卡,用 FP8;算完再汇回,用 BF16,汇回那趟大一倍。
左图是 DeepEP 低延迟 kernel 在 H800 上实测:卡数从八涨到两百五十六,涨了三十二倍,每趟只慢两到三倍。」

「只慢两到三倍,听着不多,可每层都要付。本课算一笔:EP 两百五十六一去一回半毫秒多,乘 V3 的五十八个 MoE 层,约三十二毫秒。
这是不重叠时的上限。不藏起来,一步要白等三十毫秒上下,省下的读权重时间全赔进去。」

🖥 屏幕:同一张图,指右边三张卡片,先「8 卡机器 + InfiniBand」,再「GB200 NVL72」,最后「TPU Ironwood」。

「常有人问是不是非 NVL72 不可。⛔ 不是。DeepSeek 就跑在普通八卡机器上:机内 NVLink,全集群 InfiniBand 全互连,DeepEP 的测试机每卡一张四百 Gb 网卡;decode 用 IBGDA,由 GPU 直接发起 RDMA,不经 CPU。
开源栈也写明了门槛:llm-d 要求 InfiniBand 或 RoCE 全互连、GPU 发起 RDMA;vLLM 文档的排障一节专门列了 IBGDA 初始化失败。」

「还有一招少跨机器:V3 训练时就限定每个 token 最多去四个节点,先过 IB 到目标节点,再走 NVLink 转发给机内各卡;同一节点挑中几个专家,IB 上只走一份。共享专家每卡一份,本地算,不用发。
⭐ 量其实不大,难在延迟。一个 token 一步发收的量,比它四 K 上下文一步要读的 KV 小一个多量级,这是本课推的。难的是每层都要等一去一回,五十八层下来,出一个字要等一百一十六次。」

「NVL72 换来的是余量:七十二张卡一个 NVLink 域,EP 铺到几十张卡也不出柜、不走网卡。这份余量 SGLang 怎么花的,等代价数完再看。
TPU 这边,Ironwood 六十四颗一组,ICI 直连成 3D 环面,每颗只连六个邻居,远处要经中间芯片转发,这条是本课推的。组之间靠光交换拼成最多九千二百一十六颗,再大就走数据中心网络。」

「MaxText 有跨数据中心网络做专家并行的配置项,但推荐跨过去的只有数据并行。
公开的 TPU 推理目前是 DEP8,专家那步用 all-gather 加 reduce-scatter,不是 all-to-all。跨切片的大 EP 推理,还没有公开结果。」

🖥 屏幕:滚到「代价:要大批,要藏通信,一张卡出事全组陪着」,沿下面五个加粗段首往下指。

「把账单列全,一共五笔。一,通信露在外面,刚才那三十二毫秒,要靠双微批藏。二,批得够大,批小了凑不满车、传的开销照付:SGLang 实测 decode 每卡三十二个 token 时,双微批反而慢百分之二十七。三,等最慢的那张卡,一张过载,其余空等。
四,爆炸半径:一个 DP rank 出故障,整个 DP 组都得下线,最多一百二十八张卡。五,DeepEP 两套 kernel 一个偏吞吐、一个偏延迟,同一个通信组只能用一种,SGLang 因此必须 PD 分离。」

🖥 屏幕:滚到「整柜当一个 EP 域:SGLang 在 GB200 NVL72 上怎么还这几笔账」,指那行 --tp-size 48 命令。

「五笔账摆完,看一份把它们逐笔还掉的答卷:SGLang 在 GB200 NVL72 上的两篇博客,DeepSeek V3,两千 token 输入,prefill 和 decode 分机跑,分机这件事第八节讲。
decode 用四十八张卡。命令写着张量并行四十八,和刚才 TPU 那条命令一样别照字面读:配上 DP 注意力,其实是四十八路 DEP,EP 四十八。」

🖥 屏幕:同一段,沿下面五个加粗段首往下指,停在「反着缩」。

「网络这笔:DeepEP 加了纯 NVLink 模式,别的卡的显存直接映射进本卡的地址空间。延迟低到双微批可以关掉,整批算,kernel 更快,也不会出现通信比计算还长、重叠了还空等的情况。
大批这笔:decode 每卡一次跑七百六十八个请求。原文把显存大、KV 放得多、批更大列为提速原因之一。」

「第二篇再挤 KV:KV 存成 FP8,decode 注意力的访存压力约减半,也能多装 token。batch 就选到 KV 基本占满,比第一篇将近翻倍;降回第一篇那么多,性能掉一成左右。
少传:专家换 NVFP4,DeepEP 发之前就量化,分发流量比 FP8 再砍一半。」

「最有意思的是反着缩。⭐ prefill 没往大铺:每个实例只用四张卡,低精度时两张;显存不够,就借 CPU 和 GPU 之间那条快通道,把权重放在主机内存里提前取。
原文列的好处正好对上刚才那几笔代价:通信少,出事波及的卡少,也少等最慢的那张。⭐ 大 EP 不是越大越好,最优大小看 kernel 和模型。」

🖥 屏幕:指下面「换来多少」那段。

「换来多少:对比 H100 上的大 EP 部署,第一篇 decode 每卡快将近三倍;第二篇再换上低精度,decode 快将近五倍。
⛔ 倍数别全记在大 EP 头上:里面混着显存、精度、kernel、分机;decode 是先压慢、攒满请求再测的。原文自己也说,许多 kernel 还没吃满带宽和算力。
下面两招,一招藏通信,一招治忙闲不均。」

🖥 屏幕:滚到「6.5 双微批:一批拆两半,一个传、一个算」,fig-s6-tbo,先指上面「算」那一行的空档,再指下面排满的那一行和「省下的这段」。

「先藏那三十二毫秒。看上面不拆的:每层四步,注意力、分发、专家、汇回,分发和汇回时「算」那一行全是空档。
DeepSeek 把一批拆成 A、B 两个微批:A 在传,B 就在算。看下面,「算」那一行排满了,省下的就是右边那一段。SGLang 叫它 TBO,vLLM 叫 DBO,都是这一招。图上时长是示意。」

「实测,prefill 最赚:SGLang 测,同样的 token 数快三成上下;拆开还省显存,能多塞 token,比不拆时调到最好再快四成。
decode 看批多大:批大时快四分之一;每卡只有三十二个 token 时,就是刚才那个慢百分之二十七,半批太小,kernel 吃不饱。所以 vLLM 默认批小就不拆。」

「几个细节。decode 各步长短不一,DeepSeek 把注意力再切成两段,排成五段流水。
一个微批内部仍是串行:路由、分发、专家、汇回一环扣一环。重叠靠两个微批错开半拍,错着就跨了层:A 还在收第 N 层,B 已经在算第 N 加一层的注意力。
decode 的通信不占计算单元:RDMA 发出后,SM 全部还给计算;prefill 的通信要占 SM。」

「代价:权重不多存,但多读一遍。两个微批用同一份权重,可各自做矩阵乘时都要把这层权重流一遍,一步读两次,本课推的。EP 一百四十四每卡每层专家八十八 MB,读两遍不贵;每卡三十二个专家的一点四一 GB 就肉疼。
NVL72 上又换了个法子:通信变短,拆半批反而亏。SGLang 第二篇不拆批,只把汇回通信和专家的下投影、共享专家叠在一起,在 GEMM 里埋信号,通信不必等整个 GEMM 算完。
单批也能跨层藏:本层在算时,先把下一层权重往片上搬,不靠拆批。第十四节 K3 的 megakernel 就这么干。」

🖥 屏幕:滚到「6.6 EPLB:热门专家多备几份」,fig-s6-eplb,先指左边卡 0 那根最高的柱子和红虚线 70。

「哪个专家热门,要等路由算完才知道。专家那一步等最慢的卡,热门专家所在的卡拖住所有人。
看左边,八个专家、四张卡,按编号放。专家零一个人分到六十,卡零合计七十,平均才五十。所有卡都得等到七十那条红线。」

🖥 屏幕:同一张图,指右边:专家 0 和专家 0′ 各 30,红虚线落到 52.5。

「EPLB,专家并行负载均衡器,DeepSeek 开源的。办法很朴素:按过去一段的负载统计,把热门专家多复制一份放到别的卡上,再重新排座位。
右边,每卡多一个空位,专家零和专家七各复制一份,token 平分给两份。最慢的卡降到五十二点五,平均还是五十。⭐ 加的是空位,换的是等待。数字是示意。」

「DeepSeek V3 怎么配:prefill 多备三十二个冗余专家,每卡原有八个再加一个,按线上统计定期重算,例如每十分钟。
卡越多越不均,就越要紧。SGLang 在大规模 EP 上测,开 EPLB 后 prefill 吞吐是不开的一点五倍,decode 两倍半;作者提醒效果看负载分布,线上要拿真实流量重测。」

「顺带还松开了卡数:两百五十六个专家只能均分给二的幂张卡;加三十二份冗余凑成两百八十八,十二张、七十二张也分得开。
两个框架都是一个开关加一个冗余份数,刚才 GB200 那份复现命令里,就带着三十二份冗余专家。」

🖥 屏幕:滚到本节末尾「回到主线」,再指下面「考考自己」那一格(先别展开)。

💬 互动:念课件「考考自己」:「4 个 KV 头的模型,8 张卡开 TEP8,换 DEP8 后 KV 容量最多是原来的几倍?什么情况下涨了也没用?」等两三个人答。期望答案:2 倍(8 ÷ 4);prefill 喂不上、或 batch 大到算力先到顶时,放得下也换不来吞吐。⏭ 时间紧可跳:留给学员自己展开看答案。

「这一节在杠杆上归车上多坐人:注意力那头,DEP 省掉每步白读的副本,座位坐满就换吞吐,SGLang 两头 DEP 做到官方目标的九成五;专家那头,大 EP 让每个专家一趟分到更多行,每卡只读自己那两个。
留下的问题:每个 rank 自备一份状态,K3 这类模型 DEP 起不来,退回 TP,KV 又被复制。不换 DEP、留在 TP 上,能不能也把副本去掉?能,换个方向切:沿序列切,第七节。」

⚠️ 这一节最容易跑偏的地方 ⛔ 别说「DEP 多装了 4 倍请求」:4 倍是容量上限,池子坐满才兑现;SGLang 那组实测每卡坐到 727/886/999(ISL 4096、14 路 × 并发 1050,runbook :851-858),没有和 TP 同条件对比过。⛔ 也别拿 Little 定律算的在飞请求(输出 × 间隔)去驳容量:那是速度的结果,不是池子能装多少。
⚠️ dep16 那组 prefill 从 14 台降到 12 台,卡数配比同时变了,别说成「dep16 不如 dep8」;runbook 自己的判断是 prefill 成了瓶颈(:794-806)。
⛔ 别说「每个 token 只用 8+1 个专家,所以每卡本来就只读那几个」:8+1 只对单个 token 成立;一批几百个 token 合起来几乎每个专家都被选中(5.2 图下:256 个 token 时每个专家被选中概率 > 99.9%;7.3 表里 TP16 一批 5 个 token 已碰到 37.6 个路由专家)。EP8 每卡 32 个专家每步全读,大 EP 的意义就是每卡只放、只读自己那 2 个(课件 6.3 图「每张卡 32 个专家,每步都要把它们读一遍」)。
⚠️ vLLM 旁证口径杂:2.09 倍是按全部卡(含 12 张 prefill 卡)的总吞吐;只算 decode 卡的输出是 1,055 → 1,379,1.31 倍。两边投机接受率 34% 对 35.7%,可排除投机。只当速度轴旁证,别和 SGLang 那组的数并排比。
⚠️ Day 6 的日期:开源周排在 2025 年 2 月最后一周,但 Day 6 是 2025-03-01 发的(仓库目录名写 202502,别据此说二月)。
⚠️ mmlu_pro 只抽 50 题(PR 写 limit=50),「在 1σ 内」是冒烟测试,不是严格对齐。
⚠️ Qwen3.5 那 4 份副本是本课解读,台上带「PR 没归因」,另一种解读(TP 基线撞参数上限)也要说。
⛔ 别说「大 EP 必须 NVL72」:DeepSeek 跑在 8 卡机器 + IB 上(课件 6.4)。
⚠️ GB200 的 2.7×/3.8×/4.8× 要带条件:DeepSeek V3/R1、2K 输入、每卡、对 H100 大 EP 部署;4.8× 是 FP8 注意力+NVFP4 专家;decode 先压慢攒满再测;H100 基线有一组开了模拟 MTP、GB200 没开。倍数混着显存、精度、kernel、PD,别归功给大 EP 一项。
⚠️ 768/1408 按每卡读:768 来自第一篇复现命令(--cuda-graph-bs 768,--max-running-requests 36864 = 768 × 48);1408 第二篇只说 batch,按同一口径读作每卡,是本课推断。
⚠️ 8 行、128 行、16 倍、32 ms、10 MB 是本课推导:行数是每卡 32 个请求、负载均匀的示意;32 ms 是不重叠上限,台上说「算一笔」。
⚠️ EPLB 那张图的 70、52.5 是示意,不按实测;实测倍数用 SGLang 的 1.49/2.54,且作者提醒看负载分布。
⚠️ R17 口径(6.4 账单并成一段后撤下的出处):「一张卡过载就拖慢整个系统」是 DeepSeek 原话;「一个 DP rank 出故障整个 DP 组下线、最多 128 张卡」出自 Anyscale;TensorRT-LLM 提醒没有容错会抬高线上故障率,并在 GB200 上自己写了通信 kernel;DeepEP 常规模式用不了 CUDA Graph,而 decode 离不开它。
⚠️ R13 口径(第六节口播撤下的原数):再加 KV 显存 13%,每卡 886 → 999,吞吐 10,614 → 10,704(只多 0.8%),一步 77.7 → 85.3 ms;最终 10,704 = 官方 11,200 的 95.6%(口播「九成五」)。vLLM 旁证并发 512,出字间隔 46.8 → 11.8 ms(口播「四分之一左右」,本课算 0.25)。dep16:间隔 60 → 33 ms(「将近一倍」),总输出 +17%(「不到两成」),首字 45 → 54 s(「慢了九秒」),每张 decode 卡 9,032 → 5,270(「掉了四成多」,本课算 −42%)。TPU PR 并发 512:4,266 → 6,914(+62%,「六成」);mmlu_pro DP=8 0.8129、TP=8 0.8271(「差一个多点」)。V3 技术报告 decode:EP320、40 台、每卡 1 个专家;开源周 Day 6 于 2025-03-01 在 open-infra-index 公布。动画:行数 8 × 32 × 8 ÷ 256 = 8;一个路由专家约 44 MB;每字节用 8 → 128 次;EP8 路由专家每卡 81.7 GB、EP144 5.1 GB。网络:每 token 最多发约 57 KB、收约 115 KB(本课推导,「汇回大一倍」);DeepEP 每批 128 token,分发 77 → 194 µs、汇回 114 → 360 µs;EP256 一去一回约 554 µs(「半毫秒多」);一步发收约 10 MB 对 4K 上下文 KV 288 MB。GB200:48 卡合计 36,864 请求;第二篇 batch 1408(比 768「将近翻倍」);C2C 900 GB/s;第一篇 decode 7,583(2.7×,「将近三倍」),第二篇 prefill 26,156、decode 13,386(3.8×/4.8×,「将近五倍」)。双微批:prefill 同 token 数 +27~35%(「三成上下」),每卡 16,384 token 再 +40.5%(「四成」);decode 每卡 256 token +25.5%(「四分之一」);vLLM 纯 decode ≤ 32 token 不拆。EPLB 1.49/2.54 倍口播取整为一点五/两倍半;vLLM 默认每 3,000 步按最近 1,000 步统计重排(eplb config)。
❓ 台下可能问(备答,不计地板;数都在课件上)
💰 管预算的「几个高端用户、并发很小、每人要非常快,用 TEP 还是 DEP?」→ TEP(注意力走 TP),再开投机。人少时一步几乎全花在读权重上:TP 按头切开注意力和稠密层权重,几张卡的带宽合起来服务同一批人;DEP 每卡自备整份注意力权重,一个人的注意力只在一张卡上算,人少时单人不变快(本课的解释)。TP 头数要能被卡数整除,别切出 NVLink/ICI 域。投机不只属于低并发:6.1 那组 V4-Pro 两边都开着 DSpark;固定猜几个的 MTP 在 DEP 上会翻车(第十一节),DSpark 忙时少验、闲时多验,所以能和 DEP 叠(本课的解释)。部署上可以按档分池:高端池 TP + 投机,批量池 DEP + 大 EP。
🛠 GPU 老兵「SGLang 不是报过比 TP 快五倍吗?」→ 那是连 prefill、decode 分机一起复现的输出,最多是同卡数 TP 的五倍;几招叠起来的,不全算注意力切法的功劳(6.3)。
🧑‍🎓 新人「EP 是什么?」→ 专家并行:不同专家放在不同卡上,每个 token 被送到它选中的专家那张卡去算。
🛠 GPU 老兵「Qwen3.5 那六成,会不会只是 TP 基线没调好?」→ 有可能:PR 没给 TP 的完整命令,TP 从并发 256 到 512 只涨 3%(4,130 → 4,266)。课件两种解读都列了,都排除不了(6.2)。
🛠 GPU 老兵「Megatron 的 ETP/EDP 是不是就是 TEP/DEP?」→ 不是一回事:ETP/EDP 指专家层内再分的 TP 组和 DP 组;TEP/DEP 是 TRT-LLM 对注意力切法的叫法(6.2)。
🛠 GPU 老兵「双微批 decode 也该开吧?」→ 看批:每卡 256 个 token 快 25.5%,32 个慢 27%;vLLM 默认纯 decode 不超过 32 个 token 不拆(6.5)。
💰 管预算的「换 DEP 要多花卡吗?」→ vLLM 那组多了 4 张 decode 卡(全部卡 16 → 20),按全部卡算每卡仍是 2.09 倍;SGLang 那套 16 台里 decode 只占 2 台。先看 TP ÷ KV 头数,大于一才值得换。
🛠 GPU 老兵「GB200 上是不是 EP 越大越好?」→ 不是:SGLang decode 用 EP48,prefill 反而每实例只用 4 张卡(低精度 2 张),靠 900 GB/s 把权重卸到主机内存;原文说最优 EP 大小看 kernel 和模型(6.4)。
💰 管预算的「大 EP 一卡坏了影响多大?」→ 一个 DP rank 出故障,整个 DP 组下线,Anyscale 说最多 128 张卡(6.4)。
⚙️ TPU 工程师「TPU 能跑大 EP 吗?」→ ICI 一组 64 颗、3D 环面,光交换拼到 9,216 颗;MaxText 有 dcn_expert_parallelism 配置项但跨 DCN 只推荐数据并行。公开推理目前是 DEP8,专家那步用 all-gather 加 reduce-scatter;跨切片大 EP 没有公开结果(6.4)。
⚙️ TPU 工程师「R1 的命令写 --tensor-parallel-size 8,就是 TP8?」→ 不是:那是总 device 数;真正的切法在 additional-config 里:TP=1、开 DP 注意力、EP=8,即 DEP8(6.2)。

第七节 切序列:DCP 和 PCP(17′)计划 17′ · 含互动 15.5′ · 跳后 15.0′

🖥 本节主屏:课件 第七节 切序列:DCP 和 PCP · 主图 fig-s7-dcp-gain

🎯 这一节留一句:DCP 只在 KV 放不下时赚,盈亏看 KV 总量;PCP 买的是首字延迟,切开以后先查对不对。

🖥 屏幕:滚到「切序列:DCP 和 PCP」,停在开头那段。

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

🖥 屏幕:滚到「7.1 DCP:只在长上下文赚,开之前先知道坑」,fig-s7-kv-dup-t5,先指上面 TP 8 路那排,再指下面 TP 8 + DCP 8 那排。

「先回顾专题五。看上面:V3 一个 128K 的请求,TP 八路。MLA 的 KV 只有一个头,每张卡都存完整的一份,每卡八点五八 GiB,八份一样的,七份白存。
看下面,加 DCP8:KV 按 token 轮流落到八张卡上,第零个 token 卡零、第一个卡一,每卡只剩一点零七 GiB,合起来刚好一份。⭐ 它不加卡,直接复用 TP 那几张。」

🖥 屏幕:fig-s7-softmax-merge-t5,一排三格:先指最左那格两张卡各自的分子分母,再指中间打叉那格,最后指右边打勾那格。

「KV 分散了,注意力怎么合?看这个小例子:三个 token,卡零拿前两个,分子二十四、分母三;卡一拿第三个,分子二十、分母一。
各除各的再平均:八和二十,平均十四,错。卡一只有一个 token,却占了一半的票。
先别除:分子加分子四十四,分母加分母四,四十四除以四等于十一,跟三个 token 放一张卡上算的一样。」

「好比几个班各报总分和人数,年级平均最后一起算,不能把各班平均数再平均。所以每张卡除了结果,还得交出自己的分母;分母取个对数,就是常说的 LSE。
代价是每层多几次通信,vLLM 默认后端每层三次。度数,就是切成几份,最多开到 TP 除以 KV 头数。」

💬 互动:下一张图出来之前问「同一个 Kimi K3,4K 输入和 128K 输入,DCP8 在哪边赚、哪边亏?」举手二选一。期望答案:128K 赚,4K 亏。答反了的,追问一句「4K 的 KV 放不放得下」。

🖥 屏幕:滚到「DCP 只在长上下文赚。」,fig-s7-dcp-gain,先指 128K 那个突出的点「+237%」,再指 4K 那一段四个负数。

「Kimi K3,GB300,SGLang,TP 八路跨两个节点,输出一 K。纵轴是 DCP8 除以 TP8 的输出吞吐,对数刻度,一条线一个并发。
看突出画的并发八那条:十二万八输入时,DCP 出字是 TP 的三倍多。
再看最左边四 K:四档并发全亏。」

「长了为什么赚?官方说 DCP8 能把整组卡存的 KV 撑大八倍。实测 TP8 默认只装得下七十九万 token 左右,可 128K 乘八并发要一百多万,放不下,只能少收请求。
结果是首字:TP8 调到最好也要半分钟,DCP8 两秒出头。⛔ 这是含排队的,不是 prefill 本身快了这么多。」

「短了为什么亏?KV 本来放得下,DCP 只剩代价。原记录发现,4K 亏得最多的那一档,亏的正好是关掉 symm-mem 的那份。
symm-mem 是 symmetric memory,一种加速卡间通信的显存用法;开 DCP 时它用不了。」

「⭐ 所以盈亏看的是 KV 总量,不是单看长度:同是 8K,并发八还亏百分之十一,并发三十二已经赚百分之二十四。盈亏点看输入长度乘并发压出来的 KV 总量。
图上并发一的 8K、32K 没测,虚线只连两端;横轴也没换成 KV 总量,因为原表只给了长度和并发,没有实测的 KV 占用。」

🖥 屏幕:滚到「开 DCP 之前要知道的坑。」,沿下面三个加粗段首往下指。

「开 DCP 之前,三个坑。
一,缓存层没跟上:SGLang 的 HiCache 开 L3 远端存储,或者 L1 加 L2 叠投机解码,就得退回纯 TP。
二,状态池它不管:K3 的 KDA 状态池,DCP 不切,第六节那张格子图。
三,K3 官方另有两组 prefill、decode 分机的部署,反倒是 TP8 吞吐略高。可分母和输入长度官方都没写,别拿来和这张图比。」

🖥 屏幕:滚到「7.2 PCP:超长 prompt 的首字延迟」,fig-s7-pcp-dcp-t5,先指上半张 PCP 那块三角表的四条横带。

「再说 PCP:在 prefill 阶段沿序列切,让几台机器合算同一个 prompt。
注意力可以看成一张提问乘笔记的表:一行是一个新 token 的提问,一列是前面一个 token 的笔记。只看前面,所以是三角。
prefill 几千个提问一起来,按行切给四张卡,每一行在一张卡上算完,结果不用合。可卡三那两行要看左边全部笔记,得先把前面的 KV 收齐。为了第一个字早出来;现在的引擎里 PCP 一般另开一维,要另外加卡。」

🖥 屏幕:同一张图,指下半张 DCP 那一行被切成四段。

「下半张是 DCP:decode 每步只剩一个提问,表只有一行,没行可切了,只能把这一行按列切开,每张卡算一段,交出分子加分母,再按先别除合起来。用的是原来那几张 TP 卡,不加卡。
⭐ 两种看法是同一件事:笔记都按 token 分段放在各卡上,差在传什么,PCP 传笔记、DCP 传提问(Meta 叫 pass-KV/pass-Q);画在表上,就是先切行,行切到只剩一行,再切这一行。加不加卡是现在引擎的部署习惯,不是机制区别。」

🖥 屏幕:滚到「Meta 2024 年 11 月的论文」那一段。

「二〇二四年十一月,Meta 的论文把训练侧切序列的办法搬进推理 prefill:一百多张 H100 合算 Llama3 405B 的一个 prompt,一百万 token 七十七秒。
用的是 Ring,二〇二三年十月提出:各卡拿一段,别人那段沿环一站站传来,边传边算。整段 prefill 传 K、V,GQA 下它小;新 token 很少时改传 Q。结果都和不切一样。」

「同一篇里,一到八台之间机器数翻倍,prefill 延迟约减半;再从八台翻到十六台,只降了三成多,没到一半,这个比是本课按原文两个数算的。」

「跨机切 TP 就不行:两台时 TP16 比 CP2 慢约百分之十五,八台慢约一倍。原文的解释:TP 每层都要走跨机带宽,它比机内低得多。
另一条路是 Ulysses,DeepSpeed 二〇二三年九月提出:用 AllToAll,每张卡给其余每张卡各发一份,把按序列切换成按头切,所以切的份数不能超过头数。」

🖥 屏幕:滚到「PCP 的两个正确性陷阱。」。

「PCP 出错往往不报错:形状全对,数不对。
⭐ 第一个陷阱:少算会「更快」。某个 rank 漏了别段的 K、V,算量少了,速度自然好看。快得反常,先核输出。
第二个陷阱在线性注意力。softmax 注意力没有跨段状态,拿齐 K、V 就能算对;GDN、KDA 这类层不一样,带着一份随 token 更新的状态。」

🖥 屏幕:fig-s7-pcp-linear,先指平滑那条一口气扫到底,再指锯齿那条每段又从 0 起步,最后停在右端「3.439(差 58%)」。

「这份状态像存折余额:每来一个 token,先把上一笔余额打个九折,再加上新存的一块。这是本课自造的玩具递推。
十六个 token 切给四个 rank,每段四个。平滑那条一口气扫到底;锯齿那条,每个 rank 从零余额起步,最后一段差了将近六成,程序照常跑完。」

「修法有两种:把前一段的末余额传过来;或者利用结合律,各段并行算好自己对状态的那份映射,再从头合并出每段的起始状态。
⛔ 存折比方只管「状态要接力」这一件。真实的 GDN、KDA 状态是矩阵、带门控,别往利率、复利上延伸;递推的形状一样,都是乘上一步状态再加新东西。」

🖥 屏幕:滚到「7.3 并排看:副本让出来,多放 token」,先停在第一张表,指「剩给 KV」那一列。

「把第六、七节的切法摆进同一本账。V3,八颗 v7,共十六个 device,上下文十二万八。全是本课推的纸面账。
每个 device 留一成给激活值,剩八十五 GiB 左右;一条十二万八的 KV 是八点五八 GiB。实测 FP8 专家比均摊更占地方,真机余量只会更少。」

「第一行,DP 整套复制:一份权重就六百多 GiB,放不下,零条。
TP16 和 TEP16:权重全切开,每个 device 剩一半多给 KV。」

💬 互动:先别往下看「装几条」那一列,问「TP16 下 128K 能装几个人?换 DEP16 呢?」等两三个人报数。期望答案:TP16 只装 5 个,DEP16 装 48 个。有人算 TP16 装八十多个,追问一句「MLA 那条 KV 能不能按头切开」。⏭ 时间紧可跳:题当设问念一遍,直接指那一列。

「TP16 只装五个。MLA 每层只有一份 KV,按头切不开,十六个 device 每个都得存一整份,四十六除以八点五八,五条。TEP16 一样是五条。
DEP16 每个 device 多背一份非专家权重,自己只装三条;可每条只存在自己那个 device,十六个合起来四十八条,将近 TP16 的十倍。」

「再叠 DCP16:一条 KV 按 token 切成十六份,每个 device 只存一小片,权重又是全切,能装八十六条。
⛔ DCP 叠不到 DEP 上:度数最多 TP 除以 KV 头数,DEP 的 TP 是一。所以最后一行是 TEP16 加 DCP16。」

🖥 屏幕:往下到第二张表,先指「每层读权重」和「每层读 KV」两列,再指「一步读完下限」,最后指「每层通信」那列。

「再看每层读多少。读的一侧取装满时的 batch,下限只算从 HBM 读的字节。
TP 和 TEP 只差在专家:TP 是切片,TEP 是整块,热门专家那张卡要多读,大家等它。
DEP 每个 device 每层都要整份读一遍注意力权重,这是不复制 KV 换来的代价。」

「只算读:三种切法一步的下限相差不到一倍,一步出的字却从五个涨到四十八个、八十六个。
最后一列是通信:TP、TEP 每层两次 AllReduce,DEP 两次 all-to-all,DCP 再加每层三次。⭐ 下限只看了读,谁真赢,要把这列也算进去。」

「先给第十节埋一笔:那里有张图说八颗装得下十二万八乘六十四,前提是 KV 不复制、非专家权重不重复。照这本账,DEP 只到四十八条,TEP 十六加 DCP 十六到八十六才兑现。」

🖥 屏幕:指本节末尾「考考自己」那一格:「4K 输入、并发 8 的线上服务」,展开答案。

「最后那道考考自己:四 K 输入、并发八,不开 DCP,KV 放得下,只剩代价;十二万八的长对话开,TP 八路放不下,只能少收请求、排长队。」

「两节都是车上多坐人:DEP 去掉每步白读的副本;DCP 把副本换成更长的上下文,只在长输入赚。PCP 是另一件事,买的是首字。
到这里,所有切法都还在同一批卡上。下半场把 prefill 和 decode 拆到两批机器上,每个请求要多搬一趟 KV,接的请求反而能多出几倍。凭什么?休息十分钟,回来揭晓。」

🖥 屏幕:中场休息,画面停在课件第八节标题。

⚠️ 这一节最容易跑偏的地方 ⛔ 别把 DCP 讲成「总是更快」:短输入各档都亏。要带走的是盈亏点,不是 +237%。
⚠️ 首字 32.1 s 对 2.3 s 含排队,不是 prefill 本身变快了这么多。
⚠️ 短了亏的那份:−26% 正好等于关掉 symm-mem 的损失(课件 7.1)。
⚠️ Meta 那篇「翻倍减半」只在 1 到 8 台:8 台 128K 5.85 s,16 台 3.8 s,只降约 35%(本课按原文两个数算)。别说成一直线性。
⚠️ 存折比方只管「状态要接力」:真实状态是矩阵、带门控,别往利率、复利上延伸。
⚠️ 7.3 两张表全是本课推导的纸面账:读的下限不含通信和计算;实测 FP8 专家比均摊更占地方(10.2)。
⚠️ 休息十分钟不计入计划时长。
⚠️ R13 口径(第七节口播撤下的原数):128K TP8 合计 68.6 GiB。并发 8 × 128K:DCP 365 对 TP 108 tok/s(+237%,「三倍多」);4K 并发 1 亏 26%,正好等于关掉 symm-mem 的损失。官方 KV 容量 150 万 → 1,220 万 token(「撑大八倍」,本课算 8.1);TP8 默认实测约 79 万,开投机再少两成。首字中位数 TP8 最好档 32.1 s、默认档 39.3 s、DCP8 2.3 s(「半分钟/两秒出头」)。K3 分机部署 TP8 2,808 对 2,633。Meta:128 张 H100、1M 77 s、128K 3.8 s、并行效率 93%;8 台 128K 5.85 s。存折玩具:平滑 8.147、锯齿每段 3.439。7.3:每 device 可用 94.75 GiB;DP 权重 625 GiB;TP16 权重 39 GiB 出头、剩 46 GiB(「一半多」);DEP16 多占约 15 GiB、剩 31 GiB;48 ÷ 5 = 9.6 倍(「将近十倍」);DCP16 每条每 device 0.54 GiB;DEP 每层注意力权重 187 MB;读的下限 14.4/20.6/24.1 ms(最大比最小 1.67 倍,「不到一倍」)。
❓ 台下可能问(备答,不计地板;数都在课件上)
🛠 GPU 老兵「MLA 的提问不是先压到 1536 维吗?DCP 为什么不传压缩的,到了再解压?」→ 能传,但划不来。解压要用那块展开矩阵,按 TP 每张卡只存自己那几个头的八分之一;各卡自己解压全部头,就得每张卡存一整块、每步整块读一遍,每层多读约四千万个参数,换来少传一百多 KB 的提问。decode 卡在读,车上不到约三百个 token 时传提问更便宜(本课按 V3 形状推);八张卡还把解压重复算八遍。SGLang 的做法是各卡算自己那几个头的提问,再在 DCP 组里 all-gather。另外就算按 1536 比,笔记 576 也还是小的那个,PCP 搬笔记的结论不变。(2026-10-22 试讲追问后补)
🛠 GPU 老兵「上下文多长,注意力的计算量才超过专家?」→ 课件 7.1 拿 Qwen3.5-397B 算了一笔(本课推导):单层 decode 约 8.4K、prefill 约 16.9K;60 层只有 15 层全注意力,全模型 decode 约 34K、prefill 约 68K。但这不是开 CP 的门槛:decode 拼读字节,DCP 看 KV 放不放得下,PCP 看首字。
🧑‍🎓 新人「DCP 和 PCP 一字之差,差在哪?」→ D 是 decode,切的是 KV 的存放,用原来的 TP 卡;P 是 prefill,切的是一个长 prompt 的计算,要另外加卡。(加不加卡是现在引擎的部署习惯:Meta 的 pass-KV/pass-Q 用的是同一批卡、同一种切法,只是传的东西不同)
🛠 GPU 老兵「Ring、Ulysses 选哪个?」→ 两个都是二〇二三年提出的,Ulysses 九月、Ring 十月;Ring 传 K、V 还是 Q,看谁的通信藏得进计算,结果都和不切一样;Ulysses 用 AllToAll 换成按头切,切的份数不能超过头数。Meta 那篇用的是 Ring。
🛠 GPU 老兵「DCP 能和 HiCache 一起开吗?」→ 课件 7.1 记的坑:HiCache 开 L3,或 L1+L2 叠投机解码,就得退回纯 TP。
🛠 GPU 老兵「DCP 能叠在 DEP 上吗?」→ 不能:度数最多 TP ÷ KV 头数,DEP 的 TP 是 1(7.3)。
💰 管预算的「长上下文要多付多少?」→ 先是人少:第四节一个 device 4K 装 172 条,32K 只剩 21 条。DCP 能把 K3 的 KV 容量从一百五十万撑到一千二百多万 token(官方口径;TP8 默认实测约七十九万),但短输入会亏。

第八节 拆工作:那一趟 KV(27′)计划 27′ · 含互动 23.8′ · 跳后 23.3′

🖥 本节主屏:课件 第八节 拆工作:那一趟 KV · 主图 fig-s8-kv-bw

🎯 这一节留一句:PD 分离不改变 decode 每一趟搬多少,它保证 decode 不被 prefill 打断;代价是那一趟 KV,上线前先量带宽、再比字。

「欢迎回来。休息前那道题,有答案了吗?多搬一趟 KV,凭什么多接请求?」

💬 互动:听两三个答案,不揭晓,anim-pdsplit 播完再收。期望答案:decode 不再被 prefill 打断,才敢把 batch 攒满。

🖥 屏幕:滚到「拆工作:PD 分离与那一趟 KV」,停在导语。

「下半场拉第三根杠杆:开两个仓库。第六、七节把每张卡带的人撑多了,长 prompt 一进门,卡住的也多;分块 prefill 只是把打扰摊平,两段还挤在同一批卡上。
那就把吞 prompt 的和吐字的分到两批机器上,这叫 PD 分离。难的是 KV 从 prefill 机传到 decode 机的那一趟。」

🖥 屏幕:滚到「8.1 为什么要拆,那一趟要多久」,fig-s8-decode-ai-t5,先指横轴,再指上面那条稠密线和横着的显存线,最后指下面那条 MoE 线。

「先把专题五这张图请回来,提醒一下为什么非要凑大批。横轴是一步里一起出字的请求数,纵轴是从显存读一个字节的权重,能换来多少次计算。
稠密层那条线,一批几个请求,就换几次。v7 的算力除以显存带宽,约三百一十三:一批不到三百个请求,卡就在等显存。」

「MoE 那条线更低。V3 每个专家平均只分到这一批的三十二分之一,要一批约一万个请求,每个专家才吃得饱。这些是本课推的,只算了读权重,读 KV 门槛还更高。
所以 decode 的各种做法,都在凑一个大 batch。可 batch 越大,一次 prefill 插进来,卡住的人就越多。」

🖥 屏幕:停在 anim-pdsplit,等它播完一圈(22 秒);先指上组的红框,再指下组那支紫箭头。

「上下两组时间轴,一格是一步 decode 的时间。前四步两组一样:A、B、C 每步各出一个字,格子等间距。
然后来了一个长 prompt,橙色那段占了五格。上组是混部,它占住整台机器,红框里 A、B、C 这五格一个字都没出。batch 越大,红框里卡住的人越多。」

「下组拆开了:prefill 在自己那台机器上算,decode 机一格不断,字距始终均匀。这就是休息前那道题的答案。
代价是那支紫箭头:每个请求多传一趟 KV。注意箭头上写的是传 KV,不是传权重。新请求带着 prefill 给的第一个字进 decode 批,之后一步一个字。图上传 KV 画得比 prefill 短,到底多短,等会儿算。」

🖥 屏幕:滚到「Splitwise(2023)、DistServe(2024)先后提出它」,再往下指 Mooncake 和 Dynamo 那两段。

「这个想法不新。Splitwise 二〇二三年、DistServe 二〇二四年先后提出,一篇报同成本同功耗下吞吐最多二点三五倍,一篇报每卡能接的请求最多七点四倍。
口径一个比吞吐、一个比能接住的请求,都是论文里最好的那组,别拿来比高低。」

「真正做进生产的是 Kimi 的线上系统 Mooncake,连同第四节那个 KV 池一起:KV 反正要搬,算过的顺手存着。正式版报告说,比此前系统多接一倍多的请求。
NVIDIA 的 Dynamo 二〇二六年出了一点零正式版,里面搬 KV 的那层叫 NIXL。到这时,PD 分离已经是标准件了。」

「拆开换来什么?TPOT 稳了;两边还能各挑各的切法,就是第六、七节那些。
代价三样:一趟 KV 传输,两套机器,还有一份要调的配比,那是第九节。」

🖥 屏幕:滚到「那一趟要多久。」,fig-s8-kv-trip-t5,先指上面那根一到两秒的 prefill 长条,再指下面那根三色细条,最后指「放大 10 倍」那一行的三段。

「专题五算过这一趟。Qwen3-Coder-480B,一个八千 token 的 prompt,prefill 本身要一到两秒。
KV 从 prefill 机搬到 decode 机分三段,大头是中间走一百 Gbps 网络那段;三段加起来约一百毫秒,只是 prefill 的零头。这是按带宽估的,不是拿秒表掐的。」

「为什么才这么点?这个模型 KV 头少,只有八个,又用 FP8 存,八千 token 的 KV 本课乘出来约一点零四 GB。
这个一点零四 GB,后面会当一把统一的尺子反复用。」

「一百 Gbps 还是保守算。GB300 每张卡配八百 Gbps 网卡,一趟只要十毫秒上下,也是本课推的。
敢走慢线,是因为一个请求只传这一次。TP 每一层都要通信,只能待在最快那一圈;这里一个请求就一趟,跨机器也藏得住。」

「这靠两个前提:网络真跑在设计带宽上,KV 没大到离谱。后面两个故事,各打破一个:8.2 打破第一个,8.4 打破第二个。」

🖥 屏幕:滚到「8.2 三层软件:谁搬、谁派、谁存」,fig-s8-kv-stack,先指左下的搬运层(路和车),再指正上方的调度层,最后指右下的存储层。

「图上把这一趟画成搬家:左边 prefill 机,右边 decode 机,中间一条路。路和车是搬运层,路口的调度员是调度层,路边的仓库是存储层。小字里蓝的是 GPU 的组件,青的是 TPU 的。
搬运层只管一件事:把字节从一块显存挪到另一块,GPU 上常见的是 NIXL 和 Mooncake 的搬运库。各层具体的组件名图上都有,不一个个念。」

「调度层决定请求先去哪台 prefill、算完交给哪台 decode。TPU 上 tpu-inference 那个代理做得很巧:把请求改成只要一个输出字,发给 prefill,反正 prefill 本来就顺手出首字;然后让 decode 端自己去拉 KV。」

「存储层是路边的仓库。KV 反正已经离开 prefill 机了,顺手存下来,同前缀的下一个请求直接取,放主机内存、SSD 或远端都行。
路和车只是比方,不代表真实拓扑。」

🖥 屏幕:停在「排查按层找」那一段。

「TPU 这边今天能直接用的是 TPUConnector;TPU Sync 刚开源,它自己说还不宜通用。
认层的好处在排查。带宽掉到每秒几百 MB,先看搬运层走没走对通道;请求接不上、握手失败,多半在调度层;前缀命中率低,查存储层。」

💬 互动:下一张图出来之前问「一趟 KV 要是从八十多毫秒变成五秒,你觉得系统会报错吗?」举手。期望答案:不会,只是首字变慢。多数人会以为超时报错。

🖥 屏幕:滚到「GPU 实战:配错一个开关,慢两个数量级。」,fig-s8-kv-bw,先指那根红条,再指灰带,最后指下面两根配对的条。

⭐⭐ 这一格是本节最反直觉的一下,讲慢。

「不会。vLLM 在 GB300 上跑 DeepSeek-V4-Pro 的 PD,起初 KV 每秒只走两百 MB。本课拿一点零四 GB 那把尺子换算,一趟要五千二百毫秒,五秒多,比一到两秒的 prefill 还长:红条比灰带还长。
⛔ 那把尺子是专题五那个 prompt 的,不是 V4-Pro 自己的 KV。带宽是实测,时间是换算。」

「再看下面两根。按对配置以后,runbook 自己的口径是单次传输从几百毫秒降到十毫秒以内。
配错和配对,差了两个数量级。而配错的时候什么都不报,只是首字慢。所以上线前先量一次 KV 传输带宽。」

🖥 屏幕:展开「那三样配置」折叠块,逐条指三行。

「错在哪?本该直接读对端 GPU 显存、走 NVLink 的那条路没走上,退回了经主机内存中转。
补的三样配置折叠块里有原文,意思是:通道去掉 RDMA,留下走 NVLink 那条和必要的拷贝、控制通道,允许跨机箱也走 NVLink,显存换一种对方认得出的分配方式。还有个前提:prefill 和 decode 必须在同一个 NVLink 域里。」

🖥 屏幕:滚到「同一个库在两个引擎上结论相反」下面那张五行表,先指前三行,再指后两行。

「这张表是两份 runbook 的试错记录,只看一件事:同一个库,换个引擎,结论就反过来。
前三行是 vLLM:NIXL 是唯一活路;换成 Mooncake 的搬运库,KV 是快了,整体输出反而少两成;套上 Dynamo,干脆握不上手。」

「后两行换成 SGLang,正好颠倒:NIXL 走以太网上的 RDMA,在 GKE 上调不通,请求超时;Mooncake 走 NVLink 在 R1 上反倒能用,K3 的 PD 尝试也选了这条。
所以别问哪个好,问这个引擎、这张网上哪条路真的通。共同点只有一条:同一个 NVLink 域里,KV 别出域。」

🖥 屏幕:滚到「8.3 混合模型的尾巴与 PD 坑清单」,fig-s8-hybrid-kv,先指左边注意力那排格子,再指右边的存折和红色那截,最后指最下面一行。

「混合模型还有个不报错的坑。KV 按块存,第四节讲过。老的 connector 只传装满的整块,不满一块的尾巴,让 decode 端自己补算。
看左边,注意力层。KV 像一本逐格记的账,尾巴那格本来空着,decode 端补算只是把空格填上,每格只记一次,账不变。」

「右边是 GDN 层,像存折余额。prefill 端算完时,尾巴那几笔早就记进余额里了;decode 端再补算尾巴,同一笔钱又入账一次,红色那截就是重复入账。
说到这儿点个名:GDN、Mamba 这类层存的是递归状态,固定大小,已经吃下了整段 prompt。多一截不是状态变大,是那几个 token 被喂了两遍。输出偏了,也不报错。」

「这张图是示意,层数取自 Qwen3.5-397B:六十层里四十五层 GDN,十五层注意力。
修法看最下面一行:全传,七格连同余额原样过去,decode 端一个 token 都不重算。tpu-inference 的 TPUConnectorHMA 就这么做。」

🖥 屏幕:展开「Qwen3.5 PD 的启动要点」折叠块,再指它上面那三条列表。

「启动时两件事:connector 选 TPUConnectorHMA,再显式加上 no-disable-hybrid-kv-cache-manager 这个开关。
全传的代价是什么?Qwen3.5-397B 在 TPU v7x 上,每个请求要搬三百多 MB;单并发、四并发时,每请求吞吐比不拆的单机低百分之五到八。」

「GPU 上还有一坑:SGLang 跑 K3 时,PD 的 decode 端每个请求一个状态槽,留不住前缀的状态,前缀缓存就失效了。
混合模型上 PD,尾巴和前缀两头都要查。」

🖥 屏幕:滚到「PD 坑清单。」,逐条指三条。

「再看三条坑。第一条,两边上下文长度要一致。只改了 decode 的 context-length,KV 布局对不上,握手失败。单条请求能过,压测才暴露。
第二条,失败策略两头疼。vLLM 的 kv_load_failure_policy 设成 fail,一次瞬时拒收,引擎就死;设成 recompute 稳了,可十二个 prefill 时每卡吞吐要交约百分之十七的税。」

「第三条,表面报错可能是假的。vLLM 开十四个 prefill 时,decode 所在的 pod 接连被驱逐;pod 是 K8s 里一组一起调度的容器。真因是 core dump 撑爆了临时盘。
这三条,和刚才表里第三行的出处,都在下面那个折叠块里,两份 runbook 都有行号。」

🖥 屏幕:滚到「8.4 拆了以后先比字,KV 够薄才敢走远路」,停在「正确性:拆了以后先比字。」下面的三条。

「拆完先比字,再比速度。PD 出错最常见的样子,不是崩,是能跑、通顺,但和不拆时不一样。
怎么比:温度设零,同一批 prompt,拆和不拆各跑一遍,逐个 token 对。」

💬 互动:问「对出来,第三百个 token 才分叉,是 bug 吗?」举手。期望答案:不一定,可能只是浮点差;分不清就降到并发一再比。⏭ 时间紧可跳:当设问念一遍,直接接下一块。

「看在哪儿分叉。头几个 token 就分叉,多半是 bug,比如尾巴被重算了,或者两边上下文长度不同,就是刚才那两条。几百个 token 以后才分叉,可能只是浮点差。
浮点差从哪来?kernel 要不是批不变的,同一个 prompt 跟不同的请求拼进一批,就会出不同的字,Thinking Machines 那篇讲推理非确定性的文章专门写过。」

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

🖥 屏幕:滚到「跨数据中心:KV 够薄才敢走远路。」,fig-s8-prfaas,先指两根橙柱,再指两根绿柱,再指红虚线,最后指底下那条绿虚线。

「第二个前提是 KV 别太胖。网络不是瓶颈这句话,只在同一个机房里成立。Moonshot AI 和清华有篇论文叫 PrFaaS,敢把 prefill 放到另一个数据中心、另一种卡上,靠的就是混合模型的 KV 薄。
每根柱是一台八卡 H200 吞三万二千 token 的长 prompt 时,每秒要往外送多少 KV。」

「橙柱是全注意力,绿柱是混合模型。论文把规模相近的两两配对,橙柱是绿柱的四倍到十三倍;这是论文自己的配对,不是同参数量的严格对照。
红虚线是整个 prefill 集群共用的一条跨机房专线,约一百 Gbps:全注意力只够并一两台,混合模型能并十几二十台,台数是本课一除推的。」

「底下那条绿虚线是案例里整个集群的平均出口,只用掉专线的一成多。还要挑请求,只把超过长度阈值的长 prompt 送去远端。
论文的案例是 Moonshot 自己的一万亿参数混合模型:拿一批 H200 去做 prefill,对比同样卡数全用 H20,吞吐多五成多、慢请求的首字少六成多。」

「这句要连着说:按同等成本算,吞吐只多一成半左右。而且这几个数是把实测 profile 代进吞吐模型推出来的,不是端到端实测。」

🖥 屏幕:滚到「8.5 一柜 NVL72 怎么拆:SGLang 的两次实测」,停在导语和下面那张表,先指 decode 行,再指 prefill 行。

「前面拆的是零件,最后看一套整机。SGLang 二〇二五年发了两篇博客,在 GB200 NVL72 上跑 DeepSeek V3 和 R1,PD 分离加第六节的大 EP。
一柜七十二张卡全在一个 NVLink 域里,KV 用 Mooncake 走 NVLink,正好守住刚才那条:KV 别出域。」

「表上先看两行怎么分卡。decode 两篇都是四十八张卡,注意力按 DP 切,专家按 EP 摊开,Part II 每张卡的 batch 挑到把 KV 正好占满。prefill 反过来,一个实例只用几张卡。一宽一窄,这个反差等会儿解释。
再看吞吐,都按每卡跟 H100 比:Part I 的 decode 是二点七倍;Part II 降了精度,prefill 三点八倍,decode 四点八倍。H100 那根柱还开了模拟 MTP,所以二点七倍偏保守。」

🖥 屏幕:滚到「两边是分开量的。」,再往下指「两个每卡数拼不成一套集群。」那一段。

「这些数是两边分开量的:测哪一边,就假设另一边资源无限。量 decode 时,先让 decode 每一步故意睡一会儿,请求在门口堆满再放开,量的是 decode 吃饱时的速度。
所以 Part I 的两个节点对十二个,只是测试用的配法。原文自己说,真部署更像十八个节点里六个 prefill、十二个 decode。」

💬 互动:问「两千进一百出,prefill 每卡每秒吞两万六千、decode 每卡出一万三千,两边的卡怎么配?」听两三个答案。期望答案:prefill 要的卡约是 decode 的十倍(本课推导)。多数人会按两个每卡数之比答 2:1 或 1:2。

「本课推一下:别比两个每卡数,比一个请求在两边各占多少卡·秒。两千个输入在 prefill 上要占约零点零七六,一百个输出在 decode 上只占约零点零零七五,prefill 要的卡是 decode 的十倍。
输出拉到一千字,两边才差不多一比一,这还没算上下文变长后 decode 每卡会降。」

「所以两个漂亮的每卡数,拼不成一套集群。配比跟着你的输出长度走,第九节细算。」

🖥 屏幕:滚到「Part II 补的招,机制第六节都讲过」,再指下一段「另外两招是降精度」。

「最后解释那个一宽一窄。Part I 只顾了 decode,prefill 写在待办里;Part II 补 prefill,有一招就是把 EP 反着缩到一个实例两到四张卡,放不下的权重卸到主机内存。其余几招第六节都讲过,不重复。
为什么 prefill 敢缩?本课的理解是,prefill 一次吞几千个 token,本来就算得饱,不靠大 EP 凑批,和 decode 正好相反。」

「另外两招是降精度和换 Blackwell 版 kernel:原文一个典型案例里,注意力和矩阵乘的 kernel 都快了将近一倍。
原文自己也提醒:高低精度两条路的差距,不全是精度带来的,辅助 kernel 和专家负载都不一样。」

🖥 屏幕:停在本节末尾「回到主线」那条绿框,再展开下面的「考考自己」。

「decode 每一趟搬多少没变,变的是它不再被 prefill 打断,才敢把 batch 攒满。开两个仓库这一步:DistServe 九成请求达标时,每卡能接的请求最多是不拆系统的七点四倍;Mooncake 线上多接一倍多。
留道题:PD 上线后首字比不拆时还高,TPOT 倒是稳了,先查哪一层?」

「先量 KV 传输带宽。只有每秒几百 MB,多半是退回了 cuda_copy,或者跨出了 NVLink 域;带宽正常,再看调度层有没有排队。
还剩一个问题:多了一批机器,P 和 D 各配几台,该不该拆。接下来第九节。」

⚠️ 这一节最容易跑偏的地方 ⚠️ R14 口径(台上取整,原数在此):313 = v7 bf16 2,307 TFLOP/s ÷ 约 7.4 TB/s(本课推);V3 每 token 挑 256 个专家里的 8 个 → 每专家 1/32;Mooncake「多接一倍多」= FAST'25 正式版 +115%(A800)、+107%(H800);Dynamo 1.0 是 2026 年 3 月。KV 一趟三段 ≈ 10 + 83 + 10 ≈ 100 ms,占 prefill 5–10%;1.04 GB = 2(K、V)× 62 层 × 8 头 × 128 维 × 8,192 token × 1 字节,100 Gbps = 12.5 GB/s → 83 ms;A4X(GB200)400 Gbps ≈ 21 ms、GB300 800 Gbps ≈ 10 ms(单卡单网卡,本课推)。配对后实测 7–167 GB/s,一趟 149 → 6 ms 多。三样配置原文:UCX_TLS=cuda_copy,cuda_ipc,tcp;UCX_CUDA_IPC_ENABLE_MNNVL=y;--enable-cumem-allocator(GKE 上 subblock 标签做 podAffinity)。Mooncake「少两成」= 并发 64 输出 1,333 对 NIXL 1,693(−21%,本课算);NIXL 走 RoCE 是 60 s 超时。全传「低 5–8%」= 1K 进 1K 出每请求约 349 MB,单并发 0.95 倍、4 并发 0.92 倍(XLA 缓存已热的第二轮)。recompute 税 = 12 个 prefill 时每卡 3,187 → 2,645。PrFaaS 四柱:Qwen3-235B 33.35、MiniMax-M2.5 59.93 对 Qwen3.5-397B 8.25、MiMo-V2-Flash 4.66 Gbps(32K 输入、一台 8×H200);「十几二十台」= 12–21 台;案例 32×H200 prefill + 64×H20 本地 PD 对 96×H20:+54%、P90 TTFT −64%。8.5:一柜 18 节点 × 4 卡;decode 12 节点 48 卡,Part II batch 1,408;prefill Part I 2 节点 8 卡、Part II 每实例 4 卡(低精度 2 卡);Part I decode 7,583、Part II prefill 26,156、decode 13,386 tok/s;卡·秒 2,000 ÷ 26,156 ≈ 0.076、100 ÷ 13,386 ≈ 0.0075;kernel「快将近一倍」= 注意力 1.8 倍、GEMM 最多 1.9 倍。
⛔ 别把 1.04 GB 说成 V4-Pro 的 KV:它是专题五那把统一尺子(Qwen3-Coder-480B 一条 8K prompt),只用来换算。
⚠️ 「每秒七 GB 到一百六十七 GB」是一个区间(7–167 GB/s),别报成单个数;runbook 自己的口径是单次传输 200–800 ms 降到 2–10 ms。
⚠️ 「哪个库好」不下结论:五行是两份 runbook 在两张网、两个引擎上的试错,换集群可能又不一样。
⚠️ 专线约 100 Gbps 是论文案例节直接写的(两集群 VPC 互联,aggregate 约 100 Gbps);13 Gbps 是 prefill 集群平均出口、占 13%。+54% 和「同等成本约 +15%」要一起说,别只报前一个。
⚠️ PrFaaS 的 4 倍、13 倍是论文自己的配对(原文 compared with dense models of similar size),不是「同代」,也不是同参数量严格对照。
⚠️ Splitwise 2.35 倍和 DistServe 7.4 倍别并列比高低:一个是同成本同功耗的吞吐(对现有不拆集群),一个是九成以上请求守住延迟要求时的每卡请求率(对 vLLM、DeepSpeed-MII);两个都是论文原文的 up to,最好的那组。
⚠️ 8.5 的 3.8/4.8 倍是低精度(FP8 注意力+NVFP4 MoE)对 H100,原精度是 18,471/9,087;2.7 倍那根 H100 柱开了模拟 MTP。两边每卡数是分开量的(另一边假设无限),「prefill 卡约是 decode 的 10 倍」是本课推导,台上要说是推的。
⚠️ 8.5 的缩 EP、卸载、NVFP4 分发、细粒度重叠,机制都在第六节,这里只点名不展开。
⚠️ 8.3 坑清单三条都讲;三条的出处在课件折叠块里,被追问行号翻那里。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「connector 是什么?」→ 推理引擎里在 prefill、decode 两端收发 KV 的插件,课件 0.2 词表就这么写;TPU 上用的是 TPUConnector,8.2 有。
🛠 GPU 老兵「Mooncake 和 NIXL 到底谁快?」→ vLLM 上 Mooncake 走 NVLink 加简易代理,KV 是快了,整体反而更慢:并发 64 输出 1,333 对 NIXL 的 1,693。换到 SGLang 又是 Mooncake 能用,所以只问这个引擎上哪条路通。
🛠 GPU 老兵「DistServe 那个 7.4 倍怎么读?」→ 九成以上请求守住 TTFT 和 TPOT 时,每卡能接的请求率最多是 vLLM、DeepSpeed-MII 的 7.4 倍(原文 up to,聊天负载对 DeepSpeed-MII 是 1.6–7.4 倍),是论文在自己负载上的数;拿到自己的集群要重扫配比,第九节。
💰 管预算的「要不要上 RDMA 网卡?」→ 一条 8K prompt 的 KV 约 1.04 GB:800 Gbps 网卡约 10 ms(本课推的),跌到每秒 200 MB 就要五秒多。先确认带宽真跑到设计值,再谈加卡。
🛠 GPU 老兵「拆完输出和不拆不一样,是 bug 吗?」→ temperature 0 逐 token 比:前几个 token 就分叉多半是 bug,几百个后才分叉可能是浮点差;分不清降到并发 1 再比(8.4)。
🛠 GPU 老兵「prefill 卸权重到 CPU 不会更慢吗?」→ 会拖慢计算;Part II 的判据是省下的通信要大过这份拖慢,GB200 的 CPU–GPU 通道 900 GB/s(双向)才让这笔账划得来,最佳规模看 kernel 和模型(8.5)。
⚙️ TPU 工程师「全传 KV 贵不贵?」→ Qwen3.5-397B 1K 进 1K 出每请求约 349 MB(README 原文);单并发每请求吞吐是不拆单机的 0.95 倍,4 并发 0.92 倍(8.3)。
💰 管预算的「prefill 放到别的机房、用便宜卡,能省吗?」→ 论文案例同等成本吞吐约 +15%;前提是混合模型 KV 薄、只送超过阈值的长 prompt,而且是吞吐模型推算的,不是实测(8.4)。

第九节 配几台、拆不拆(17′)计划 17′ · 含互动 14.6′ · 跳后 14.1′

🖥 本节主屏:课件 第九节 配几台、拆不拆 · 主图 fig-s9-prefill-sweep

🎯 这一节留一句:配比公式只给起点,要拿自己的负载去扫;看每卡吞吐先问分母;拆不拆跟着负载走。

🖥 屏幕:滚到「配几台、拆不拆:P:D 配比、AFD、EPD」,停在导语。

「还是开两个仓库。拆开上线第一天,你就会被问:prefill 配几台,decode 配几台?一配一叫 1P1D,二配一叫 2P1D。配错了,一边忙死,一边闲着。
在它前面还有一问:这个负载到底该不该拆。两件事都得拿自己的负载去量,别照搬别人的配比。」

🖥 屏幕:滚到「9.1 配比:先算一个起点」,fig-s9-pd-ratio-t5,先指上排混着做的七张卡,再指下排拆开的三张。

「专题五用 DistServe 的例子讲过怎么配。看图:同一套延迟要求下,每秒接住十个请求,混着做要七张卡,拆开只要三张。
为什么?一张卡两样都做,两头互相干扰,每秒只接得住一点六个。拆开以后两张专做 prefill、一张专做 decode,各按自己的上限跑,三张卡每张接三点三个,是混着做的两倍多。这几步算术是本课推的。
长 prompt 的业务多配 prefill,长回答的业务多配 decode。真实部署,要把一张接几个,换成量出来的吞吐。」

🖥 屏幕:滚到「配比公式:先算一个起点。」,指那条公式,再从上往下指表的四行。

「公式一句话:decode 每秒吐完多少个请求,就得有 prefill 每秒吞进这么多个 prompt。prefill 个数,约等于 decode 每秒完成的请求数,乘输入长度,再除以一个 prefill 每秒能吞的 token。
代 DeepSeek-V4-Pro 在 GB300 上、八千进一千出的官方数,表上四行一步步乘下来,约九点八个。」

「有个前提:官方那个 decode 吞吐是按每张 decode 卡读的,第二节讲过分母;要是按全部卡读,这张表就不成立。」

🖥 屏幕:停在「同一个部署有三个 prefill 个数」下面的三条。

「可同一个部署,出现了三个 prefill 个数。公式说九点八;官方高并发配方只配八个,比公式还少;runbook 早期自己扫出来是十四个。
runbook 实测的 prefill 单卡只有官方的八成多,照实测还要更多。」

「十四怎么定的?一个个往上加,看每张 decode 卡的输出:加到十四个以后,再加到十六只涨百分之二,喂饱了,就停在这儿。
所以公式只定起点,上下扫,取每卡输出不再涨的那一档。」

💬 互动:下一张图出来之前问「1P1D 再加一台 prefill,每张卡的吞吐会涨还是跌?」举手。期望答案:跌,可首字快了。多数人会猜涨。⏭ 时间紧可跳:题当设问念一遍,不举手,放图接「跌了」。

🖥 屏幕:滚到「多一台 prefill,换来的是首字。」,fig-s9-2p1d,先指左边「按机器看:花的卡换来多少字」,再指右边「按用户看:等第一个字等多久」。

「跌了。一份 B200 上的 DeepSeek-V3 报告,从 1P1D 加一台 prefill 变成 2P1D,十六张卡变二十四张。
左边按机器看:总输出几乎没动,只多百分之三点六;卡多了一半,每张卡就少了三成。」

「右边按用户看:平均首字少了将近三成;最慢那百分之一的请求,首字从十二秒多降到六秒多,砍掉将近一半。
同一组数,按每卡吞吐看是亏,按首字的延迟目标看是赚。加 prefill 之前先问:缺的是首字,还是每秒出的字?」

「两条口径要说清。首字是客户端测的,含排队;两边都关了 CUDA Graph,TPOT 偏高,所以不比 TPOT。
为什么吞吐不涨?固定并发压测下,一个请求从发出到收完要一分多钟,首字省下的那不到一秒摊进去,几乎看不出。第六节那组 decode 在等料,加了就涨;这组 decode 不缺料,多的卡只摊薄分母。」

🖥 屏幕:滚到「9.2 换个分母,不拆反而更好的时候」,fig-s9-prefill-sweep,先指蓝线,再指橙线,最后指图下那行「×10.4 对 ×2.2」。

⭐⭐⭐ 这一格是本节的主图,讲慢。

「再看分母。vLLM 跑 V4-Pro,decode 固定八张卡,每个 prefill 四张卡,prefill 一个个往上加,从一个加到十四个。
蓝线只除 decode 的卡,这是不少 PD 报告的默认口径:加到十二个 prefill,涨到起点的十点四倍,到十四个还在涨。」

「橙线是本课换了分母重算的,把 prefill 的卡也算进去:只涨两倍多,十二个就到顶,再加还往回掉。
两条线都说加 prefill 是杠杆,只是长短差了约五倍。蓝线的分母里没有 prefill 的卡,喂一个小 decode 的 prefill 越多,它越好看;算整机成本,看橙线。」

「所以配比到十二个就够了,再加只是稀释每卡产出。
这条曲线是历史实测,只看趋势。同一份 runbook 换成四千输入重扫,每个 prefill 喂的料约翻倍,曲线形状会随输入长度变。」

🖥 屏幕:滚到「不拆反而更好的时候。」,fig-s9-split-pod,先指左边 batch 128 最高的橙柱,再指右边同一根成了同组最矮,最后指蓝柱上那个涨幅。

「也有不拆更好的时候:prefill 和 decode 本来没怎么打架时,拆开是白付代价。
MiMo-V2-Flash 在 TPU v7x 上三种摆法:不拆、1P1D 各用两个 pod,2P1D 用三个。」

「左边看总吞吐:batch 六十四,不拆最高;batch 一百二十八,2P1D 最高。可它多用了一个 pod。
右边本课按 pod 一除,2P1D 比不拆低两成,成了同组最矮。拆了还赢的,只剩 batch 一百二十八的 1P1D,多不到一成;batch 六十四时,拆了怎么算都亏。」

「这里的吞吐含输入 token,压测不限速,README 自注只看趋势、没考虑延迟目标。」

🖥 屏幕:停在「单并发拆成 1P1D」那一句,再展开下面「两组 TPU 例子」的出处块。

「再看一个更极端的。Qwen3-Coder 在两台 v7x-8 上,一千进一千出,单并发拆成 1P1D:首字慢成将近三倍,输出只多一成多。
单并发时两段本来就不抢资源,拆了只付了那一趟的代价。这两组 TPU 例子都是单点测量,不是扫描。」

🖥 屏幕:滚到「9.3 决策树:三个问题」,fig-s9-decide,先指最上面的灰框,再按 ①②③ 往下指三个蓝框。

「该不该拆,先做一步,不算问题:开分块 prefill,第三节讲的,把长 prompt 切成小块,夹在 decode 步之间。然后问三问,答否就停。
第一问最常被跳过:开了分块,长 prompt 一进来,别人出字还卡一下吗?没有,就不拆,分块就够;拆了多一趟传输、多一套机器,换不回东西。」

「第二问:KV 能走快线吗?同一个 NVLink 域,或者同一个 TPU 切片里传。不能就先停,除非 KV 够薄,或者只把长 prompt 外送,就是 8.4 那篇论文的做法。出了快线,KV 越厚越慢。」

「第三问:拆完,延迟目标还有缺口吗?没有就停,配比够了,不缺就别再加机器。有缺口,看哪个先破:缺首字加 prefill,缺吞吐加 decode。配比用 9.1 的公式起个头,再往先破的那边加。
图上故意没画阈值:多长算长、多严算严,没有通用答案,要拿自己的负载量。」

🖥 屏幕:滚到「9.4 再拆一层:AFD 与 EPD」,fig-s9-afd-t5,先指上面注意力机和专家机之间的来回箭头,再指下面三条道的时间格,盯住小批 A。

「decode 里还能再拆一层。专题五讲过:注意力和专家拆到两批机器上,叫 AFD。左边 M 台只算注意力,右边 N 台只放专家。
专家那边同时接好几台注意力机的 token,凑出来的 batch 比单台大得多,两边的机器数也能分开调。」

「代价是每一层都要跑一趟来回:注意力算完,把 token 发给专家,叫 M 到 N;专家算完送回来,叫 N 到 M。
为了藏住这来回,把一批请求切成三个小批轮着跑。盯住小批 A:第零格算注意力,去半格,专家一格,回半格,第三格又轮到它。单程超过半格,一圈就超过三格,得四个小批。」

🖥 屏幕:滚到「字节 2025 年的 MegaScale-Infer」那一段。

「论文的数不错。字节二〇二五年的 MegaScale-Infer,报告每卡吞吐最多是对照系统的一点九倍。阶跃星辰的 Step-3 在字距五十毫秒的约束下,每卡峰值比论文拿来对照的 DeepSeek-V3 高七成多,本课一除的。
可那个 DeepSeek 的数是人家自己公开的 profile,不是 Step-3 重测的;模型不同,Step-3 这档还用了 FP8 注意力,差距不能全记给 AFD。TPU 上,本课没找到公开的 AFD 实现。」

🖥 屏幕:fig-s9-afd-ascend,先指左边三行小人,再指中间那行的橙柱,最后指下面那行的绿柱。

「开源实现没这么顺。vLLM 的 AFD 是外部插件,主仓库的提案已经因为不活跃被关了。插件博客在昇腾 910C 上跑 DeepSeek-V3.2,一个小人是一块 die,这里当一张卡数。
第一行不拆,每块两样都干,当基准。」

「中间一行拆了,专家那边吃不饱,每块反而比不拆少百分之五左右。
下面一行,专家不动,注意力再加一截,每块反倒比不拆多一成多。同样拆开,橙柱亏、绿柱赚,差的只是配比。」

「配比是关键:作者说绿柱那组专家侧还有余力,再加注意力可能还涨。
可只能看趋势:实验把专家路由换成了强制均衡,还用小部署模拟大规模。所以配比一错,拆了比不拆还慢;配对了,也别拿这几个数去和论文数比高低。」

🖥 屏幕:滚到「EPD:多模态把编码也拆出去。」,逐条指三条。

「还有一种拆法叫 EPD,给多模态模型。它在 prefill 前要把图片、视频编码成 token,图一多,就跟 prefill 抢资源。
做法是编码器单独一批机器,视觉 token 交给 prefill,KV 再交给 decode。」

「论文跟不拆编码的系统比,显存、batch、首字都好了一大截,首字最多少七成;论文报的都是上限,别当典型值。
什么时候值得?请求带很多图,或者图很大的时候;纯文本用不上。」

🖥 屏幕:停在本节末尾「回到主线」那条绿框。

「开两个仓库这一步的账:只数 decode 卡涨十倍多,全算上只涨两倍多;AFD 让每个专家一趟分到更多 token。拆不拆、怎么配,看负载,不看潮流。
拆完还剩一个问题:DEP、PD、AFD 摆在一起,先定哪种拓扑,再调哪些参数。接下来第十节。」

⚠️ 这一节最容易跑偏的地方 ⚠️ R14 口径(台上取整,原数在此):DistServe 13B/单张 A100:混着 1.6、只 prefill 5.6、只 decode 10 req/s;2P1D = min(2 × 5.6, 10) = 10 → 每卡 3.3(本课推)。配比表:8 卡 × 11,200 ÷ 1,024 ≈ 87.5 req/s → × 8,192 ≈ 71.7 万 tok/s;一个 prefill 4 卡 × 18,200 ≈ 7.28 万 → ≈ 9.8。runbook 实测 prefill 单卡峰值 15,196(官方 83%);扫描 8/14/16 个 prefill 时每张 decode 卡 6,788/8,809/8,993。B200 那组:每台 8 卡、SGLang+NIXL、并发 128;总输出 1,118.8 → 1,159(+3.6%),每卡 69.9 → 48.3;平均 TTFT 2.4 → 1.73 s(−28%);「一分多钟/不到一秒」= 平均端到端约 65 s、首字省 0.67 s。扫描:蓝线 307 → 3,187(×10.4),橙线 204 → 455(12 个),14 个回落 415;2026-07-24 的历史实测。MiMo:每 pod 4 颗芯片、16K 进 4K 出;总吞吐 batch 64 不拆 11.7K、batch 128 的 2P1D 15.3K;每 pod 6.39K/6.82K(+6.7%,README 写约 6.8%)/5.10K。Qwen3-Coder 单并发 1P1D:TTFT 中位 95 → 281 ms,输出 +12%。Step-3「七成多」= 4,039 ÷ 2,324 ≈ 1.74(本课算;Hopper、50 ms TPOT、4K 上下文)。昇腾:不拆 64 die 232.6;48A16F 220.3(−5.3%,32K −10%);64A16F 共 80 die 258.9(+11.3%,32K +9%),16K 输入。EPD「一大截」= 显存最多降到 1/15、batch 最多 22 倍、TTFT 最多 −71%。
⛔ 别拿「官方配 8 台」当公式验证成功:估算约 9.8 台,官方配得更少;runbook 实测要 14 台,它量的 prefill 单卡只有官方数的 83%。要带走的恰恰是「公式只是起点」。
⚠️ B200 那组 TTFT 含排队;两边都关了 CUDA Graph,没比 TPOT。
⚠️ prefill 扫描的 ×10.4 / ×2.2 是同一组实测换了分母:橙线是本课推导(output ÷ 全部卡),蓝线是 runbook 原口径;曲线是 2026-07-24 的历史实测。
⚠️ AFD:TPU 上没找到公开实现;MegaScale-Infer 1.90×(对当时最好的方案,up to)、Step-3 4,039(峰值那一分钟,长期平均 3,910;对照的 2,324 是 DeepSeek 自己公开的 H800 profile 峰值)是论文数,别和插件实测比高低;昇腾那组是强制均衡路由 + 小部署模拟(48A16F 模拟 192A64F),只看趋势。
⚠️ EPD 的三个数(1/15 显存、22 倍 batch、TTFT −71%)都是「最多」,对比的是不拆编码的系统,论文 arXiv 2501.05460 的上限,别报成典型值。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「1P1D、2P1D 是什么意思?」→ 几组 prefill 配几组 decode:2P1D 就是两组 prefill 喂一组 decode。
🛠 GPU 老兵「配比公式的数从哪来?」→ decode 每秒要的 prompt token,除以一台 prefill 每秒能处理的;V4-Pro 官方数代进去约 9.8 台,实测 prefill 只有官方的 83%,所以要更多。
💰 管预算的「拆开是不是多花钱?」→ 看延迟目标:B200 那组多一台 prefill,每卡掉三成,最慢那档首字从十二秒降到六秒。没有首字压力,MiMo 那组 batch 64 时不拆最高,按总量、按每 pod 都是;batch 128 总量是 2P1D 高,但它多用一个 pod。
🛠 GPU 老兵「EPD 在 TPU 上有吗?」→ 课件没给 TPU 上的 EPD 数;9.4 只有论文数和适用条件(多图、大图才值得)。
💰 管预算的「并发不高,要不要上 PD 分离?」→ 先别:Qwen3-Coder 单并发拆成 1P1D,首字中位 95 → 281 ms,输出只多 12%;两段本不抢资源就是白付代价。9.3 三问答「否」就停。

第十节 先选拓扑,再调参数(15′)计划 15′ · 含互动 13.7′ · 跳后 12.7′

🖥 本节主屏:课件 第十节 先选拓扑,再调参数 · 主图 fig-s10-lens

🎯 这一节留一句:换一次拓扑,抵得上把参数调遍;报一个提升百分比,先写清分母。

🖥 屏幕:滚到「先选拓扑,再调参数」,停在导语。

「第六到九节换的,其实都是拓扑:卡怎么分组、组和组之间走哪条线。换一种,调好的参数就得从头再找。
先定车走哪条路、一趟捎多少人,再拧参数;参数怎么拧,也出不了路定的上限。」

🖥 屏幕:滚到「10.1 切法先定:先看分母,拓扑是硬约束」,fig-freq-t5,先指上面五根横条,再指下面两种线的带宽。

「专题五讲过一条规则:通信勤的切法放在快线里,懒的才能跨慢线。图上 TP 和 EP 一步要通信近两千次,DP 只有一次。这是训练口径的示意;推理只有前向,FSDP 和梯度那几行不适用。
下面两种线:GB300 一柜之内走 NVLink,出了这一柜走网卡,带宽差九倍。」

💬 互动:下一张图出来之前问「有份记录说:调参 +45%,换拓扑 +347%。你先问什么?」等台下说出「分母」。期望答案:分母,各用了几张卡。⏭ 时间紧可跳:那句记录(+45%、+347%)照样念出来,不等台下,直接接「先问分母」回扣第二节;下一块台词要用到这两个数。

🖥 屏幕:fig-s10-lens,先指左边总吞吐的三档柱子,再指柱下的小方块,最后指右边每卡那一栏。

⭐⭐⭐ 这一格是整节论点所在,讲慢。

「先问分母。这两个数出自 V4-Pro 的部署记录,GB300、vLLM、四千进一千出,都是总吞吐。
左边三档:从 1p1d 起点出发,3p1d 调到最好,多百分之四十五;换成 dep8,多百分之三百四十七。」

「可看柱子底下的小方块,一个方块一张卡,空心是 prefill,实心是 decode。三档用的卡,从八张一路涨到二十张。
右边只换了分母,按每卡算:3p1d 最好那档,反而比起点少百分之二十八。那百分之四十五,大半是 prefill 从一台加到三台、卡数翻倍换来的。」

「卡数不变、只调并发那一下,才是纯调参:同为 3p1d,并发翻一倍,总吞吐涨二十几个点。
换拓扑在两种口径下都赢。同样的并发,dep8 每卡是 TP4 的两倍多,第六节拆过为什么。dep8 再把并发拉到三倍,每卡最高,可首字要等一分半,已经出了交互档。」

🖥 屏幕:滚到「拓扑约束是硬的。」,fig-s10-wire,先指左图最左一组(c=1)两根柱,再指 1K/1K c=4、c=16 两组,再指 8K/1K 两组,最后指右栏两种连法。

「拓扑约束是硬的。Qwen3-Coder-480B,单机 v7x-8 跑 TP8 作对照;两台 v7x-8 拼起来,十六个 device 跑 TP16。柱子往下长,越长越慢。
只有一个请求时,不管走哪条线,都慢两成上下。」

「并发一高就分开了。一千进一千出、并发十六:走数据中心网络慢六成多,编进同一个 ICI 切片只慢一成半。
八千进一千出那组,并发四时两种差不多;并发十六,走 DCN 也慢五成多。」

「右栏是两种连法:每台机器里四颗芯片之间都是粗管 ICI。上面那种,两台之间只有一根细管 DCN;下面那种,两台编进同一个切片,机间也接上粗管。
为什么差这么多?张量并行每层都要把各卡的部分和加一次,线一慢,每出一个字就层层多等。」

「就算走 ICI,两台加起来的总输出也不如一台单机。原记录的建议是开两份单机,做数据并行。
GPU 上同理。V4-Pro 的 SGLang 部署要求十六个节点都在同一个 NVL72 域里:PD 之间传 KV 走 NVLink,跨域就退化成 RDMA,原文只说显著变慢。」

🖥 屏幕:滚到「TPU 上,device 编号就是拓扑。」,fig-s10-rank,从左到右指三栏。

「TPU 上再记一条:device 编号就是拓扑。JAX 的 mesh 是一张 device 列表排成的网格;列表怎么排,决定了沿哪一轴通信时,哪几个 device 一组。
图上四颗芯片连成环,每颗两个 device,一共八个;灰色粗线是芯片之间的物理链路。」

「左边按物理相邻编号,下一个都在隔壁,每步一跳。
中间同样八个 device,顺序打乱:零号在芯片零,一号在对角的芯片二,两颗之间没有直连,数据要经过芯片三绕两段才到,还会和别人抢同一条线。」

「右边最危险:各进程算出来的顺序不一样,A 等 B,B 等 C,C 又等 A,第一次集合通信就卡死,还不报错。这一栏是机制推演,不对应哪次公开事故;真实 v7 是三维 torus,图是简化的。
所以 mesh 交给 mesh_utils 的 create_device_mesh 按物理位置生成;跨切片用 create_hybrid_device_mesh,把 ICI 和 DCN 分成两层。」

🖥 屏幕:滚到「10.2 最小切片、容量与对照实验」,停在「最小切片怎么定。」,fig-s10-slice,先指最上面的灰色权重条,再从上往下指六行,最后指四条竖虚线。

「一个引擎最少几个 device?先算纸面账:权重加 KV 加激活值,激活值就是中间结果。拿 DeepSeek-V3 在 TPU v7 上算,口径同 4.1,全是本课推的。
FP8 权重六百二十五 GiB,是地板。账按 device 记:一颗芯片是两个 device,每个可用约九十五 GiB,再留一成给激活值。」

「看六行,只看两头。最短最少那行,四千上下文、六十四并发,纸面七个半 device,取八个,四颗芯片就够。
可切片是成倍跳档的,八、十六、三十二、六十四。纸面只多出一点,也得跳到下一档:中间四行都落在十六个 device,八颗芯片。」

「最长最满那行,十二万八千配二百五十六,纸面三十三个出头,刚过三十二,就得取六十四个,三十二颗。
权重是地板,KV 决定往上加多少。」

「那一行里 KV 是权重的三点五倍。要装下只有三条路:加芯片;KV 存 FP8,第十二节末尾讲;冷 KV 下放主机内存,第四节讲过。
DCP 帮不上。这里 KV 本来就只存一份,用的是 DP 注意力;DCP 只是把一条序列摊开,而最长的一条也才八 GiB 多。」

🖥 屏幕:停在「本课推导的边界」那个黄框,连同它上面那段实测。

「还有个反转:纸面最少八个 device,也就是四颗,实测却放不下。R1 和 V3 同结构,光 FP8 专家每个 device 就要一百零一点八 GB,越过上限,比按八份均摊多约二十 GB,原记录没拆原因。所以 v7x-8 上实际用 FP4,第十二节讲。
纸面账只给下限,激活值预留一成也是假设;用一次真实启动,看实测的 HBM 峰值。」

💬 互动:下一张图出来之前问「一套机器,并发八测出来每秒八百五十四个 token。它能扛多少?」等两三个答案。期望答案:测不出来,要一路往上扫。⏭ 时间紧可跳:当设问念一遍,放图。

🖥 屏幕:滚到「容量别拿小并发估。」,fig-s10-conc,先指最左的红点和灰虚线,再沿曲线从左指到见顶那一档,最后指虚线右边那段平线。

「R1 在 GB300 上用 SGLang 跑 3P2D,二十张卡,一千进五百一十二出。部署记录先估了这套 DEP8 decode 能扛约二百八十八个并发,那是估算,不是实测;起初却只拿并发八去量。八除二百八十八,只用到约百分之三。
并发八时,decode 每一趟只分给八个请求,测到的是这套机器闲着时多快,不是它能扛多少。」

「一路往上扫,扫到五百一十二才见顶,是并发八时的十二点五倍。
可过了二百五十六,吞吐只再涨三个点,首字却从十二秒拖到半分钟。停在哪一档,由延迟目标定,不由吞吐峰值定。」

「还有个口径:横轴是压测端设的并发,不是服务端实际的批大小。最右那档,实际只跑到四百多,其余在排队。」

🖥 屏幕:滚到「对照实验的纪律。」,指两条。

「两条纪律。先固定拓扑,再扫参数:拓扑一变,瓶颈就换边,第六节讲过;错拓扑上调出的最优参数,搬不到对的拓扑上。
一次只动一个变量:同时改并发和 prefill 台数,涨了说不清是谁的功劳,刚才那个百分之四十五就是例子。」

🖥 屏幕:滚到「10.3 五步选法落到两个例子」,fig-s10-gates,从第一关往下逐行指,左列右列各指一下。

「专题五那五关,推理时照样走一遍。左列 DeepSeek-V3 跑在 TPU v7 上,右列 DeepSeek-V4-Pro 跑在 GB300 上。
第一关,装得下:左边纸面四颗够,实测 FP8 放不下,用八颗,或者专家换 FP4;右边一个四卡节点就放得下,vLLM 跑通过 TP4。」

「第二关,快线多大:左边是一个 ICI 切片,TP 不跨 DCN;右边是一个 NVL72 域,七十二卡,SGLang 部署要求全部节点同域。
第三关,序列:左边 KV 总量大,但单条装得下,DCP 帮不上;右边只有一个 KV 头,TP 只会复制 KV,改用 DEP,第六节讲的。」

「第四关,PP 是流水线并行,按层切给几组卡:两边都不用,左边一个切片就放得下。第五关,DP:左边剩下的卡开副本,每份留在自己的切片里;右边先定 P 比 D,再按目标用户数加 decode 副本。
五关里只有 PP 一关答案相同。没有哪列更对:硬件和模型变了,答案跟着变。每一格是本课按部署记录归纳的。」

🖥 屏幕:停在本节末尾那条「先选拓扑,再调参数;比较时先看分母」的落点。

「这一节的账:换拓扑,同并发每卡是 TP4 的两倍多;卡数不变只调参,总吞吐涨二十几个点。拓扑定了那一趟搬运走哪条线、能分给多少人,参数只在这个上限底下挪动。
第五到第七节是车上多坐人,第八到第十节是开两个仓库。可这些都靠把 batch 做大;交互档压住 batch 时,一趟还是只出一个字。接下来第十一节,投机解码。」

⚠️ 这一节最容易跑偏的地方 ⛔ 别把 +45% 讲成调参的功劳:大半是卡数翻倍换来的,每卡反而跌了(−28% 是本课现算)。整节论点靠这一下拆开。
⚠️ 「每卡两倍多」是同并发 512 的 2.09 倍;dep8 拉到并发 1,536 的 2.47 倍代价是首字 95 s,别只报 2.47。
⚠️ 10.2 最小切片是纸面下限:实测 FP8 在 v7x-8 上放不下(约 101.8 GB/device 超 94.75 GiB)。128K × 256:KV 约 2,196 GiB 是硬账,三条路是加芯片、KV 存 FP8、冷 KV 下放;DCP 帮不上:KV 本就只存一份(DP 注意力),一条 128K 才 8.58 GiB。
⚠️ 约 288 并发是估算不是实测;8 ÷ 288 = 2.8%,原文写约 3%。
⚠️ R15 口径(台上撤下的原数):通信次数 TP/EP 约 1,920、PP 16、DP 1(训练口径示意);NVLink 每 GPU 双向 1,800 GB/s 对网卡 200(9 倍);三档总吞吐 14,563 → 21,100(+45%)→ 65,132(+347%),卡数 8/16/20;每卡 1,820 → 1,319(−28%);纯调参并发 256 → 512,总吞吐 +28%;dep8 并发 1,536(512 的 3 倍)首字 95 s(≈一分半)。TP16 慢多少:c=1 DCN −22%/ICI −21%;1K/1K c=4 −44%/−19%,c=16 −63%/−15%;8K/1K c=4 都约 −16~17%,c=16 DCN −54%(ICI 未测);两台 ICI 513.8 对单机 602。最小切片:每 token KV 70,272 B,每 device 94.75 GiB、留一成按 85.275 GiB;六行 642 GiB/7.53 → 8,694/8.13 → 16,…,2,821 GiB/33.08 → 64;KV 约 2,196 GiB;一条 128K 8.58 GiB。容量扫描:32 → 4,635,128 → 6,878,256 → 10,390,512 → 10,715(12.5 倍),256 之后 +3%,首字中位数 12 → 30 s;512 档实际并发 416。V4-Pro 官方权重 806 GB、vLLM FP8 版 832 GB。
⚠️ 五关那张表每格是本课归纳,不是某份 runbook 的原表。图里格子写的「10.3」「10.5」是旧小节号,对应现在的 10.1、10.2。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「ICI 和 DCN 是什么?」→ ICI 是一个切片里芯片之间的直连线,DCN 是切片之间走的数据中心网络,慢得多。
🛠 GPU 老兵「GPU 上对应的是什么?」→ NVLink 域:GB300 NVL72 一柜 72 块是一个域,出域走网卡;SGLang 的部署要求全部节点在同一个域。
💰 管预算的「先调参还是先换拓扑?」→ 先拓扑:同一组 V4-Pro 的数,换拓扑同并发每卡两倍多;卡数不变只调并发,总吞吐涨二十几个点,两个数口径不同别直接比。
🛠 GPU 老兵「+347% 是你们自己测的吧?」→ 是,本仓库公开 runbook 实测,非厂商数,台账有行号;但它是总吞吐,卡数 8 对 20,按每卡算对 1p1d 起点是 1.79 倍(10.1)。
🧑‍🎓 新人「v7x-8 是 8 颗芯片吗?」→ 不是:一颗 v7 芯片 2 个 device,v7x-8 是 4 颗芯片、8 个 device;每 device 的数是每芯片的一半。
🧑‍🎓 新人「那个约 288 并发是怎么来的?」→ 部署记录的估算,不是实测;正因为只是估算,才要一路扫到吞吐见顶。
⚙️ TPU 工程师「两台 v7x-8 拼 TP16 划算吗?」→ 不划算:Qwen3-Coder 跨 DCN 并发 16 慢 63%;同一 ICI 切片两台总输出 513.8,也不如单机 602;原记录建议两份单机做 DP。

第十一节 投机解码(32′)计划 32′ · 含互动 30.3′ · 跳后 29.3′

🖥 本节主屏:课件 第十一节 投机解码 · 主图 anim-spec

🎯 这一节只留一句:搬一趟权重,猜对几个就出几个;人一多、温度一错,白送的就没了。

🖥 屏幕:课件 s十一,停在节标题下那段导语,先别往下滚。

💬 互动:先问一句「让一个小模型先猜,猜错了,会不会比不开还慢?」听两三个答案,不揭晓,放动画。期望答案分两半:字数上不会少,最差也出一个字(第 2 步讲完揭晓);时间上可能更慢(11.2 讲 DEP 那段揭晓)。

「第三到第十节,大多在把 batch 做大。可交互档定了每人每秒要出多少字,batch 不能无限加;推理模型又一答几千字。一步一字,成了剩下的硬上限。
开场那条链上,环三补的就是它。还是车上多坐人,坐上来的是同一个人后面的几个字。
投机解码先便宜地猜几个字,再让大模型搬一趟,一次验完。」

🖥 屏幕:滚到「11.1 先猜后验:收益账」,指第一句「大模型把草稿当一段输入」。

「先说验是怎么验的。大模型把草稿当成一段输入,跟 prefill 读 prompt 一样,一步把每个位置都算一遍,算出每个位置它自己会写的字,再逐个对照。
⭐ 关键在这一步只搬一趟权重。小 batch 时一步的时间几乎全花在搬权重上,多验几个位置,本该几乎不加时间。」

🖥 屏幕:anim-spec。先取消勾选动画下方的「连续播放」(默认是勾上的,勾着它不会停),点「⟲ 重来」回到开头,再点「开始」;先闭嘴,等它第一次自己停住(第 1 步完成)再开口。

「第一步,小模型一个接一个猜了四个字,每个都很快,用时条上是四小格紫色。大模型搬一趟,一大格灰色,五个位置一起算出来。
从左往右比:前两个猜对,第三个错。
错的位置,大模型这一趟本来就算出了自己的字,直接换上,后面全扔。问号那两格,前面已经错了,算了也作废。
出三个字,大模型只搬了一趟。」

🖥 屏幕:点「下一步」,等动画第二次自己停住(第 2 步完成)。讲完可以重新勾上「连续播放」让它循环。

「第二步四个全对,第五个位置大模型本来就算了,白送一个,出五个字。
⭐⭐ 规则:碰到第一个错就停,猜对几个出几个,再加大模型自己的一个。所以最差也出一个字:开头那道题,字数上不会比不开少。」

「⛔ 有人会担心:小模型猜的,会不会把答案带偏?不会。
动画是温度零的贪心比对,一样就收。真要随机采样,按标准的拒绝采样来收:大模型觉得这个字的概率比草稿高,就一定收;低,就按两者的比例收;被拒了,从两者概率的差里重新抽一个。
⭐ 这样收下来,输出分布跟大模型自己一个一个写完全一样:改速度,不改答案。」

🖥 屏幕:往上一点到 fig-s11-step,先指上面普通 decode 那行,再指下面投机那行,最后对齐两行的灰条。

「同一件事换成时间线看。上面一行是普通 decode:每一步搬一遍权重,出一个字,三十格时间出三个字。
下面一行:紫色小格是草稿,灰色大格是验证,验证比普通一步稍长一点。第一轮出三个,第二轮出五个,同样三十格出了八个字。
⭐ 对齐两行的灰条:投机这行少搬一遍权重,字反而多。格子长短是举例,不是实测。」

「⛔ 图上那句「不会比不开更少出字」,说的只是字数。
要是验证那一步明显变慢、草稿又总猜错,每步只出一个字,却每步都比原来慢,墙钟时间照样会变长。开头那道题的后半句,11.2 揭晓。」

🖥 屏幕:滚到「收益账:接受长度 ÷ 一步变慢了多少。」,停在这一行。

「所以收益账就一个除法。
⭐ 每步平均出几个字,说到这儿点个名,叫接受长度。用它除以一步变慢了多少倍,就是每个字快了多少倍。
分子靠草稿猜得准,分母靠验证别太贵。下面两张图,一张看分母,一张看分子和分母一起。」

🖥 屏幕:fig-s11-bytes,先左半边:指浅蓝那段,再指深蓝那段从验一个到验八个怎么变长。

「车装多了开得慢点,先看慢多少。左边是本课按 DeepSeek-V3 的配置推的,FP8 每个参数一字节。
浅蓝是每个 token 都要经过的部分,一百七十亿参数上下,验几个都只读一遍,白送。
深蓝是路由专家。每个 token 挑自己的八个,验得越多,碰到的专家并起来越多:验八个要读的,是验一个的四点四倍。」

「⛔ 所以 MoE 上多验几个不是白送的。
不过这根深蓝是偏高的估计:推的时候假设每个 token 独立、均匀地挑专家;实际路由不均匀,相邻的 token 常挑同一批,碰到的专家会少一些。
顺带一个外部锚点:这样推出的每 token 激活三百七十五亿,跟技术报告的三百七十亿差不到百分之二,说明这套账算得对。」

🖥 屏幕:同一张图移到右半边,先指上面不开投机那条,再指开投机那条和它带回的方块。

「右边是实测:有人在 GB300 上量过 Kimi K3,八张卡、一个人用。
开投机,一趟慢到一点四五倍,可平均带回将近七个字。
⭐⭐ 一除,每个字快到四点八一倍。一趟慢多少,是拿每字间隔乘接受长度反推的。」

「⛔ 一点四五倍别全算到多读的专家头上:八张卡跑一个人,一步里除了读权重,还有通信、还有 kernel 之间的空转。」

🖥 屏幕:滚到「11.2 收益会缩,温度会骗人」,指「收益会缩:并发、上下文、DEP。」这一行,再下到 fig-s11-conc,从最左那根柱一路往右。

「可这笔便宜会缩。头一个原因是人多。
人一少,工位大半闲着,多验几个位置是用闲着的工位算的;人一多,工位先忙满,草稿里每个字都得真算一遍,验证就不再白送。
看柱子:K3 一个人用时四点二二倍,人越多柱子越矮,到六十四个人只剩一点七四倍。」

「⭐ 缩归缩,六十四个人那一档还是赚的:出处里记着,那一档开投机的每字间隔只有不开的四成,吞吐和延迟同时变好。
⛔ 一个人那根四点二二,比刚才的四点八一小一截:刚才那个是每字间隔,这里是端到端吞吐,里面有一段 prefill,投机管不着。」

🖥 屏幕:同一张图,停在最右边单独那根柱。

「第二个原因是上下文拉长。同样一个人用,上下文从四 K 拉到三十二 K,只剩一点三二倍。
按理验证不该因此变贵:不开投机时,每字间隔几乎没涨;多验的几个位置读的又是同一份 KV。
原因没人拆过,本课推测是两条之一:要么上下文长了猜中的少了,要么草稿自己读长 KV 变慢了。」

🖥 屏幕:滚到「DEP(第六节)本为大 batch 而设」,停在这一段和下一段。

「第三个原因最极端:DEP。它本来就是为大 batch 配的,高并发时工位早忙满了,投机成了纯开销。
有人在八张 B200 上跑 DeepSeek-V4-Flash,用 vLLM、DEP8 开 MTP,接受率五成多,十档并发全部变慢,连只有一个人用的那一档也慢一成二。
⭐⭐ 开头那道题的后半句:时间上,会更慢。」

「⛔ 但这个结论不能搬到别的配置:B200 那套是 EP 加 DP 的高吞吐配法,只用 TP 的低延迟配法是另一回事。
还有一种反向:GB300 上的 V4-Pro,把 MTP 从猜一步加到两步,单步慢了四成,decode 峰值跟着掉,端到端吞吐反倒涨了近三成。
真实负载 batch 多半没那么大,白送的那部分还在。」

🖥 屏幕:滚到「温度:压测怎么发,结果就怎么变。」,再下到 fig-s11-temp,先指题目和草稿的「好」,再指上一行温度一点零。

「最后一个坑最阴。先说道理:草稿怎么抽,要跟请求的温度对上。
这张图拿对答案打比方。题目是下一个字填什么,最可能的是「好」。贪心的草稿永远交最可能的那个字。
上一行温度一点零:大模型每次掷骰子定标准答案,大多掷出别的字,草稿对不上,被扔掉。」

「⛔ 别误会成猜错了:草稿交的是最可能的字,按理是猜得最好的;是标准答案自己在掷骰子。
理论上,这时候接受率就等于大模型给这个字的概率,会降,但不归零。
那压测怎么会撞上它?压测工具不发温度,服务端就按模型自带的默认值一点零来采样。」

💬 互动:「同一套服务,压测工具少发一个温度参数,吞吐能差几倍?报个数。」听几个数,不点评,直接揭晓。⏭ 时间紧可跳:偏猜数,题当设问念一遍,不等报数,直接接「三倍」。

🖥 屏幕:同一张图,指上一行的接受率和吞吐,再指下一行温度 0。

「三倍。有人在 GB300 上压 V4-Pro,草稿是贪心的 DSpark。不发温度,接受率只剩百分之一出头。
下一行温度零:骰子永远停在最可能的那个字,接受率回到三成多,吞吐是上一行的三点一倍。」

「百分之一出头,比理论值还低得多,为什么?这是本课推的:接受率是收下的除以猜的。这套每步猜七个,第一个被拒,后六个跟着作废,一步就记七个没收。
⛔ 两家压测工具还不一样:vLLM 自带的压测不发温度,另一个常用的压测脚本把温度写死成零。同一套服务,换个工具数就差三倍。」

「那温度一点零就没救了吗?不是。K3 的官方压测就用温度一点零,它的 DSpark 草稿是按概率抽的,草稿自己也掷骰子,照样对得上:官方给的参考接受长度,写代码将近五个字,写文章两个半上下。
⭐ 所以要对上的是草稿的抽法和请求的温度,不是非得温度零。」

🖥 屏幕:停在黄框「接受率掉了不会报错」。

「⭐⭐⭐ 这个框是这一小节的落点,讲慢。
接受率掉了不报错,只让每字间隔慢慢变长,看起来就像机器变慢了。
线上要把接受率和接受长度当一级指标告警;跨框架比数,先对齐两边发没发温度。」

🖥 屏幕:滚到「11.3 草稿从哪来」,指第一句「各家报的倍数口径不同,不能横比。」,再从上往下指那六行年份。

「草稿从哪来?先挡一句:⛔ 下面每一家报的倍数,都是在自己的模型、自己的负载上测的,口径不同,不能横比。
二〇二二年底,Google 提出投机解码,DeepMind 隔年初独立提出:另找一个独立的小模型当草稿。」

「二〇二四年一月,草稿开始长在大模型身上。Medusa 在大模型上加几个解码头;EAGLE 拿大模型的隐状态来猜,就是出字前那一层的向量。
同年十二月,DeepSeek-V3 的 MTP:预训练时就多带一层,往后多猜一个字,第二个字能收下八成五到九成。⭐ 草稿训进主模型,从此成了主流。」

「二〇二五年三月,EAGLE-3 再推一步,等会儿展开。二〇二六年二月,DFlash 让小草稿一趟并行出一整块;七月,DeepSeek 的 DSpark 拿它当骨干再加两样东西,前面 K3、V4-Pro 用的就是它。
各家自报的倍数都在课件那几行里。」

🖥 屏幕:fig-s11-tree,沿时间轴从左往右扫,最后指下面那条侧枝 Prompt Lookup。

「这张图把刚才那串排到时间轴上,⭐ 故意不画倍数,因为不能横比。
主干只看一件事:草稿离大模型越来越近。从独立小模型,到头上加几个头,到读隐状态,到训练时就带上。DFlash 没单画卡,跟 DSpark 后面一起讲。」

🖥 屏幕:滚到「还有一支不要草稿模型」,再下到 fig-s11-ngram,顺着 ① 到 ④ 一格一格指。

「侧枝那一支不要模型,叫 n-gram,也叫 Prompt Lookup:直接从提示词里抄。
① 用户贴了一段代码,要把三点一四换成 math 点 pi。② 模型已经写到 def area 括号 r,最后两个字在提示词里出现过。
③ 就把提示词里紧跟着的四个字照抄成草稿。④ 大模型一次验完:前两个对,第三个它要的是 math 点 pi,于是这一步前进三个字。例子是自拟的,只讲机制。」

「⭐ 所以改代码、做摘要这种输出大段重复输入的活最合适。
vLLM 测过:每秒一个请求时,做摘要最多快二点八倍;同条件换小草稿模型跑闲聊对话,只有一点五倍。
开法很简单,vLLM 和 SGLang 里都是一个配置项。」

🖥 屏幕:滚到「EAGLE 也要训,只是训得很少」,再下到 fig-s11-eagle:先指图例的橙、蓝两色,再从第一块左边顺着箭头指到「草稿字」,最后指橙色虚线回环。

「时间线上 EAGLE 一笔带过了,展开说,它现在最常用。⭐ 先纠一个常见误会:EAGLE 不是免训练。
大模型冻住一点不动。入口把字变成向量的那层、出口把向量变回字的那层,都直接借大模型的。
真正要训的只有中间一小块:一个压缩层,加一层 decoder。给 70B 配的这块不到 1B 参数,一台 A100 服务器训一两天。」

「它怎么猜?吃两样东西:大模型出字前那层的向量,加上下一个已经抽中的字。
两样拼起来两倍宽,压回一倍,过那一层 decoder,猜出下一位的向量,再借大模型的出口变成字。猜出的向量和字再喂回去,接着猜。
为什么要把抽中的字也喂进去?光看向量,它不知道上一步按概率到底抽中了哪个字。」

🖥 屏幕:fig-s11-eagle 第二块,先指左边三层拼起来,再指右边第 2 步那格橙色「草稿自己的 I」。

「EAGLE-3 改两处。一是不只拿最后一层,浅、中、深三层各拿一个向量,拼起来再压回去;也不猜向量了,直接猜字。
二是猜第二个字起,那个字大模型还没验,拿不到大模型的向量,只能拿草稿自己上一步的输出顶上。所以训练时就让它把自己的输出喂回来练,叫 training-time test。」

🖥 屏幕:fig-s11-eagle 第三块左边,指那一排方框,再指下面两行「什么时候训」。

「⭐ 再看 MTP,结构跟 EAGLE 几乎一样:主干的向量加下一个字,压一下,过一个 block,借主模型的出口。
差别不在长相,在谁训:MTP 是厂家预训练时一起训、随模型发布;EAGLE 是模型发布以后,谁都能外挂上去训。
带 MTP 的也不止 DeepSeek:Qwen3-Next、GLM-4.5、小米 MiMo 都有,Step 3.5 Flash 一口气挂三个。」

🖥 屏幕:fig-s11-eagle 第三块右边柱状图,灰柱和绿柱一对一对比。

「一层 MTP 能不能猜好几个?能:把它的输出喂回去再跑一趟,就多猜一个。可原版只练过往前一步。
MiMo-7B 原样连猜,第三个位置几乎全错;FastMTP 把这一层按连猜微调,第三个位置还能收下三成多,速度到两倍。
⭐ 所以多猜几步不是改个参数就行,草稿得按连猜练过。」

🖥 屏幕:滚到「MTP、DFlash、DSpark 是一条线上的三步」,读完这段就下到 fig-s11-three,先只指第一行。

「常有人问:DSpark、DFlash、MTP 到底什么关系?⭐ 一句话:一条线上的三步。三个都是贴着大模型隐状态猜字的小草稿,差在怎么出字、每步验几个。
看图第一行,就是刚讲完的 MTP 和 EAGLE:一个字一个字猜。猜第二个字时看得见第一个猜了啥,所以越往后也不太掉;代价是猜五个就得跑五趟。」

「DeepSeek 线上原先开的叫 MTP-1:只多猜一个字,连大模型自己那个,每步验两个。
为什么不多猜几个?他们自己在论文里说了:固定猜三个、五个,在高并发下验证太贵,总吞吐反而掉。就是 11.2 那个坑,batch 一大,多验的字要付真钱。记住这个,后面 DSpark 就是来解它的。」

🖥 屏幕:指 fig-s11-three 第二行,再回正文指「注入草稿每一层的 KV」。

「第二行,DFlash。草稿只跑一趟,五个位置并行出来,猜五个和猜一个差不多贵,这是它快的地方。
它还挪了一处:大模型的隐状态喂在哪。EAGLE-3 只喂在草稿入口,草稿一做深,信号走几层就淡了;DFlash 注入草稿每一层的 KV,层层都看得见。二〇二六年它进了 vLLM 和 SGLang。」

💬 互动:问台下「一趟并行出五个字,什么时候会出错?」 期望答案:每个位置各猜各的,看不到同块前一位选了谁,两种说法会拼串。问的时候手先别指第二行的红格和右边那几行注。⏭ 时间紧可跳:当设问,自己接下一块。

🖥 屏幕:停在第二行的红格「problem」,再回正文滚到「一趟出整块的病:越往块尾越不准」。

「一趟出整块有个病:每个位置各猜各的,看不到同一块里前一位到底选了哪个字。
上文既能接 of course、又能接 no problem。第一位选了 of,第二位却押了 problem,拼出 of problem,验到这就断了,后面三个跟着作废。
所以 DFlash 越往块尾接受率一路往下掉;第一行那种一个一个猜的,反而持平。」

🖥 屏幕:指 fig-s11-three 第三行上半:五个「小头」和它们之间的横箭头;再回正文「DSpark 第一刀补草稿」。

「第三行,DSpark。⭐ 它就是拿 DFlash 当骨干,补了两刀。
第一刀补草稿:照旧一趟出整块,上面加一排很轻的顺序小头,从左往右传,按前一位选的字调下一位的分数。选了 of,就把 course 抬起来。
这样既保住一趟出整块的速度,又补回了第一行那种前后照应。」

「效果:平均接受长度比 DFlash 高将近两成,比 EAGLE-3 高近三成。
小头几乎不加时间:大 batch 下整轮只比 DFlash 慢不到百分之一点五,大模型验证那一下才是大头。」

🖥 屏幕:指 fig-s11-three 第三行下半:绿柱从左往右变矮,再指红、蓝两条虚线;回正文「第二刀补验证」。

「⭐ 第二刀补验证,这才是它在线上好用的主因。另一个小头给每一位估一个被收下的概率,连乘起来,就是这串草稿活到第几位的概率,图上绿柱越往右越矮。
调度器把整批请求的候选字按这个概率排队,再查一张引擎吞吐表,定这一步总共验多少:负载重,只验前两个,红线;负载轻,验到第四个,蓝线。没把握的字不占验证名额。」

🖥 屏幕:滚到「这正好解了 11.2 的坑」,再下一段「它在 V4 上占的正是 MTP 的位子」。

「这就回到刚才 MTP-1 那个坑:固定多猜,高并发下验证太贵。DSpark 不固定,忙时少验、闲时多验。
负载不重时,每个请求能验到四到六个,是 MTP-1 那两个的两到三倍;吞吐相同时,用户看到的出字快了六到八成五。V4 预览版上线两周,它就替下了 MTP-1。」

「最后一个细节把关系钉死:它在 V4 上占的正是 MTP 的位子,vLLM 就是按 mtp 零到二这几个名字,从主模型 checkpoint 里读它的权重。
⭐ 所以三者的关系一句话:DSpark 是 DeepSeek 线上 MTP 的接班人,出字方法走的是 DFlash 那一路,再加上按把握、按负载决定验几个。」

🖥 屏幕:滚到「11.4 接进系统的代价」,三条一条一条指。

「算法讲完,接进系统还有三笔代价。
第一,草稿要占显存。K3 开了 DSpark,KV 池少了将近两成。
第二,引擎默认值会跟着变。K3 的 SGLang 配方开了投机,又没写同时跑几个请求的上限,它就被悄悄重设成四十八,batch 上限压低了,没人提醒。」

「第三,PD 碰上投机。刚从 prefill 交接过来的请求这一步只算一个 token,别人都是一加 N,N 是草稿数。
形状不齐,就掉出整图 CUDA Graph,退回分段录或者逐个发。CUDA Graph 就是把一串 kernel 录好一次发出去,第十二节讲。decode 端把它补齐到一加 N 之后,每字间隔将近砍半,这是 vLLM 跑 GLM-5.2 的 PD 博客报的。」

🖥 屏幕:停在绿框「回到主线」。

「车上多坐人这一步补了多少:算上首字,K3 只有一个人用时吞吐是不投机的四倍多,比每字快的四点八一小一截;六十四个人一起用就不到两倍了;为大 batch 配的 DEP 可能倒亏。
一趟车能拉回好几个字了,可货还是那么重。batch 大时投机帮不上,第十二节换一根杠杆:货变轻。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 拒绝采样只用口语讲规则(概率高就收、低就按比例收、被拒从差里重抽),不写 min(1, p/q) 公式;被追问再指 fig-s11-step 的出处框。
⚠️ 4.81 倍和 4.22 倍别混:前者是每字间隔(fig-s11-bytes),后者是端到端吞吐、含首字时间(fig-s11-conc)。被问到就这样解释。
⚠️ 一趟 16.1 ms 是本课反推(2.31 × 6.96),1.45 倍里还有通信和空转,别全归给多读的专家。
⚠️ R15 口径(台上撤下的原数):V3 验 1 个读 37.5 GB、验 8 个 163.8 GB(4.4 倍);K3 不开投机一趟 11.1 ms、开投机约 16 ms(1.45 倍)、接受长度 6.96(将近七)、每字 11.1 → 2.31 ms;并发 1/8/32/64:4.22/2.86/1.89/1.74 倍;32K 时不开投机每字 11.1 → 11.4 ms;B200 DEP8 接受率约 54%、十档慢 3%~37%;V4-Pro MTP 1 → 2 步接受长度 1.88 → 2.36、单步慢 41%、decode 峰值 −13%、端到端 +28%;温度坑 1.16%/944 对 34%/2,911;K3 官方参考接受长度代码约 4.73、创作约 2.61。谱系倍数:独立草稿 2~3 倍、Medusa 2.2~3.6、EAGLE(LLaMA2-Chat 70B)2.7~3.5、MTP 约 1.8 倍、EAGLE-3 最多 6.5 倍/batch 64 吞吐 1.38、DFlash 最多 EAGLE-3 的 2.5 倍;投机解码 Google 2022-11、DeepMind 2023-02。n-gram:4×H100、Llama 3 70B、每秒 1 请求,摘要 2.8 倍、ShareGPT 小草稿 1.5 倍;vLLM 写 method ngram、SGLang 是 NGRAM。MiMo-7B 连猜约 70%/10%/近零 → FastMTP 81%/56%/36%。DFlash B300 Gemma-4 31B 单用户 3~5.8 倍。DSpark:Qwen3 4B~14B 接受长度比 DFlash +16%~18%、比 EAGLE-3 近 +30%;batch 128 草稿 4~16 个整轮只慢 0.2%~1.3%(台上说「不到百分之一点五」);V4-Flash 并发 <200、V4-Pro <150 时验 4~6 个。K3 KV 池 78 万多 → 63 万多 token;GLM-5.2 PD TPOT 约 40 → 22 ms(台上说「将近砍半」)。没画进谱系图的:SpecInfer、SuffixDecoding、Lookahead。
⚠️ 草稿谱系图上不画倍数是故意的:各家倍数在自己的模型上测,不能横比。
⚠️ B200 那组是 EP+DP 高吞吐配置,结论不能搬到 TP-only 低延迟配置。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「EAGLE 不用训吧?」→ 要训,只训一个压缩层加一层 decoder,嵌入层和出口借大模型;70B 配的不到 1B 参数,一台 A100 服务器一两天(11.3)。
🛠 GPU 老兵「num_speculative_tokens 调到 3,MTP 接受率怎么崩了?」→ 原版 MTP 只练过往前一步,MiMo-7B 连猜第 2、3 位约一成、近零;要按连猜微调过(FastMTP 升到五成六、三成六)。
🛠 GPU 老兵「压测发温度 0 算不算作弊?」→ 不算,但两边要对齐:V4-Pro 那组不发温度接受率只剩 1.16%,发 0 是 34%,发 0 的吞吐是不发的 3.1 倍。报数时写明温度。
💰 管预算的「生产环境要不要开?」→ 低并发、要跟手的档先开;为大 batch 配的 DEP 先实测,B200 那组十档全变慢。开了就把接受率当一级指标告警。
💰 管预算的「投机解码能省多少?」→ 看并发:K3 实测吞吐并发 1 时 4.22 倍,并发 64 只剩 1.74 倍;大 batch 部署可能反而变慢。
🛠 GPU 老兵「PD 下开投机,TPOT 反而变差?」→ 刚交接的请求只算 1 个 token、别人 1+N,形状不齐掉出整图 CUDA Graph;decode 端补齐后 TPOT 约 40 → 22 ms(11.4)。

第十二节 量化与 kernel 融合(23′)计划 23′ · 含互动 21.4′ · 跳后 20.9′

🖥 本节主屏:课件 第十二节 量化与 kernel 融合 · 主图 fig-s12-bytes

🎯 这一节只留一句:量化让货变轻,融合让车不在半路停;同叫 4 bit,差在缩放,还得跟硬件对上。

🖥 屏幕:课件 s十二,停在节标题下那段导语。

「人多了投机不灵,剩下的办法是让每一趟少搬、少停。
少搬叫量化:权重和 KV 用更少的位数存。少停叫 kernel 融合:去掉 kernel 交接时的空等。两件事一件一件来。」

🖥 屏幕:滚到「12.1 位数减半,下限减半」,指第一段。

「先看量化怎么一步步走到今天。二〇二二年底,GPTQ 只压权重、算的时候再还原:压到三 bit 的 OPT-175B,一张 A100 就能跑,逐字还比五张卡跑半精度快三倍多。
同年 Hopper 的张量核,就是 GPU 里做矩阵乘的那块,能直接拿 FP8 算;DeepSeek-V3 连训练都用 FP8。到 Blackwell,四 bit 浮点 NVFP4 也进了张量核。」

🖥 屏幕:fig-s12-bytes,先左边四根条从上往下,再右边。

「batch 小的时候,一步几乎全在读权重,所以位数减半,耗时下限就减半。
左边是本课只算权重推的:V3 放在八颗 TPU v7 上,带宽跑满。四根条,位数每降一档,下限差不多减半。
⭐ FP8 那根是零点六三毫秒,正好是第一节单芯片五毫秒的八分之一。」

「⛔ 两种四 bit 都比 FP8 的一半多一点,NVFP4 又比 MXFP4 多一点,多出来的是缩放,等下讲。
右边看整个模型放不放得下:BF16 要占八颗芯片总显存的八成多,FP8 只占四成,这是本课一除。
⛔ 下限是理想值:没算 KV、激活和通信,实际一步更慢。」

🖥 屏幕:滚到「实测接近这个比例」,再往下指 AWQ 那段和「省下的显存多放 KV」那句。

「实测接近这个比例。二〇二四年七月 vLLM 接入 FP8 权重:两张 H100 上,稠密的 Llama 3 70B,每字间隔最多降到不量化时的一半;MoE 的 Mixtral 8x7B 最多降到一点六分之一。
MoE 为什么赚得少?原文没说。本课推测:MoE 只读选中的专家,读权重在一步里的占比本来就低。」

「再减一半到四 bit:AWQ 二〇二三年在 RTX 4090 上、一个人用,跑 Llama-2-7B,比已经融合过 kernel 的半精度再快三点一倍。
精度看困惑度,越低越好:AWQ 只比半精度高一点点,直接四舍五入取整,高出来的是它的两倍。⭐ 同样四 bit,取整取得聪明不聪明,差出来一截。
省下的显存能多放 KV、多接人,顺带走了车上多坐人那条路。」

🖥 屏幕:滚到「同叫 4 bit,差在缩放。」,再下到 fig-s12-mx,先上后下。

「四 bit 只有十六个编码,一个数自己装不下量级,只能几个数共用一个缩放倍数。
上面的 MXFP4:三十二个数共用一个八 bit 缩放,格式叫 E8M0,八位全是指数、没有尾数,只能表示二的幂。摊下来每个数四加八除以三十二,四点二五 bit。」

「下面的 NVFP4:块小一半,十六个数共用一个缩放,缩放本身是个 FP8 的小号浮点数,叫 E4M3,四位指数三位尾数,所以能取非二的幂的值,贴得更准。每个数四点五 bit。
⭐ 规律一句话:块越小,越贴合那一小段的数值,精度越好,摊下来的字节也越多。格式的位布局细节在专题九第二节。」

🖥 屏幕:停在「差多少有一组同条件的数」和下面推理侧那段。

「差多少?NVIDIA 拿一个八十亿参数的 Mamba 与 Transformer 混合模型,同条件训了一万亿 token:MXFP4 的 loss 偏离 BF16 更多,要多训三成六的 token 才追平 NVFP4。
推理侧,NVIDIA 博客说 DeepSeek-R1-0528 从 FP8 训后量化到 NVFP4,主要语言任务掉点在百分之一以内。
⛔ 同一张卡上 FP4 比 FP8 快多少,没找到官方同条件的数。」

🖥 屏幕:滚到「低精度直接训出来」。

「越来越多模型发布时就是低精度。二〇二五年的 Kimi K2 Thinking 在后训练做了量化感知训练,就是训练时就模拟低精度,专家直接是 INT4,官方称低延迟模式生成快约两倍、「无损」。
⛔ 但它没写跟什么精度比,基准也只报了 INT4 下的分,「无损」先打个问号。
DeepSeek-V4 模型卡写明:专家用 FP4,其余大多 FP8。专家是 decode 读得最多的部分,压它省得最多。」

🖥 屏幕:滚到「12.2 专家压到 4 bit,注意力不动」,指第一段三个参数数。

「为什么只压专家?数一下就知道。gpt-oss 一百二十 B 的模型卡把参数分开列:专家占九成八,注意力不到百分之一,这是本课拿专家除以总数算的。
OpenAI 只把专家压成 MXFP4,整个模型就装进了一张八十 GB 的卡。」

「⭐ 注意力不压,头一条原因是省不了多少:不到百分之一的参数,压掉一半也只省半个百分点。
所以各家做法一致:Kimi K2 Thinking 的配置里,注意力、共享专家、稠密层、输出层都在不量化名单上,INT4 只给路由专家。本仓库在 TPU 上跑 R1 和 GLM-5.1,也是专家 FP4、注意力 FP8。」

🖥 屏幕:下到 fig-s12-cap,先指竖虚线,再指上面红条越过虚线的那截淡红,最后指下面 FP4 那根。

「压专家,第一份好处是放得下。这张图是 R1 放上 v7x-8,每个 device 要多少显存,竖虚线是可用上限。
专家用 FP8,光专家就顶到了线上。⛔ 记录里单位写得含糊,GB 和 GiB 两种读法图上都画了,哪种都越线。再加上注意力那九 GB 上下,这是本课拿七十减六十点九推的,FP8 怎么都放不下。」

「换成 FP4,连同注意力约七十 GB,离上限还空出三十 GB 上下,留给 KV。」

🖥 屏幕:滚到「第二份是少读」,再指下面「第三份最反直觉」和 Marlin 那段。

「第二份是少读。decode 每一步都要把选中的专家从 HBM 读一遍,batch 不大时,读权重的时间就是一步的时间。四 bit 比八 bit 少读一半。
第三份最反直觉:v7 的公开规格只列了 BF16 和 FP8 的峰值,没有 FP4 算力,照样能快。」

「为什么?tpu-inference 的 MoE kernel 把四 bit 权重块原样搬进片上,在 kernel 里跟激活做点积,每块乘完再乘缩放。本课推测编译器在片上先解成更宽的格式,再送进矩阵单元。
⭐⭐ 贵的是从 HBM 搬,片上解一下便宜。⛔ 所以别说 FP4 在 TPU 上算得更快,省的是字节和容量。」

「GPU 上早算过同一笔账。二〇二四年的 Marlin,让四 bit 权重在寄存器里解回半精度再进张量核:batch 十六以内的矩阵乘接近半精度的四倍,接进 vLLM 端到端最多二点八倍。
Blackwell 的张量核能直接算 FP4,那是另一条路。」

🖥 屏幕:停在「精度:本仓库在 v7x-8 上用 FP4 专家跑出」那段。

「那精度呢?本仓库在 v7x-8 上用 FP4 专家,GSM8K 数学题 R1 跑出九成五,GLM-5.1 将近九成。
⛔ 这两个数口径不同,不横比;也都没有同条件的 FP8 分可对照。只能说跑出来了,不能说没掉点。同机 FP8 对 FP4 的吞吐也没有:R1 用 FP8 根本放不下。」

🖥 屏幕:fig-s12-ledger,从上往下指三根橙段,最后停在蓝、灰两段上。

「压完以后呢?这张是 gpt-oss 一百二十 B 每出一个字要读的权重,按组件堆成横条,本课按配置推的。
橙色是专家,BF16、FP8、MXFP4 一根比一根短;蓝的注意力、灰的输出层,三根一样长。」

「⭐⭐ 合计整步只省了一半左右;专家在一步里的占比,从七成上下掉到不到四成。
注意力和输出层原样不动,反倒成了读得最多的部分。所以专家压到四分之一,整步也快不到四倍。K2 Thinking 只称快两倍上下,本课推测原因之一在这儿;它也没写对照的是什么精度。上下文一长,后面还要接一段 KV,那段怎么压,12.4 讲。」

🖥 屏幕:滚到「INT4 不是另一种 FP4。」,再下到 fig-s12-r1,跟着那个「−3」从左往右走。

「同叫四 bit,FP4 是浮点,零附近密、远处疏,靠块缩放对齐量级;INT4 是负八到七等距排开的整数。
这张图跟着一个权重负三走一遍:存进文件时整体加八,变成零到十五,负三存成五。读的时候减八,负三原样回来,模型正常。
K2.6 的记录里就漏过这一步。你猜:报错、略差,还是全崩?」

💬 互动:举手三选一,不点人答。期望答案:全崩,程序还照常出字。多数人会选报错或略差。⏭ 时间紧可跳:不举手,上一句的「你猜」当设问,直接说「全崩」。

「全崩。看最下一行:不减八、直接当有符号整数读,负三读成了五,每个权重都差八,符号位整个反了。
输出成了重复的乱词,程序照常出字,不报错。⭐ 又是一个不报错的坑,跟温度那个一样,只能靠看输出发现。」

🖥 屏幕:滚到「12.3 CUDA Graph 与 kernel 融合:边界上不再干等」,再下到 fig-s12-graph,先指上面 GPU 那行一格一格的粉色空当,再指下面挤成一条。

「还有一招不是少搬,是让车别在半路停。先看 CPU 那头:batch 一小,GPU 算一个 kernel 很快,CPU 一个个发反倒跟不上,GPU 算完一个就等下一个。
CUDA Graph 把一步要发的整串 kernel 录下来,之后每步只发一次重放。
这张图是 Fireworks 在 A100 上跑七十亿参数的 LLaMA-2,一个人用:每秒出的字多了一倍多,提速全来自 CPU 那头。」

🖥 屏幕:滚到「代价是形状写死」,三条一条一条指。

「代价是形状写死,所以按批大小分档预先录。vLLM 默认从一录到五百一十二,越往上档越稀;SGLang 有个参数定上限。人数不在档上,就补到上一档。
prefill 的形状千变万化,所以 vLLM 默认 decode 录整图,prefill 和混合批只把注意力以外的部分分段录。」

「⭐ TPU 上也有同一件事,叫桶,是一件事的两头:GPU 默认逐个发,录图是可选的加速,档外的批照样能跑;TPU 上 XLA 本来就按形状整图编译,档外的形状要现编,所以桶得开服前定好,第十四节再说。
11.4 里 PD 碰上投机掉出整图,也是形状不在档上。」

🖥 屏幕:滚到「kernel 融合:边界上不再干等。」,再下到 fig-s12-fuse,先指第一行的上限,再指中间放大的一层,最后指 megakernel 那行。

「图录好了,GPU 这头还有停顿。一次前向,就是模型从头算到尾一遍,要发上百个 kernel;每个收尾、下一个开场的那一下,没人在读权重。
这张是 Hazy Research 的算例:Llama-3.2-1B 在 H100 上,光把权重读一遍约七百四十微秒,这是上限。」

「可一次前向要交接一百多回,每回按乐观的五微秒算,又多出五百六十微秒,作者说实际往往更糟。⭐ 交接的空等吃掉四成多。
中间那行把一层放大,七个 kernel 之间各空一段。最下面那行是 megakernel:整次前向写成一个 kernel,上一段在算,下一段的权重已经在读,只剩读权重的七百四十微秒。」

🖥 屏幕:停在「CUDA Graph 省的是 CPU 那头」和下面 Hazy Research 那段。

「⛔ 别把这两招混了:CUDA Graph 省的是 CPU 那头;GPU 这头,生产里先上的是 PDL,让下一个 kernel 提前准备。megakernel 再往前一步。
有人量过:vLLM、SGLang 最多用到 H100 带宽的一半,megakernel 到将近八成。而且那组基线已经开了 CUDA Graph。
模型和 batch 越小,空等占比越大,赚得越多:同一篇在 Llama-3.2-1B、一个人用时,比 vLLM 快近两点五倍,比 SGLang 快一点五倍以上。」

「反过来,模型一大,融合单拎出来就赚得少:AWQ 那组测试里,光把半精度 kernel 融合,Llama-2-7B 只快了两成左右,这是本课一除。」

🖥 屏幕:停在「TPU 这边,Inferact 2026-09 用 Pallas」。

「TPU 这边,Inferact 二〇二六年九月用 Pallas,就是 JAX 里手写 TPU kernel 的语言,写了 megakernel。十六颗 v7 跑 Kimi K3,单用户每秒超过七百个字;同样数量的 GB200 跑 vLLM 是四百五十多。
⛔ 两边都开了投机,都按接受长度六、也就是每步出六个字换算;真实负载要是接受长度不到六,两边都会降。」

「⭐ 这个七百多是 megakernel 加 DSpark 投机一起换来的,博客没提量化。这几招能叠着用:投机让一趟多拉几个字,量化让货变轻,融合让车不在半路停。」

🖥 屏幕:滚到「12.4 KV 也能量化」,指前两段。

「最后,KV 自己也能压。存成 FP8,每个数从两字节变一字节;vLLM 和 SGLang 都是一个参数的事。K3 官方的高吞吐配方把它列为必开:BF16 的 KV 装不下每副本一百二十八个请求。
⭐ 坑在缩放。vLLM 只设 FP8 不校准时,缩放全取一;拿数据校准过,才能每个 K、V 张量一个,或者每个 KV 头一个。开了 FP8 KV 掉精度,先查有没有校准过的缩放。」

🖥 屏幕:滚到「实际布局不是严格一半」,再下到 fig-s12-kvlayout,先上面 BF16 那条,再下面 FP8 那条,最后指红虚线。

「省多少?不是一半。这张是 DeepSeek-V3.2 一个 token 在一层里存的 KV,条长按字节画。
上面 BF16:压缩 KV 加一小段位置编码,每维两字节。下面 FP8:压缩 KV 每维一字节,加几个缩放,位置编码还是 BF16 不压。」

「两条末尾都接一段索引键,就是第四节那个小打分器挑 token 时读的,它本来就存 FP8,换了也不变小。
⭐ 看红虚线:MLA 那截严格减半该到这儿,FP8 那条越过了,多出来的是没压的位置编码和缩放。
本课推的:同样显存能多装六成多的请求,一点六三倍。」

🖥 屏幕:滚到「4 bit 已经落地」,再指最后一段 V4.1-Flash。

「KV 也已经到四 bit。二〇二五年十二月 NVIDIA 在 Blackwell 上放出 NVFP4 KV,比 FP8 再省约一半,博客报基准上精度损失不到百分之一。算注意力之前照样解回 FP8,省的是容量和读的字节。
同样显存多存了前缀:Qwen3-Coder-480B 上命中率比 FP8 KV 高两成,首字延迟最多降到约三分之一。」

「二〇二六年九月 DeepSeek 的 V4.1-Flash,主 KV 原生就存四 bit,每十六个数一个缩放,FlashMLA 同时放出读它的 kernel,比原先的 FP8 KV 小四成五。不过只有其中一份能存四 bit,另一份还是 FP8。」

🖥 屏幕:停在绿框「回到主线」。

「货变轻这一步补了多少:权重压到 FP8 或 INT4,出字最多快到两倍上下;KV 存 FP8,同样显存多装六成多。
到这儿,三根杠杆都拉过了。可这些招数都默认一件事:每个 token 留一份 KV,想截在哪就截在哪。新架构把这件事拆了,这是第十三节。」

⚠️ 这一节最容易跑偏的地方 ⚠️ E8M0、E4M3 只讲到「指数几位、尾数几位、能不能表示非二的幂」;E2M1 内部编码不展开,细节在专题九 §2。
⚠️ Inferact 那个七百多是 megakernel 加 DSpark 投机一起换来的,别说成量化或单靠 megakernel 的功劳;GB200 一侧的数也是 Inferact 博客自报。
⚠️ v7 规格没列 FP4 峰值,别说「FP4 在 TPU 上算得更快」:省的是字节和容量,算之前要解开。
⚠️ R1 那几个容量数单位混着(README 记 GB、上限是 GiB),fig-s12-cap 两种读法都画了;口播落在「不管单位怎么读都放不下」。
⚠️ R15 口径(台上撤下的原数):GPTQ 3.25 倍(≈三倍多);V3 激活 370 亿、BF16 74 GB/1.26 ms、FP8 37 GB/0.63 ms、MXFP4 约 19.66 GB、NVFP4 约 20.81 GB(都在 0.3 几 ms);671B:BF16 1,342 GB、FP8 671 GB、八颗合计 1,649 GB(81%、41% 本课算);AWQ 困惑度 FP16 5.47、AWQ 5.60、RTN 5.73(+0.13 对 +0.26,两倍);训练 loss 高出 BF16:MXFP4 约 2.5%、NVFP4 约 1.5%;gpt-oss 专家 1,147 亿、注意力 9.6 亿、嵌入+输出 11.6 亿;R1 上限 94.75 GiB ≈ 101.7 GB、FP8 专家 101.8 GB(若是 GiB 约 109.3 GB)、FP4 专家约 60.9 GB;GSM8K R1 94.9%(1,319 题)、GLM-5.1 89.46%(5-shot、未调优);ledger 专家 BF16 7.2/FP8 3.6/MXFP4 1.9 GB、注意力 1.9、输出层 1.2,合计 10.2 → 5.0 GB;Fireworks 30 → 69 tok/s、33 → 14.5 ms;vLLM 录图档 1、2、4,8~248 步长 8,256 起步长 16,到 512(数据中心 Blackwell 到 1,024);Hazy 2.48 GB、3.35 TB/s、上限 1,350 次/s、7 kernel × 16 层(112 次交接)、770 次/s;AWQ 融合 52 → 62 tok/s(+19%);V3.2 BF16 512 维 + 64 维 = 1,152 B、FP8 四个缩放、合计 1,284 对 788 B;收尾:FP8 稠密 2 倍、MoE 1.6 倍、K2 Thinking 约 2 倍。
⚠️ 1.63 倍、四成多、gpt-oss 字节账都是本课推导,台上已说「推的」。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「量化会不会掉精度?」→ 课件没给同条件的精度对比;代价一般有,所以现在倾向训练时就适应:K2 Thinking 做了量化感知训练,V4 专家直接用 FP4。自己量的模型要跑评测。
🛠 GPU 老兵「megakernel 能直接在 vLLM、SGLang 里用吗?」→ 生产里先上的是 CUDA Graph 和 PDL;megakernel 目前是 Hazy、Mirage MPK、Inferact 这类专门实现,MPK 报 1.7 倍。
🛠 GPU 老兵「KV 存 FP8 掉多少精度?」→ 课件没有 FP8 KV 的精度数据;掉了先查缩放是否校准过,vLLM 不校准全取 1.0,校准后可每张量或每 KV 头一个(12.4);K3 官方高吞吐配方把它列为必开。更激进的 NVFP4 KV,NVIDIA 报基准上损失不到 1%(12.4)。
💰 管预算的「量化先上哪一步?」→ 先看模型发布格式,已经是低精度就直接用;否则先压权重,再开 KV FP8,各跑一遍评测。
💰 管预算的「量化能省多少?」→ FP8 权重:vLLM 实测稠密每字最多快 2 倍、MoE 1.6 倍;KV 存 FP8 能装的请求约是 BF16 的 1.63 倍(本课推的)。
🛠 GPU 老兵「TPU 比 GB200 快,是 Inferact 自己报的吧?」→ 是:Inferact 博客自报,本课没复测;GB200 一侧是 vLLM 基线,两边都按接受长度 6 换算。
🧑‍🎓 新人「TPU 上能直接算 FP4 吗?」→ 公开规格只列 BF16、FP8 峰值;tpu-inference 的 MoE kernel 把 4 bit 块搬进片上再和激活相乘,课件推测片上先解成更宽格式。省的是容量和读的字节(12.2)。

第十三节 新架构出难题:状态没法按 token 切(10′)计划 10′ · 含互动 9.8′ · 跳后 8.8′

🖥 本节主屏:课件 第十三节 新架构出难题:状态没法按 token 切 · 主图 fig-s13-snap

🎯 这一节只留一句:线性层一条序列只有一份状态,截不开;前缀缓存只能存快照,一份顶几千个字,所以生产只留要紧的几份,KV 和快照分开管。

🖥 屏幕:课件 s十三,停在节标题下那段导语。

「先问一句:前缀缓存命中了一段六百个字的开头,能不能直接从第六百零一个字接着算?前面十二节,答案都是能。这一节讲一种模型,答案变成了不能。」

「前面每一招,底下都垫着同一个前提:每个 token 一份 KV,大小一样,想截在哪截在哪,想按块复用、按块搬都行。
⭐ 混合模型里的线性层不是这样:一条序列只有一份状态,整段压进去,截不开。」

🖥 屏幕:滚到「13.1 前提塌了:三种层,前缀缓存只能存快照」,那张三行表一行一行指。

「三种层,新请求能接着算的地方不一样。
全注意力,每个 token 一份 KV:共享前缀的任意位置都能接。
滑窗只留最近一个窗口的 KV:要有完整的最后一整窗才能接。
线性层,GDN、Mamba、KDA 这一类:每条序列一份固定大小的状态,原地更新,只能从正好存过状态的地方接。」

「为什么线性层这么死?它的状态每进一个字就改写一次,像一锅汤,加了料就分不出去,退不回更短的前缀。
PyTorch 博客把难处归成三条:一,退不回去;二,一份状态比单个 token 的 KV 大几个数量级;三,要么整份能用,要么不能用,没有用一半这回事。」

🖥 屏幕:滚到「前缀缓存只能改存快照。」,再下到 fig-s13-snap,先指上面那排旗,再指六百那条竖线和中间重算的那一截。

「截不开,就隔一段把整份状态拷一份存下来,叫快照,像游戏存档。
看上图:一条一千零二十四个字的前缀,全注意力每个字一格;线性层只在二百五十六、五百一十二、七百六十八各存一份。
新请求和它共用前六百个字。全注意力本可以从六百接着算,可线性层最近的存档在五百一十二,⭐ 整个模型就只能从五百一十二接着算,中间八十八个字重算。」

💬 互动:「线性层只占一部分层,为什么全注意力层也得陪着退回五百一十二?」等两三秒再答。期望答案:每一层都要从同一个位置往下算,线性层接不上,整个模型就只能从它能接的地方开始。⏭ 时间紧可跳:当设问,自己接下一块。

🖥 屏幕:滚到「命中后先把快照拷到这个请求自己的槽里」,再指下面一段。

「命中以后还有一个细节:先把快照拷到这个请求自己的槽里,再往下改。
⛔ 因为状态是原地更新的,直接在共享的那份上算,别人的存档就被你改坏了。
全注意力层的 KV 照旧按块存,快照只是线性层多出来的一份。两类东西复用的边界不同,SGLang 二〇二六年把它们挂进同一棵前缀树,各按各的边界判命中。」

🖥 屏幕:滚到「13.2 生产里怎么存:两个池,只留要紧的几份」,再回到 fig-s13-snap 左下那几根条。

「存档不便宜。拿 Qwen3.5-397B 按配置算,本课推的:四十五层 GDN 的状态加起来,一份快照约一百八十三 MiB。
⭐⭐ 一份就顶六千二百五十个字的 KV。K3 更夸张,一份顶一万六千个字左右,也是本课按公开配置推的。」

「这么大,生产上肯定不会每隔一小段就存。vLLM 的 K3 博客原话:每个位置都存,贵得没法用。它只留三种。
⭐ 一,prompt 末尾必留。多轮对话,下一轮正好从上一轮的末尾接着算。
二,隔一大段留一份,比如每三万二千字一份,可以设成零,只留末尾。」

「三,第二次撞见才存。系统提示、代码仓库这种共享前缀,不在 prompt 边界上。第一次只记一笔,第二次确认真有人共用,才在分叉的地方存一份。
SGLang 换了个管法:decode 时每二百五十六个字记一份,但池子是固定大的,满了按最久没用的先删快照,KV 留着;命中时还会在分叉处补记一份。」

🖥 屏幕:fig-s13-snap 右下三行,从上往下指,最后指红的那行和下面 KV 那行。

「看右下,一条十二万八千字的前缀。
⭐⭐ 只留末尾一份,是 KV 的百分之五;每三万二千再留一份,也不到两成。
⛔ 红的那行是每二百五十六都留:五百一十二份,是 KV 的二十几倍。生产不这么干。」

💬 互动:「多轮对话为什么只留 prompt 末尾就够?」等两三秒。期望答案:下一轮的 prompt 就是上一轮整段加新话,正好从上轮末尾接着算。⏭ 时间紧可跳。

🖥 屏幕:滚到「两种东西,两种管法。」,四条一条一条指。

「KV 和快照是两种东西:KV 按字长、按块存;快照按请求、一份一份存。
SGLang 干脆分两个池:KV 池按字,状态池按份,比例启动时定,弹性池让一边闲着时匀给另一边。
⭐ 删的时候也分开:KV 只能从树叶往根删,快照哪个节点上的都能单独删。」

「vLLM 是一个管理器、一种页:全注意力的块放大到一页装得下一份状态。PyTorch 博客的例子里一块六百七十二个字,命中粒度变粗。K3 起把物理块和前缀匹配的单位拆开,快照可以登记在大块里更细的边界上。」

「显存放不下还能往下放:KV 和快照一起落到 CPU 内存,再到外部存储,命中了再搬回来。
最后一招是把快照压小。SGLang 有个开关,默认关,存成 int8,说明里写能多缓存约一倍前缀。
⛔ 为什么不选 FP8?状态值分布近乎均匀,指数位用不上;而且只在命中时还原一次,误差不会在递推里累积。」

🖥 屏幕:滚到「同一个前提,前面已经撞了四次。」,四条一条一条指。

「其实前面已经撞过四回,都是这一件事。
一,前缀复用,第四节:tpu-inference 跑 Qwen3.5 得关掉前缀缓存,不然断言出错;看样子是还没接上这套快照,这是推测。
二,DEP,第六节:状态按请求开、不随 DP 切,K3 每个 rank 存整池状态,DEP8 起不来。」

「三,PCP,第七节:序列切开以后,状态要从前一段接力,不能从空状态起步。
四,PD 分离,第八节:状态已经吃下整段 prompt,尾巴不能留给 decode 端重算,只能整份传。
GPU 引擎这两年为此补了成套机制。那 TPU 上把这种模型真正跑起来,要过哪几关?第十四节。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 一百八十三 MiB、六千二百五十个字、K3 四百三十 MiB 与一万六千字、右下三行的 GiB 和百分比都是本课按 config 推的(K3 状态按 fp32 计),没有实测显存读数,台上已说「推的」。
⚠️ 第四节表里的 180 MiB 不是错,是只算了递归状态;183 MiB 多算了卷积状态。被问就这样答。
⚠️ 参数名(VLLM_PREFIX_CACHE_RETENTION_INTERVAL、--mamba-track-interval、--mamba-full-memory-ratio 等)在 13.2 课件上,台上只说做法,被问再指。
⚠️ 右下「每 32K 留一份」是 vLLM 博客举的例子,不是默认值。
⚠️ R16 口径(撤下口播的原数):Qwen3.5 每字 KV 30 KiB、每层 GDN 状态 4 MiB +卷积状态;K3 六十九层 KDA 一份约 430 MiB、MLA 每字 576 维约 27 KiB;右下 128K 前缀 KV 约 3.75 GiB,只留末尾 0.18 GiB(5%),每 32K 一份共 4 份(19%),每 256 一份共 512 份九十多 GiB(二十几倍)。
❓ 台下可能问(备答,不计地板)
🛠 GPU 老兵「int8 快照会不会越用越不准?」→ 只在命中时还原一次,误差不在递推里累积;默认关,号称能多缓存约一倍前缀(13.2)。
🧑‍🎓 新人「为什么不每个字都存一份?」→ 一份快照顶六千多个字的 KV,每字一份显存马上就满;生产只留 prompt 末尾、隔大段一份、第二次撞见的共享前缀(13.2)。
🛠 GPU 老兵「两个池比例定死了,长短请求一变不就浪费?」→ SGLang 有弹性池,一边闲时匀给另一边;vLLM 本来就是一种页共用(13.2)。
🧑‍🎓 新人「滑窗层要不要快照?」→ 13.1 表:它存的是最近一个窗口的 KV,要有完整的最后一窗才能接;课件没讲滑窗的存法细节,不展开猜。

第十四节 落地:把 Qwen3.5 在 TPU 上跑起来(深讲,不计时)深讲,不计时 · 含互动 31.1′ · 跳后 30.1′

🖥 本节主屏:课件 第十四节 落地:把 Qwen3.5 在 TPU 上跑起来 · 主图 fig-s14-diff

🎯 这一节只留一句:搬到 TPU,形状、通信、片上内存、数据格式四条规矩变了;每条都要在模型上找一处做法去配合,刀往哪砍再看 batch。

📌 第十四节为深讲,不计入总时长:奔着讲清楚去讲,每一条都按「打个比方 → 机制 → 不这么做要付多少 → 为什么快」走完。课时紧时整节可以挪到课后单独讲。

🖥 屏幕:课件 s十四,停在导语「三个问题:TPU 跟 GPU 哪里不一样,这个模型哪几处要特殊处理,怎么跑快。」

「前面十三节讲的是招数。这一节把它们落到一个模型、一种芯片上:Qwen3.5-397B,存成 FP8,跑在一台 v7x-8 上,四颗芯片、八个 TensorCore。
这个模型六十层里,四十五层是线性注意力,就是第十三节那个 GDN;十五层是全注意力。MoE 每层五百一十二个专家,每个字挑十个。」

「栈是 vLLM-TorchTPU:TorchTPU 让 PyTorch 原生跑在 TPU 上,vLLM-TorchTPU 是 vLLM 在它上面的后端,十月二十号连同 SGLang-TorchTPU 一起开源了。每一刀在课件上都注了公开的 PR 号,想看代码直接点;梯子上的数仍按起点那天记作一,只说倍数。
这一节是深讲,不掐表,每一条都讲到机制。三个问题:TPU 跟 GPU 到底哪里不一样;这个模型哪几处要为 TPU 特殊处理;处理完怎么跑快。」

🖥 屏幕:fig-s14-diff 整张,先指四行的行名,再按行从左往右扫三列,最后停在右列。

「先看这张表。四行是四条规矩:形状、通信、片上与布局、数据格式。
每行三格:左边 GPU 怎么做,中间 TPU 上变成什么样,右边这个模型怎么配合。
⭐ 这一节就是把右边那一列一格一格讲透。」

🖥 屏幕:滚到「14.1 TPU 跟 GPU 哪里不一样」,停在「形状:GPU 录图只是加速,TPU 不编就不能跑。」

「第一条,形状。GPU 上 kernel 是一个一个发出去的;CUDA Graph 把一串录下来,省的是发射开销。⛔ 录图只是加速,档外的批照样能跑。
TPU 不一样。XLA 按静态形状把整张图编译好才能跑,一批的 token 总数要补齐到预编译的那几档。没编过的档,第一个撞上的请求要等六十到九十秒。」

🖥 屏幕:往下指「为什么非编不可。」

「为什么非编不可?打个比方。GPU 像现场点菜,来一单炒一单。XLA 像中央厨房,开工前把整桌菜的工序、锅位、碗碟一次排死。
每个张量多大、放在哪、循环跑几圈,编译时都定了,它才能跨算子融合、整张图一起排内存。代价是形状一变,那套排法就作废,得重排,就是那六十到九十秒。」

🖥 屏幕:往下指「分桶就是成衣尺码。」,再到 fig-s13-bucket,先指左下角三根条,再指右边六根条。

「那形状千变万化怎么办?分桶,就是成衣尺码。不给每个总数量体裁衣,只备几个码。
看左下角:这一步整批拼起来七百个 token,就补零补到一千零二十四那一档去算,斜线那段是白算的零。
⭐ 码备得越多,补得越少,可每个码都要编一次。」

「右边是本课推导的示意。只备一个八 K 的码,算的 token 里将近九成是零;备三十二个码,降到一成左右。
有意思的是绿条:十三个按根号二递增的码,比十六个等距的码还省。码要按分布的形状切,短的地方切细,长尾切粗。」

🖥 屏幕:往下指「长短不一的请求,不进形状。」

「注意,补齐只按整批总数,单条请求不补。
那一批里有人两百字、有人八千字,形状怎么办?答案是长度根本不进形状。每条多长、页在哪,是 RPA 的 kernel 运行的时候才读的数据:按页表取页,只搬有效长度,5.1 那个动画。
所以一个 kernel 吃下各种长度,不用为每种长度各编一份。」

🖥 屏幕:往下指「跨 rank 回放:一份菜谱印八份。」

「档位一多,编译就成了开服的大头。怎么省?想一想编出来的程序取决于什么:只取决于图本身,形状、算子、常量,跟哪个 rank 来跑无关。
八个 rank 各编一遍同一张图,就像八个厨师各自试做同一道菜。不如一个人做出来,菜谱印八份。」

「做法是档位分给不同 rank 去编,产物校验过图指纹,其余 rank 直接加载。
前提是同一形状只能编出同一张图。一篇公开博客在 Hy4 上把分块循环留成循环、不在追踪时展开,把一个闭包常量改成运行时输入,冷编译从一个半小时出头压到十几分钟。
Qwen3.5 八组数据并行之间也这么共享,从权重加载完到能服务,七百四十秒降到二百七十秒。」

🖥 屏幕:往下指「所以凡是随 rank 变的值」那段。

「⭐ 所以凡是随 rank 变的值,rank 号、每张卡自己的常量,都不能写进图里,改成运行时传进去,或者在组内用一次通信取到。
图只剩一张,八张卡才能共用一份产物。」

🖥 屏幕:往下指「通信:没有全互连,XLA 也未必替你藏。」,再指「6 个邻居是什么样。」

「第二条,通信。GPU 一台机器里八张卡 NVLink 全互连,机器之间走 IB,MoE 收发有 DeepEP 点对点,6.4 讲过。
v7 芯片之间是 ICI 3D 环面,每颗只连六个邻居。什么意思?NVLink 交换机像每人桌上一部直拨电话,谁找谁都一跳。3D 环面像一个立体方阵,每人只能跟前后、左右、上下六个人递东西,远的要中间人转手,这句是本课推的。」

🖥 屏幕:往下指「为什么规整通信合它的脾气。」,再指「点对点 all-to-all 难在不可预测。」

「这种连法擅长什么?all-gather、reduce-scatter。环形 all-gather 每一步,人人同时把手上一块递给下一个邻居:所有线同时忙,每步的量一样大,几步做完是算得出来的。
all-to-all 就难了。MoE 每步各 token 选的专家都不一样,谁给谁发多少每步都变;几路争一条线,有的排队、有的空着。」

「所以 Qwen3.5 的公开博客比完两个方案,选了 all-gather 加 reduce-scatter,原话是 all-to-all 在负载多变时,网络路由的开销又大又不可预测。
图的是延迟可预测,平均快慢在其次。线上服务看的是最慢那一步,可预测比平均快更值钱。」

🖥 屏幕:往下指「想要的是厨房里切菜和炒菜同时开工」。

「还有一点 GPU 老兵容易忽略:TPU 上通信什么时候发,是 XLA 排的。
打个比方:你想让切菜和炒菜同时开工,可排班的大厨是 XLA。它把一串算子当一整块排,有权调顺序、回收缓冲区,⛔ 未必排出你要的那种重叠。
落到 profile 上,就是通信那条线在跑,矩阵单元那条在空等。后面会看到,这么露在外面的有两成时间。」

「⭐ 想藏到你想藏的地方,就得自己写 Pallas:先发起异步传输,接着算矩阵乘,要用结果时再等它到。顺序写死在 kernel 里,XLA 动不了。这句话后面会兑现。」

🖥 屏幕:往下指「片上:VMEM 和 SMEM 由 kernel 自己管。」,再指「工作台、仓库、便签本。」

「第三条,片上内存。三样东西打个比方:HBM 是仓库;VMEM 是工作台,每个 TensorCore 六十四 MiB,整颗芯片合起来才是仓库的一千五百分之一;SMEM 是便签本,更小,记页号、专家号这类小数字,kernel 拿它算下一步去仓库哪一格取货。」

「跟 GPU 最大的不同:工作台不会自己进货。数据不搬进 VMEM 就算不了,什么时候搬、搬什么,kernel 自己写:发起一次异步拷贝,到要用时等它落地。
所以都留两个槽,一个在算、另一个装下一块,5.1 的 RPA 就这么干。台面还能按段借:一段小 kernel 声明要多大一块,用完归还,K3 就靠这个。」

🖥 屏幕:往下指「布局按 tile 存。」,再指「算一个补齐的例子(本课推导)。」

「还有布局。显存按 tile 存,一块默认是八乘一百二十八个三十二位的格子,最内两维都要补齐。一个格子能装两个 BF16,或者四个 FP8。
算个例子,本课推的。TP2 以后每个 rank 一个 KV 头,RPA 把 K 和 V 并成一个打包维,每个 token 这一维只有两个数。」

「两个数往格子里放:BF16 一格装两个,正好满;FP8 一格能装四个,只放两个,空一半。⛔ 两种都是一千零二十四字节,FP8 一个字节没省下。
换成序列维放最内层,四个相邻 token 挤进一格,FP8 只占五百一十二字节,正好一半。这个例子等会儿在 14.2 要用。」

「第四条,数据格式。Blackwell 的张量核能直接算 FP4;v7 公开规格只列 BF16 和 FP8。
所以这里权重和 KV 存 FP8。比 FP8 更窄的格式,得先在向量单元上解包、乘回缩放倍数,才能喂给矩阵单元。这笔活落在向量单元上,账等会儿 K3 那里算。」

🖥 屏幕:滚到「14.2 这个模型落到 TPU,哪几处要特殊处理」,停在「先认清全注意力层:GQA,不是 MLA。」

「四条规矩讲完,回到这个模型。先认清一件事:Qwen3.5 的全注意力层是 GQA,不是 MLA。
三十二个查询头只配两个 KV 头,也就是十六个查询头共用一个,公开博客写的。每个 token 的 KV 只有三万字节出头,本课按 config 推的。」

「对照一下 MLA,DeepSeek 和 K3 用的。decode 时所有头对同一条压缩后的潜向量算,等于只有一个 KV 头;TP 切不开,八路 TP 下 KV 存八份,第六节开头那堵墙。
Qwen3.5 有两个 KV 头,好一点,但八路 TP 要切成八份,一个 device 摊到零点二五个头,切不了。⛔ 只能每个头复制到四个 device 上,KV 存四份。」

💬 互动:「八路 TP、两个 KV 头,每份 KV 存几份?换成八个 KV 头的模型呢?」请台下报数。期望答案:4 份;8 个头时 1 份,不用复制,公式是 TP 除以头数和 TP 里较小的那个。⏭ 时间紧可跳:直接说答案。

🖥 屏幕:往下指「复制 4 份的代价。」,再指「切法:注意力分请求,MoE 分专家。」

「复制四份要付多少?GQA 本来就是为了让 KV 变小,复制四份等于把省下的又吐回去。公开博客的说法:按 TP8 跑,HBM 被重复的 KV 占掉,并发只到二百左右,原计划是五百一十二。
所以两段各切各的:注意力按请求切,叫 DP;MoE 按专家切成八份,叫 EP。」

「按请求切,每个 device 管自己那批请求的全部头,KV 只存一份;每个核六十四条,八个核正好五百一十二。
MoE 那边,五百一十二个专家每个 device 六十四个。all-gather 让每个 device 拿到全部 token,各算各的本地专家,再 reduce-scatter 加回各自的请求。⭐ 这两个动作,正是 ICI 擅长的规整通信。」

「代价也要说:每个 device 要放下全部八份 token,比 all-to-all 多占本地内存,博客认这笔账,换的是延迟可预测。
prefill 用 DP8;decode 用 DP4 乘 TP2,这么一配,每个 rank 正好分到一个 KV 头,一份都不用复制。」

🖥 屏幕:往下指「缓存:KV 和线性层状态共用一个池。」,再指「分两个池,总有一个闲着。」

「第二处,缓存。KV 随上下文变长;GDN 状态每条序列一份、大小固定,一份顶六千多个 token 的 KV,13.2 算过。
两者的比例随请求长度大起大落,本课推的:一 K 的请求,状态占这条请求内存的八成多;六十四 K 的请求,状态只占一成不到。」

「分两个池会怎样?像分开的小车位和大巴位。按六十四 K 的流量把状态池定在一成,换成一 K 流量:状态池先满,能接的请求数被它卡死,KV 池将近全空,本课推的是约九成八闲着。反过来也一样。
统一池就是车位可互换:两种东西共用一种页,谁要谁领,前缀缓存也走这个池。」

🖥 屏幕:往下指「GDN 状态:换视图,不搬数据。」

「第三处,GDN 状态的布局。kernel 要的是按头排好的一百二十八乘一百二十八的方阵,池里的页按统一池的格式存,对不上。
笨办法是每个 tile 先读出来重排、写到别处再算,每步多一趟读写。
⭐ 做法是换视图:书不动,只换一张目录卡。bitcast 把同一串字节按另一种类型读,reshape 只改维度怎么数,都只改元数据。指令包从三百六十六个降到八十七个。」

🖥 屏幕:往下指「切序列时,线性层按头切。」

「第四处,切序列。PCP 把一条 prompt 摊到八个 device 上。全注意力层按 token 切没问题;线性层的状态得从头一路接力扫,按 token 切,后一段要等前一段交棒,八个 device 变成排队,7.2 那个问题。
怎么绕开?头和头不相干:每个头有自己的一块状态,各扫各的。」

「所以线性层改成按头切,像接力赛改成每人在自己的跑道上跑全程。进线性层前交换一次,从每人一段 token、全部头,换成每人全部 token、八个头,扫完再换回来。
GDN 有六十四个 V 头,八份够切。代价是每个线性层多两次交换,而且切的份数不能超过头数。」

🖥 屏幕:往下指「KV:序列维放最内层。」

「第五处,KV 的布局,就是刚才那个补齐例子。KV 存 FP8 的本意是每个 token 的字节减半;头维打包时,FP8 页跟 BF16 页一样大,⛔ 池子一个 token 也没多装。
让序列维放最内层,KV 那部分页能多装一倍的 token,本课推的。线性层状态另算:存 BF16,算的时候提回 FP32,等会儿讲。」

🖥 屏幕:往下指「MoE:整层一个 Pallas 程序。」

「第六处,MoE。它占 prefill 约八成时间,而 XLA 不把 reduce-scatter 藏到矩阵乘后面,这是第二条规矩。
⭐⭐ 做法是整层 MoE 写成一个 Pallas 程序,像流水线:一箱货装好就发车,不等整车装满。算完一批行,立刻发起送往目标 rank 的传输,接着算下一批,最后统一等它落地。通信就藏到矩阵乘后面了。」

「路由表呢?kernel 每发一行都要查这行归谁、加权多少,查表用的是标量,所以放便签本 SMEM。
它只有一 MiB,是 VMEM 的六十四分之一,token 一多装不下,就按窗口分批流进去。第三条规矩又用上了一次。」

🖥 屏幕:指「K3 对照①」那个框。

「K3 对照一条。K3 的部署手册写明,六十九层 KDA 的状态池,DP、EP、DCP 都不切它。DEP8 下每个 rank 都要存一整池状态,装不下,所以 K3 用 TP:TP 把头分出去,状态跟着头一起切小。
Qwen3.5 的统一池随 DP 切,DP 等于八实测跑通。⭐ 按请求切之前先算一笔:不随 DP 切的那一池,每个 rank 装不装得下。」

🖥 屏幕:滚到「14.3 怎么跑快」,停在「prefill 四刀,全砍在 MoE。」

「放得上之后,怎么跑快。理由跟前面几节一样:HBM 在空等,通信露在外面,布局把窄维补成整块。⭐ 最大的几刀,都是手写 Pallas 拿回调度权。
prefill 四刀,全砍在 MoE。」

🖥 屏幕:fig-s13-ladder,从左往右指五根柱,停在绿柱「整层融合」,最后指右边「同期实测」那根和下面那行连乘。

「看这张刀谱,起点记作一,柱里的小字是这一刀比上一级涨多少。
第一刀,SparseCore 合并,涨百分之六。瓶颈是补齐的中间张量:每个 token 选十个专家,十不是二的幂,在 TensorCore 上重排,会往 HBM 写一大片补齐、不对齐的数据。」

🖥 屏幕:往下指「第一刀,SparseCore 合并(×1.06)。」,再指「第二刀,通信切块(×1.09)。」

「SparseCore 是专为间接寻址做的单元:按路由表直接从 HBM 把 token 收拢到一块连续的地方,就地按目的地累加。补齐的那片不再落进 HBM,原文给的读写量:读减半,写只剩三分之一。
第二刀,通信切块,再涨百分之九:原来要等整块累加完才出发,切成四块,第一块好了就先发。⛔ 可 XLA 排出来,通信仍没跟计算叠上。」

🖥 屏幕:往下指「第三刀,整层融合(×1.26)。」

「⭐⭐ 第三刀是绿柱,整层融合,一刀涨两成六,比前两刀加起来还多。改前 reduce-scatter 约占两成时间,融合以后藏到了矩阵乘后面。
这个数对得上:两成时间全藏掉,最多快一除以零点八,一点二五倍。实测一点二六,量级正是把那两成藏干净,本课推的。」

「reduce-scatter 本身也是手写的:先在同一颗芯片的两个 TensorCore 之间加一轮,走片内共享内存,原文说比芯片间 ICI 快六倍;再在芯片之间交换。
第四刀,修剪 kernel,再涨百分之九。四级连乘约一点五八,同期实测约一点五九,只差半个百分点,本课推的。」

「拆得这么干净,靠的是每一刀先合进代码、默认关着、用环境变量打开,开关前后天然一组 A/B,10.2 讲的对照实验。」

🖥 屏幕:往下指「decode 三刀,砍布局和小 batch」那段。

「decode 三刀。decode 每步要把权重、KV 和状态各过一遍,卡的是 HBM 带宽,所以三刀都在少搬字节。
第一,KV 序列维放最内层,每个 token 每层从一千零二十四字节变成五百一十二,每步读 KV 的量减半。
第二,小 batch 时 MoE 不排序:所有 token 过一遍,没选中的乘零,每个被选中的专家只读一次,daily 基准涨约一成二。」

「第三,线性层状态存 BF16。状态每步每条都要读写一遍,字节减半;公开博客说向量单元的吞吐翻倍。省下的显存让 KV 池多装约一成二,同时在跑的请求也多了一成多。⛔ 精度验收还没收尾,课件原话。」

🖥 屏幕:指「K3 对照②」那个框。

「K3 走的是另一头。它只追一到八条,一步几乎全在读权重:按 config 推,一个 token 读约一百五十八 GB,本课推导。
Inferact 把九十二个 MoE 层装进一次 Pallas 调用,跑在十六颗 v7 上。挑三刀,每刀都说清卡在哪。」

「第一刀,层循环搬进 kernel。一个 kernel 是搬进来、算、写回去,搬之外的阶段和起步收尾,带宽都闲着,每个 kernel 来一遍。
⭐ 整步装进一个程序,权重就能片上放得下就提前发:第 N 层还在算,第 N 加一层的权重已经在路上。batch 这么小,带宽闲一刻就是白丢一刻。」

「为什么只能手写?跨层预取,缓冲区就得活过算子边界,而 XLA 有权回收它。在一个 kernel 里自己发起、自己等,就不跨 XLA 能动的边界。
第二刀,VMEM 分时复用:两种投影加四个专家槽各占一块要九十点六七 MB,放不进六十四 MiB;三样时间上不重叠,轮流借同一块,三十一点二九 MB 就够,本课按公开代码推的。」

💬 互动:「第三刀把专家从 MXFP4 换成 FP8,要读的字节多了六成。会更快还是更慢?」举手:更快 / 更慢。期望答案:更快,batch 1 卡住的不是带宽,是向量单元。多数人会举「更慢」。⏭ 时间紧可跳:题当设问念一遍,直接接下一块。

「更快。MXFP4 每三十二个元素,就要在向量单元上解包、缩放一次;FP8 每二百五十六个才一次,缩放活只剩八分之一。专家三块矩阵换两块,字节多一点六倍,本课推的。
⭐ 可 batch 等于一,带宽只用到五成上下,卡住的是向量单元。这就是第四条规矩:v7 公开规格里没有 FP4,更窄的格式要拿向量单元去换。」

「另几刀过一遍:专家槽轮转;集合通信按二乘二乘四的连线手写,换拓扑就得重写;同一个 kernel 兼做投机的验证器。
整个 megakernel 从零编译不到九十秒:顺序和重叠由写 kernel 的人一次排好,XLA 不用再去找。14.1 那笔编译账就便宜得多。」

🖥 屏幕:fig-s13-map,先上表(Qwen3.5 七刀)逐行扫,再下表(K3 八刀),最后指「空心 = 代价」。

「把两边的刀放进一张表。行是一刀,列是它解决的瓶颈。⛔ 定性归类,点的大小不代表收益。
上表 Qwen3.5,实心点扎在通信和形状;下表 K3,扎在 HBM 读写。⭐ 同一种芯片,刀落的地方完全不同,差别不在模型大小,在并发。」

🖥 屏幕:往下指「拆开不一定更快。」,再指「多副本时」那段。

「最后几句收口。拆开不一定更快:PCP8 收尾时吞吐是 DP8 的约零点八九倍,省的是长 prompt 的首 token 延迟,这句是本课推测;拆 PD 每请求要搬约三百四十九 MB,单并发零点九五倍。一台装得下,就先别拆。
多副本时用 KV 感知路由,把同前缀的请求送到存着它的副本。选栈先看模型在不在支持列表里,再看第十节的拓扑搭不搭得出来。」

🖥 屏幕:停在本节末尾「先看 batch 落在 1.1 的哪一侧」。

「回头看:四条规矩变了,每条都在这个模型上落成一处做法,切法、统一池、换视图、按头切、序列维最内、整层 Pallas。
⭐⭐⭐ 至于刀往哪砍,先看 batch 落在 1.1 那条线的哪一侧。
接手服务的第一天先问什么?最后一节,八个问题。」

⚠️ 这一节最容易跑偏的地方 📌 本节为深讲,不计入总时长:计划表和节标题都标「不计时」,地板单列、不进合计。讲的时候宁可慢,比方、机制、代价、为什么快四步一步不省。
⛔ 本节只讲做法,不讲排障:不讲踩过的坑、退化和修 bug 的经过;被问「上线时出过什么问题」答「本课只讲做对的样子」。
⛔ 梯子是私有实测指数化:台上只说「起点记作一」和每刀的相对涨幅,不报绝对吞吐,不跟别家比。被问绝对值答「私有数据,课件只给指数」。
⚠️ 本课推导的数口播要带「本课推的」:补齐例子的 1,024/512 字节、统一池 86%/9%/九成八、1 ÷ 0.8 = 1.25 的上限、「只差半个百分点」、一百五十八 GB、VMEM 九十点六七和三十一点二九 MB、多读一点六倍。VMEM 容量是 MiB、两块是 MB,别混。PCP 零点八九「省延迟不省吞吐」是本课推测。
⚠️ 「每颗 6 个邻居、远的要转手」是本课据环面拓扑推的;环形 all-gather 那段是通用算法示意,不是这台机器的实测。别说成「all-to-all 一定慢」,博客原话是「不可预测」。
⚠️ 32 个查询头、2 个 KV 头、64 个 V 头都按公开博客说;别顺手说「Qwen3.5 也是 MLA」,它是 GQA。
⚠️ FP4 只按公开规格说「v7 只列 BF16 和 FP8」,别说成「硬件肯定不支持」。
⛔ 主线栈 vLLM-TorchTPU 已于 2026-10-20 开源:仓库名可以念,PR 号指屏幕不念,不报作者;梯子上的倍数一律带基线(起点那天 = 1),PR 正文里的绝对数是另一套测法,别跟倍数混着说。SGLang-JAX 那两个 --precompile-* 参数指屏幕即可,不念。
⚠️ R16 口径(撤下口播的原数):HBM 每颗 192 GiB、SMEM 1 MiB(后者 14.2 路由表那里仍念);每个 KV 头 256 维;GDN 一份状态约 183 MiB(13.2);Hy4 冷编译 95 → 约 14 分钟;SparseCore 读 20 → 10、写 15 → 5(原文单位);线性层状态存 BF16 后同时在跑的请求 208 → 232(约 +12%,「一成多」)。
⚠️ fig-s13-map 只按图注讲「扎堆在哪一列」,不逐点念哪刀落在哪格;那是定性归类。fig-s13-bucket 的分布是本课推导示意,不是真实流量。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「为什么 TPU 要分桶?」→ XLA 按形状整图编译,形状一变就编一次;分桶像成衣尺码,把总数收成几档,开服前编好(14.1)。
🧑‍🎓 新人「桶是不是越多越好?」→ 补的零越少,但每个桶都要编一次;按分布的形状切,13 个 √2 档比 16 个等距档还省(14.1 图)。
🛠 GPU 老兵「GPU 上 CUDA Graph 不也要预先捕获吗?」→ 思路一样(12.3);区别是 GPU 档外照样跑,TPU 没编过的形状要现编,等 60–90 秒,档更得先定。
🛠 GPU 老兵「TPU 上为什么不用 DeepEP 那种点对点?」→ ICI 是 3D 环面、每颗 6 个邻居,all-to-all 在负载多变时开销不可预测;all-gather / reduce-scatter 每步每条线一样忙,延迟可预测(14.1、14.2)。
🛠 GPU 老兵「Qwen3.5 的 KV 为什么要复制 4 份,不是 8 份?」→ 它是 GQA 有 2 个 KV 头,8 ÷ 2 = 4;MLA 等于 1 个头才是 8 份(14.2、6.1)。
⚙️ TPU 工程师「GDN 换视图具体是什么?」→ 在引用上做 bitcast 加 reshape,只改元数据不搬数据,指令包 366 → 87(14.2)。
⚙️ TPU 工程师「路由表为什么放 SMEM 不放 VMEM?」→ kernel 每发一行都要按表算目标,查的是标量;SMEM 只有 1 MiB,所以按窗口分批流进去(14.2)。
🧑‍🎓 新人「线性层为什么不能按 token 切?」→ 状态要从头接力扫,按 token 切后一段等前一段交棒;改按头切,每个头在完整序列上扫(14.2、7.2)。
🛠 GPU 老兵「整层融合为什么能涨两成六?」→ 改前 reduce-scatter 约两成时间露在外面,藏干净上限 1 ÷ 0.8 = 1.25 倍,量级对得上(14.3)。
🛠 GPU 老兵「K3 那套能搬到别的拓扑吗?」→ 不能直接搬:集合通信按 2×2×4 连线手写,换拓扑就得重写(14.3)。
💰 管预算的「PD 分离值不值得上?」→ 一台装得下时先亏:每请求搬约 349 MB,单并发 0.95 倍;等两边负载真打架再拆(14.3、8.1)。
🧑‍🎓 新人「线性层状态存 BF16,精度不会掉吗?」→ 计算时提回 FP32;KV 池多装约一成二,精度验收课件写的是还没收尾(14.3)。
🛠 运维「TPU 上该用哪个栈?」→ JetStream 已停止维护;先看模型在不在支持列表里,再看第十节的拓扑搭不搭得出来(14.3)。

第十五节 第一天的八问(18′)计划 18′ · 含互动 15.8′ · 跳后 15.3′

🖥 本节主屏:课件 第十五节 第一天的八问 · 主图 fig-s14-eight

🎯 这一节只留一句:decode 每一步都要搬一趟;先算清这一趟多重、能分给几个人,再挑让更多人分、或者让它变轻的招。

🖥 屏幕:课件 s十五,停在导语「前四问算纸上的账,后四问拨开关。」

「最后一节。接手一个推理服务,第一天先问八件事:前四问算纸上的账,后四问拨开关。
顺序不能反:尺子没定,比出来的快慢,可能只是分母换了。」

🖥 屏幕:fig-s14-eight 整张,先指中间那趟车上的八枚图钉,再指右边「算账」「挑招数」两栏,最后指图注那四个号「3、4、7、8」。

「看这张图,还是第零节那一趟:仓库是显存,里面放着权重和 KV;工位是算力。每一问是一枚图钉,钉在它问的那个部件上。
颜色对着主线:灰色是校准尺子和上线,蓝色是分给更多 token,绿色是少搬,橙色是拆开放对地方。
⭐ 八问里有四问钉在车上:第三、四、七、八问。第七问是两枚钉,七 a 量化,七 b 投机。」

🖥 屏幕:滚到「15.1 前四问:算账」,指第一条「负载长什么样」。

「第一问,负载长什么样:输入输出多长,要哪个交互档。
⛔ 别以为这是背景信息:换一个档位,结论能整个反过来。每人出字慢一点,一步就能多拼几个人,每卡吞吐就涨;同一套系统,在这一档赢,到那一档可能就输。这是第二节那条吞吐和交互性的曲线。」

「第二问,用哪把尺子:数总量还是数每卡,分母里含不含 prefill 卡。第二节那张四把尺子的图,同一次测量,换个数法,最大差三十六倍。
⭐ 所以别人报一个吞吐,先问清分子数了哪些 token、分母除了哪些卡,再往下听。」

「第三问,字节下限:一步至少要搬多少字节。这一问最容易被跳过。
算出下限,再看实测:每步实测要是下限的好几倍,先查布局和调度,别急着加卡。⭐ 加卡治不了布局把窄维补成整块,也治不了调度让 HBM 空等。这是第一节和第五节的账。」

「第四问,放得下几条序列。batch 的上限由 KV 定:KV 池除以每条 KV,就是能坐几个人。
⭐ 它也就定了这一趟搬运,最多能分给几个人。这是第四节。
前四问问完,纸上的账就齐了:这一趟多重,能分给多少人。」

🖥 屏幕:滚到「15.2 后四问:挑招数」,指第一条「attention 怎么切」。

「第五问,attention 怎么切:先切法,后参数。第十节那组实测,换拓扑每卡两倍多,纯调参二十几个点。
⭐⭐ 拓扑定了那一趟搬运走哪条线、能分给多少人,参数只在这个上限底下挪。」

「第六问,拆不拆 PD,配几台。有尖峰,先试分块 prefill;压不住再拆。拆了,按两边各自的吞吐配台数。这是第九节。
第十四节刚看过反面:一台装得下时,拆开先亏。」

「第七问,量化和投机开不开。投机在并发小时最赚:K3 并发一,吞吐是不投机的四点二二倍;并发一大,收益就缩,第十一节讲过。
量化不一样,它总在减字节,第十二节。所以图上这一问是两枚钉:七 a 量化是绿钉,钉在车上的货,让货变轻;七 b 投机是蓝钉,钉在座位上,一趟分给更多 token。」

「第八问,上线前跑通了吗。没预编译,第一个用户就要等一分钟,第十四节那张冷启动图。
⭐ 这一问看着最不起眼,可它决定第一个用户对你的印象。」

💬 互动:「你接手的服务开了投机解码,压测反而变慢了。八问里先查哪一问?」期望答案:先查第一问负载(并发一高,投机收益就缩),再查压测口径(第二节点过名、11.2 画成图的温度坑:草稿和请求的温度对不上,接受率会崩)。有人答第七问,就接一句:开不开,得先知道负载和口径。⏭ 时间紧可跳:题当设问念一遍,直接接「先查负载,再查压测口径」。

「先查负载,再查压测口径:并发多高,压测用的什么温度。这两个坑第十一节都画过。
开不开投机是第七问,可答第七问之前,得先知道这两样。」

🖥 屏幕:停在 15.2 末尾的「八问归到一句话」。

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

🖥 屏幕:滚到「15.3 回到时间轴:系统这一侧省了多少」,先停在下面第一段。

「回到开场那道题。开场说的降价,是市场价,里面混着三样东西:更强的小模型、硬件换代、系统招数。
斯坦福那份报告主要归给小模型;硬件那份,给的是能效每年升百分之四十;系统那份,拆不出来。」

🖥 屏幕:指「Epoch AI(2025)」那段,再指下面「每行基线不同,不能连乘」那段。

「Epoch AI 二〇二五年换了个看法:固定一档能力,看达到它的推理要多少钱。结论是年年在便宜,二〇二四年以后降得更快。
恰好跟第八到第十二节那批招数进生产同期。⛔ 这是本课的观察,Epoch 自己没做归因,别说成系统招数降了多少。」

「系统那份拆不出来,就只能按年份,每一招各拿一个实测,排成下面这张表。
⛔ 每一行的基线都不同,不能连乘去凑市场上的降幅。只有表的最后一行,是同一硬件、同一模型上,叠满软件招数的总账。」

🖥 屏幕:指着年份表,先指「Orca 连续批」那行,再把 2024 那一格从上往下扫一遍,最后指第二列的环号。

「表按年排,每行一个倍数,都在课件上。我只带大家看三处。
第一处是起点:二〇二二年,Orca 每步换人,同延迟吞吐是 FasterTransformer 静态批的三十六点九倍,第三节讲过。
第二处是二〇二四年那一格,最挤:拆两段、分块、MLA、KV 池、FP8、磁盘缓存、MTP,好几个洞同一年一起补。」

「第二列写的是这一行补第零节哪一环。⭐ 每个倍数只回答一个洞,对照的对象也各不相同。第三处是最后一行,等会儿单独算。」

💬 互动:还停在表上,问「把这几行的倍数乘起来,能不能凑出开场那道题的答案?」举手。期望答案:不能,后一个的基线就是前一个。有人举「能」,就指「Orca 连续批」和 PagedAttention 两行各自的对照对象。

「乘不得。调度那行比的是 FasterTransformer;分页那行比的,已经有 Orca。
⭐ 后一个的基线,就是前一个。」

🖥 屏幕:指表的最后一行「叠起来」,再停在表下那条「开场那道题的答案就是末行」。

「最后算一笔大账。同口径的只有最后这一行:GB300 跑 V4-Pro,硬件、模型、交互档都不变,光改软件,每卡从首发日约两千二,到约一万一千二。
一万一千二除以两千二,五点一倍,这是本课推的;博客标题写五倍。
⭐⭐⭐ 这就是开场那道题的答案。」

「开场举五倍的,这回赢了。卡、模型、交互档都没换,涨出来的每个字都是软件挣的;卡价不变,每个字的成本约降到五分之一,这是 2.3 那条公式推的。
⛔ 这五点一倍是软件栈全部改进的合计,后来开的 MTP 也算在里面。」

🖥 屏幕:往下指「这 5.1 倍里 MTP 占多少,博客没拆」那段,再指下面 TensorRT-LLM 那段。

「那 MTP 占多少?博客没拆。它分开报的两条六月曲线,一条在四十那档、一条在八十那档,⛔ 档位不同,不能相减。
别处有一组干净的拆法,模型和卡都换了,只能当量级参考:TensorRT-LLM 跑 DeepSeek-R1,开三层 MTP,单用户速度涨到两倍多,本课一除;⭐ 开到五层,反而往回掉。」

🖥 屏幕:fig-s14-story,先指顶上红、紫两条竖线,再按调度、KV 与注意力、复用与下放、解码提速、拆开放、少搬字节六条泳道从上往下各点一下,最后停在「这些倍数不能连乘」那个框。

「这张是分类账:上面那张表按年记流水,这张图把同一批招数按六类分户。卡片落在首次公开的年月上;虚线卡是模型侧的进步,比如 GQA、MLA、DSA。
顶上两条竖线是推着各泳道的两股压力:红的是上下文变长,128K 到 1M;紫的是输出变长,o1 和 R1。」

「从上往下六条泳道:调度,一批里谁进谁出;KV 与注意力,多装几个人、读得更快;复用与下放,算过的不再算;解码提速,搬一趟出几个字;拆开放,拆阶段和拆模型;少搬字节,量化和合并 kernel。
最顶上那张横卡就是五点一倍,叠起来的总账。」

「图上比表多几张卡,Flash-Decoding、Splitwise、TPU megakernel 这些,倍数和要点都写在卡上。
⭐⭐ 图里那个框,就是刚才那道题的答案:这些倍数不能连乘。口径也不同:有的是吞吐,有的是单请求延迟,有的是达标请求数,有的只是显存。」

🖥 屏幕:往下停在「落到真实账上,看 DeepSeek 公开的一天」,fig-s14-day 那根三段横条从左往右指,最后指下面「每卡每秒约 4,950 token」。

「落到真实账上,看 DeepSeek 公开的一天,二〇二五年二月底,V3 和 R1 的线上服务。条长按 token 数画,一天七千七百多亿个 token。
⭐ 先看比例:近八成是输入,输出只有两成出头。输入里一半多命中了 KV 缓存,就是最左边紫色那段,占全天四成多。」

「摊到全部卡上,全天平均每卡每秒约四千九百五十个 token,输入输出都算,本课推的。⛔ 分母是全部卡,不是 decode 卡的峰值。
这套服务用的,正是表里那几行:MLA、大 EP 加 PD 分离、磁盘 KV 缓存、FP8。⭐ 紫色那一大段,就是磁盘 KV 缓存替 prefill 省下的。」

💬 课后题:「Inferact 那个单用户每秒七百多个字,拉了哪几根杠杆?」答案:只拉了一根,投机解码,车上多坐人。megakernel 不在三根杠杆里:它不少搬字节,去掉的是 kernel 交接时的空等;博客也没提量化(12.3、第十二节末的回到主线框)。答「两根」的,追问一句:megakernel 少搬字节了吗?下次课开头收。

🖥 屏幕:停在 15.3 末尾那段「回到 2022 年那一批人」。

「回到二〇二二年那一批人,按问题再串一遍:等最长的那个,就每步换人;座位却不够,就分页、压薄、复用;长 prompt 插队,就切块,再拆成两批机器;MoE 拆散 batch,就大 EP;prefill 喂不上,就重配台数;输出变长,就投机,再少搬字节。」

「下一个洞已经露出来,就是第十三节那件事:线性层的状态截不开,前缀难复用;tpu-inference 上跑 Qwen3.5,前缀缓存至今还得关。
谁再报个倍数,先问三句:比的是谁,哪一档,分母几张卡。」

🖥 屏幕:翻回「0.2 一个请求的一生,和全课一句话」那个「一句话」框。

「整门课只有一句话:decode 每一步都要把权重和 KV 从显存里搬一趟;每一招,要么让这一趟分给更多 token,要么干脆少搬。加上拆开两段,就是第零节那三根杠杆:车上多坐人,货变轻,开两个仓库。型号会换,数字会过期,这一句不会。
同一张卡,四月首发那天出一个字的工夫,六月出五个。这份是系统挣的,一招一招叠出来的。」

⚠️ 这一节最容易跑偏的地方 ⚠️ 系统那笔只认 5.1 倍,口径是同卡、同模型、同交互档;被问市场降价,别给倍数,课程不引价格口径的数。
⚠️ 年份表和 fig-s14-story 卡上那些倍数不能连乘:后一个的基线常常就是前一个。被问「加起来快了多少倍」就这么答。
⚠️ 八问每一问都讲,每问落一句「第几节」;第三、五、八问是最容易被跳过的三问,讲到时语气加重。
⚠️ Epoch 那段是本课观察,Epoch 没归因;GQA 五点四倍、MLA 五十七分之一、V3.2 一点六三倍、5.1 倍、四千九百五十都是本课推导,口播带「推的」。
⚠️ 收尾那一句念完就停,别再补「还有什么问题」之外的话。
⚠️ R16 口径(撤下口播的原数,被问照这里答):第五问 DEP 对 TP4 每卡 2.09 倍、只调并发 +28%。年份表不逐行念,各行倍数指课件。MTP 两条六月曲线:不开 MTP 在单用户 40 token/s 档 2.1 倍、开 MTP 在 80 档 2.6 倍。TensorRT-LLM 八张 B200 跑 R1:111 → 一层 198 → 三层 253 → 五层 239 token/s,「两倍多」= 253 ÷ 111 ≈ 2.28(本课一除)。DeepSeek 一天:共 7,760 亿 token,输入 6,080 亿(78.4%),其中命中 KV 缓存 56% = 3,420 亿(占全天 44%),未命中 2,660 亿(34%),输出 1,680 亿(约 22%);平均 226.75 个 H800 节点 × 8 = 1,814 张卡。
❓ 台下可能问(备答,不计地板;数都在课件上)
🧑‍🎓 新人「八问要背下来吗?」→ 不用,图上都有;记住顺序就行:先对齐尺子和负载,再挑招。
💰 管预算的「只能先做一件,做哪件?」→ 课件没有按成本排序。本课的建议就是八问的顺序:先校准尺子,再选拓扑,最后才调参数;第十节换拓扑每卡两倍多,纯调参二十几个点。
💰 管预算的「这一套做下来,每个字的成本能降多少?」→ 只认同口径:同一套卡、同一个模型、同一个交互档,光改软件每卡是首发日的 5.1 倍;卡价不变,每个字的成本约降到五分之一(本课推导,2.3)。档位放宽还能更多,但那是拿跟手换的。别拿市场降价对标,那里面主要是模型变小。两个前提:卡价不变;「每卡」按全部卡(含 prefill 卡)算。博客没写明分母,若只除 decode 卡、prefill 卡数又没跟着降,全部卡的成本降幅会小于 5 倍;比值 5.1 本身不受分母影响(本课推导)。
🛠 GPU 老兵「5.1 倍里 MTP 占多少?」→ 官方没拆,只能说是软件栈全部改进的合计,其中包括后来开的 MTP。博客分开报的两条曲线(不开 MTP 在 40 那档 2.1 倍、开 MTP 在 80 那档 2.6 倍)档位不同不能相减。量级可参考 TensorRT-LLM 那组:八张 B200 跑 R1,开三层 MTP 单用户从一百一十一到二百五十三,但模型和卡都不同,不能套进 5.1。
💰 管预算的「真实线上一张卡每秒处理多少 token?」→ DeepSeek 公布的那一天,合每卡每秒约 4,950 个,输入输出合计、全天平均(本课推导),近八成是输入(15.3)。
💰 管预算的「不动软件,光等硬件换代能降多少?」→ AI Index 给的硬件账是能效每年升 40%。系统那份从市场降价里拆不出来,同口径只认 GB300 那笔 5.1 倍(15.3)。

🚧 这份讲义还薄的地方

  • [ ] 2026-10-18 全部重写到专题四的深度后还没试讲过。每节时间是按地板算的,第一次讲完按实际用时回来改;第十一节动画两次停顿的时间没算进地板。
  • [ ] 每节的录音、视频还是重写前的旧版,跟现在的逐字稿对不上,要重录。
  • [ ] 课后题放在第十五节 5.1 倍讲完之后,还没试过台下答不答得上。 备选题:「K3 一趟用时变成 1.45 倍、每步接受 6.96 个字,每个字快几倍?」(4.81 倍,见 fig-s11-bytes;追问端到端为何只有 4.22 倍:含首字时间。)