把 prefill 搬走之后:2026 年 11 月这波 PD 拆分,账单到底落在谁身上
2026 年 11 月 11–18 日这八天,vLLM、AWS、Cerebras 先后发布四份材料,把 prefill、decode、编码拆到不同硬件上跑。本文把这件事还原成一张网络账单:KV 搬运时间与 prefill 计算时间之比 R(忽略注意力二次项时)与 prompt 长度无关,只取决于「每 token 的 KV 字节数 × 算力」与「激活参数 × 链路带宽」之比。按官方规格推算,200B 级 GQA 模型在 400 Gb/s 上 R≈7.6%,在 100 Gb/s 上约 30%;30B 级 MHA 在 100 Gb/s 上约 121%。R 只是网络预算指标,不是收益判据:公告里的 2.05×(每卡)与 5×(每兆瓦)分别买的是不同的东西。文内 R 表与时间表为规格推算,非真机实测;引用的厂商倍数为其真机实测值。
四个发版公告,其实在说同一件事
先把四份材料按时间摆开。它们都在讲「把推理拆成几段、放到不同硬件上」,但各自的账本不一样。
- 11 月 11 日,vLLM 博客发《Encoder Disaggregation in vLLM》,把多模态请求拆成**编码(E)→ prefill(P)→ decode(D)**三段,并给出 metadata-only 路径:编码实例只回布局元数据,下游实例直接消费远端 embedding,不重复预处理媒体。
- 11 月 17 日,AWS 发《Managed NVIDIA Dynamo on Amazon SageMaker HyperPod Inference》,把 prefill 与 decode 放进两个 worker 池,KV cache 走 EFA 在池之间搬;给出的实测是 Qwen3-235B-A22B-FP8 在 16 张 H200 上,在「P90 TTFT < 1 秒且每用户中位 ≥ 50 token/s」的约束下,分开跑比混着跑多 2.05 倍输出吞吐(207 对 101 output token/s/GPU)。
- 同一天,Cerebras 发《Cerebras Launches Disaggregated Inference》:prefill 交给 AMD Instinct GPU,decode 留在晶圆级引擎上,生产实测相对 CS-3-only 基线(同一 GPT-OSS-120B 端点、归一化到聚合部署 1×)拿到 5 倍每兆瓦 token 数,且原文写明「token 生成速度无损」;硬件底牌是 350× 的 SRAM 容量、5,400× 内存带宽(对比典型 GB300 GPU)。
- 11 月 18 日,AWS 又发 ElastiCache 分布式 KV 缓存 GA:把 KV 状态放进与 GPU 同可用区的
cache.i8ge.48xlarge,经 EFA 上的 RDMA 读写,宣称「每百万 token 成本最多降 40%、TTFT 最多降 80%」。
四份材料放在一起,能看出一条共同的因果链:prefill 与 decode 是两种完全不同的负载,混在一起时互相踩;拆开以后,中间多了一样必须跨节点搬运的东西——KV cache。 于是所有关于「拆得值不值」的讨论,都会先撞到同一个问题:搬 KV 的时间,占 prefill 本来要花的时间多少。
这篇文章把这个比值推出来,用官方规格代入算一遍,然后说明它能和不能回答什么问题。
热度依据:11 月 11–18 日这八天到底发生了什么
按本站对「热度」方向的要求,热度不能只写「最近很火」,要给可核验的信号。本轮采集到的官方信号(全部为厂商官方博客,页面 200 且正文可读):
- 2026-11-11 vLLM 官方博客:EPD 拆分,metadata-only 支持 DeepSeek V4.1 Flash(vLLM main 上的 #62802;核心能力进 v0.32.0)。
- 2026-11-17 AWS Machine Learning Blog:托管 Dynamo 登陆 SageMaker HyperPod Inference,明确写出「disaggregated prefill and decode」与 KV-aware routing。
- 2026-11-17 Cerebras 官方博客:拆分推理进入生产,给出「5× tokens per MW」的归一化曲线(数据源标注为 11 月 14 日的共享 GPT-OSS-120B 端点,图注未标年份)。
- 2026-11-18 AWS Database Blog:分布式 KV 缓存 GA,给出成本与 TTFT 的端点值,并附 KVTrace 试算工具。
另有 2026-09-29 的 vLLM《A Practical Guide to Disaggregated Serving》作为方法论补充材料——它不属于这八天的发版潮,但把 goodput 这个口径讲清楚了,本文引用它的定义。
八天内三次发版加一篇方法论长文,说明这不是单家厂商的偏好,而是整个推理栈在同一季度往同一个方向挪。判断热度是否成立,看的是这个密度,而不是某一条推文的情绪。
直觉:把两件互相打架的活拆开
用一个工厂的类比。车间里有两道工序:配料和炖煮。
配料是「一口气把整张单子处理完」——几百份原料同时下锅,机器转得飞快,但要占用全部操作台;炖煮是「一份一份慢慢来」——每份都要回锅看一眼,占用的是另一套资源。
如果两种工序共用同一个车间:来一张大单,配料阶段会把所有操作台占满,正在炖的那几十锅全部停火等;反过来,为了不打断炖煮,就只让配料用一小块台面,于是一张大单的等待时间被拉得不可接受。
这就是 prefill 与 decode 的关系。prefill 是计算受限的矩阵乘,一次把整个 prompt 的所有 token 并行算完;decode 是访存受限的,每生成一个 token 都要把参与计算的权重再读一遍,算力几乎闲着,靠把很多请求拼成一个大 batch 才摊销得动。
拆开的价值不是「更快」,而是两边各自按自己的最优批处理与并行度跑。代价是:prefill 算完的中间状态(KV cache)必须送到 decode 那台机器上,否则 decode 无法接着生成。
这张图想说明的一件事:拆分没有减少任何一步的工作,它只是让被搬运的那一段显式暴露在时间线上——于是它占多少,成了第一个要算的数。
符号约定与术语表
| 符号 | 含义 | 单位/取值口径 |
|---|---|---|
| prompt token 数(prefill 输入长度) | 个 | |
| 模型层数 | 层 | |
| 查询头数 | 个 | |
| KV 头数(GQA/MQA 折减后的头数) | 个 | |
| 每个注意力头的维度 | 维 | |
| KV 每元素的字节数(FP16=2,FP8=1) | 字节 | |
| 每 token 的 KV 字节数 | 字节/token | |
| 每 token 激活参数量(MoE 只算被激活的专家) | 个 | |
| 总参数量 | 个 | |
| 加速器算力(本文一律用稠密值) | FLOP/s | |
| 算力效率,取 0.35 | 无量纲 | |
| 链路或显存带宽 | 字节/s | |
| 链路效率,取 0.8 | 无量纲 | |
| 显存带宽效率,取 0.7 | 无量纲 | |
| 一次 prefill 的计算时间 | 秒 | |
| KV 从 prefill 侧搬到 decode 侧的时间 | 秒 | |
| 传输时间 / prefill 计算时间 | 无量纲 | |
| KV 前缀命中率(按 token 计) | 0–1 |
| 术语 | 一句话定义 |
|---|---|
| prefill | 把整段 prompt 一次性过模型、生成首 token 并建好 KV cache 的阶段,计算受限 |
| decode | 逐 token 自回归生成,每步读参与计算的权重与新 KV,访存受限 |
| TTFT | time to first token,首 token 延迟,主要由排队 + prefill + 传输决定 |
| ITL / TPOT | inter-token latency / time per output token,相邻 token 间隔 |
| goodput | 同时满足 TTFT 与 ITL 目标的前提下能承受的请求速率,区别于裸吞吐 |
| PD 分离 | prefill 与 decode 跑在不同实例上,KV 经网络搬过去 |
| EPD 分离 | 在其上再拆出编码阶段(多模态),三段各自独立扩缩容 |
| KV Portal | Cerebras 的搬运算子,把 KV 经 RDMA 在 prefill 与 decode 引擎之间传递 |
| EC connector | vLLM 侧把编码器输出(embedding)送到下游实例的连接器,见来源 3 |
后面所有推导只用四个量:、、、。
混在一起时,prefill 是怎么偷走 decode 的时间
先看混跑时的一次迭代。一个 batch 里既有「正在做 prefill 的新请求」,也有「正在逐 token 输出的老请求」,那一步的总时间近似由两部分拼成:
第一项是这一步塞进去的 prefill 分块耗时,第二项是以 batch 大小 做一次 decode 的耗时。服务器在一次迭代里只能有一个瓶颈,但它必须等两步都做完才能进入下一步,所以老请求的 token 间隔被拉长到 。
这就是分块 prefill(chunked prefill)的由来:把长 prompt 切成 个 token 的小块,一次迭代只算一块。
这个式子里藏着一个两难。设 受显存与算力约束大致固定,那么:
- 想压 TTFT,就要让 小,也就是 大——但 大意味着每一步花在 prefill 上的时间多,正在输出请求的 ITL 被拉长;
- 想压 ITL,就要让 小——但长 prompt 要被切成更多块,TTFT 线性变差。
同一组 GPU 上,TTFT 与 ITL 是同一个旋钮的两端。 这不是调参水平问题,是资源复用带来的结构性矛盾。把两者放到不同硬件上,这个旋钮才被一分为二。
排队论能给一个直觉(注意:下面是 M/M/1 单服务台的平均等待,需要泊松到达与指数服务时间假设,GPU 上的动态 batching 并不满足这些条件,所以它只是解释性模型,不是预测工具)。设到达率 、服务率 ,利用率 :
混跑时,prefill 的突发把瞬时 推到接近 1,平均等待随之发散;同时 prefill 分块直接占住迭代时间,等效地把服务率 压低。拆开以后,prefill 池与 decode 池各有自己的 与 ,互不污染——但平均利用率低于 1 并不保证分位数达标,真正的达标与否必须靠实测的 P90/P99 曲线判断。
拆开真正多赚的是 goodput,不是吞吐
这里必须先把口径分清,否则所有倍数都会变成营销数字。vLLM 那篇方法论长文给的定义很直白:拆分不承诺每卡每秒吐更多 token;它承诺的是「在仍然满足延迟目标的前提下」能接住多少请求,也就是 goodput。
同一篇文里给的两组数:在单台 8 卡 MI300X 上,100 个请求里有 73 个同时满足「TTFT ≤ 1 秒 + ITL ≤ 50 毫秒」,而混跑只有 30 个,约 2.4 倍 goodput;该文还援引 llm-d 的 P/D 指南,称其在 16 张 H200 上跑 gpt-oss-120b 报告平均端到端延迟低约 59%、P95 低约 67%——这一组是二次转述,本轮未定位到 llm-d 的原始基准表,只能算「vLLM 综述援引」。
AWS 那组数字要按同一把尺子读:2.05× 的 207 对 101 token/s/GPU,是先筛掉不达标点、只在 P90 TTFT < 1 秒且每用户中位 ≥ 50 token/s 的点里比吞吐得到的。如果只比裸吞吐、不要延迟目标,把同样的卡切成两个池,未必能多吐 token——因为池变小了,并行度也变小了。
这两个量在低负载时几乎没有区别,在高负载时能差一倍以上。所以看到任何「拆分提速 N 倍」,第一个问题永远是:在什么延迟约束下、用什么口径算的。
分块 prefill 的一次算例:8k prompt 上 TTFT 与 ITL 怎么互相挤
抽象的两难不如一组具体数字。取一个 7B 稠密模型()、24 层、、、KV 用 FP16,跑在 H200 上按 FP8 稠密 1,979 TFLOPS × 0.35 的效率;prompt 8192 token,decode 侧单步时间设为 12 ms(含通信与调度开销)。
先算每 token 的 prefill 时间:
于是分块大小 决定一次迭代里 prefill 占多少:。一次迭代的总时间还要加上 decode 的 12 ms:
| 分块大小 | 迭代数 | 每次迭代 | TTFT | 同批请求的 ITL | 是否满足 1s / 50ms |
|---|---|---|---|---|---|
| 512 | 16 | 22.3 ms | 357.6 ms | 22.3 ms | 都满足 |
| 1024 | 8 | 32.7 ms | 261.6 ms | 32.7 ms | 都满足 |
| 2048 | 4 | 53.4 ms | 213.6 ms | 53.4 ms | ITL 违约 |
| 4096 | 2 | 94.7 ms | 189.6 ms | 94.7 ms | ITL 严重违约 |
读法很直接:把 TTFT 从 357.6 ms 压到 189.6 ms(省 47%),代价是同批请求的 token 间隔从 22.3 ms 恶化到 94.7 ms。 这就是同一个旋钮的两端。
拆开以后这张表的结构就变了:prefill 池可以放心用大块(甚至不做分块、一次算完),因为它的延迟只体现在 TTFT 上;decode 池完全不做 prefill,ITL 只由自己的 batch 决定。两个 SLO 从「竞争同一批 SM」变成「各自独立的两个约束」。
一次量级检查:2.05× 那组数的自洽性
公告里的数字容易让人将信将疑。可以用 Little 定律做一个量级检查(不是验证,因为缺少平均系统逗留时间这一实测项)。稳态下系统内并发数等于到达率乘以逗留时间:
AWS 那组数的口径是 16 张 H200、每请求 200 个输出 token。分离部署 207 output token/s/GPU:
公告写的最优点并发 80,反推隐含的平均系统逗留时间:
而 decode 阶段按「每用户中位 50 token/s」走完 200 个 token 只需 4.0 秒——4.83 秒比 4.0 秒多出的 0.83 秒,正好落在排队、首 token 等待与传输的位置上,两者相容。
混跑那一侧:101 token/s/GPU → 请求/秒,按 4 秒 decode 时间算 ,公告写 32,差 1.0%。
结论只能是「数量级相容」,不能更强。 这组检查说明公告的并发与吞吐不互相矛盾;它不证明 2.05× 的统计口径可靠,因为真正的判据是不同并发下的 P90 曲线,而那需要原始数据。这一点本文没法替读者补上。
KV 搬运的账单:一个与 prompt 长度无关的比值
现在进入本文的核心。把一次 prefill 的 KV 体积写出来。每层每个 token 要存 K 和 V 各一份,每份有 个头、每头 维、每维 字节:
整段 prompt 的 KV 体积就是 。搬运时间按有效带宽算:
prefill 的计算时间,主项是权重矩阵乘,每参数两 FLOPs,MoE 只算激活的部分(注意力二次项单列在下一节):
两式相除—— 被约掉了:
这个结果值得停一下。 通常的直觉是「prompt 越长,KV 越大,搬运越吃亏」。但在忽略注意力二次项、效率固定的这组假设下,prefill 计算量同样随 线性增长,两者一起长大,比值不动。
真正决定 的只有四件事:每 token 的 KV 字节数、算力、激活参数量、链路带宽。长 prompt 不会让搬运的相对代价变高;绝对时间变长,相对占比不变。(下一节会补上二次项对这条结论的修正。)
也因此, 是一个网络预算指标:它说「这条链路够不够快」,不说「拆了能不能赚钱」。收益要看 goodput 曲线,成因是混跑干扰减少、排队行为改变、两池各自调优——这些都不在 里。
给定一个可接受的占比 ,可以反解出最低需要的链路带宽:
这条式子是选型时的第一道筛:先定你能忍多少开销,再看网络够不够。反过来也成立——只有 100 Gb/s 机器间链路时, 就在 30% 上下,想更低只能换拓扑。
带宽分档:把官方规格代进去
硬件一侧数字全部来自 NVIDIA H200 官方规格页(2026-11-20 读取):141 GB HBM3e、4.8 TB/s 显存带宽、FP16 Tensor Core 1,979 TFLOPS、FP8 Tensor Core 3,958 TFLOPS。规格表脚注写明含稀疏加速,本文一律按稠密折半使用(989.5 / 1,979 TFLOPS),再乘 0.35 的效率系数。
模型侧取三档典型结构。请注意:这是按公开 GQA/MHA 常见取值建模的参数化配置,不是对任何具体模型 config 的逐字段引用。
| 配置 | ||||||
|---|---|---|---|---|---|---|
| 200B 级 GQA | 94 | 4 | 128 | 2 | 22B | 188.0 KiB |
| 400B 级 GQA | 94 | 8 | 128 | 2 | 40B | 376.0 KiB |
| 30B 级 MHA | 64 | 32 | 128 | 2 | 30B | 1024.0 KiB |
链路取三档:单口 100 Gb/s(12.5 GB/s)、400 Gb/s EFA(50 GB/s)、8 路 400 Gb/s 聚合(400 GB/s)。站内自算脚本 exp-2026-11-20-kv-budget.py 的输出:
| 模型配置 | 100 Gb/s | 400 Gb/s EFA | 3.2 Tb/s 聚合 |
|---|---|---|---|
| 200B 级 GQA(188 KiB/token) | R = 30.3% | R = 7.6% | R = 0.95% |
| 400B 级 GQA(376 KiB/token) | R = 33.3% | R = 8.3% | R = 1.04% |
| 30B 级 MHA(1024 KiB/token) | R = 121.0% | R = 30.3% | R = 3.78% |
三行读完,能读出三条:
- GQA 把 KV 压下来,是跨机拆分可行的前提。 同一个 30B 级模型若用 32 个 KV 头的 MHA,每 token 要搬 1024 KiB,是 200B 级 GQA 的 5.4 倍,在 100 Gb/s 上搬运时间比(线性口径的)prefill 计算还长(121%)。
- 400 Gb/s 是当下跨机拆分的常用档。 在这一档,两档 GQA 模型的搬运开销在 8% 上下。
- 聚合链路把开销压到 1% 量级。 3.2 Tb/s 下两档 GQA 分别 0.95% 与 1.04%,MHA 档仍有 3.78%——「不到 1%」只对第一档成立,MHA 结构在同样链路上仍要付 3.8%。
再看绝对时间(200B 级 GQA、4000 token prompt、H200 FP8 稠密 1,979 TFLOPS × 0.35):
| 链路 | 4000 token 的 KV 体积 | prefill 计算时间 | KV 搬运时间 | 搬运占比 |
|---|---|---|---|---|
| 100 Gb/s | 0.717 GiB | 254.1 ms | 77.0 ms | 30.3% |
| 400 Gb/s EFA | 0.717 GiB | 254.1 ms | 19.3 ms | 7.6% |
| 3.2 Tb/s 聚合 | 0.717 GiB | 254.1 ms | 2.4 ms | 0.95% |
这张表顺手回答了「一次 4000 token 的请求要搬多少数据」:0.72 GiB。AWS 的压测口径正是 4,000 输入 + 200 输出 token,所以在 400 Gb/s 量级链路上,按本文假设搬运对 TTFT 的贡献是十几毫秒,比 1 秒目标低一个数量级以上。这是「与 2.05× 相容」的一种解释,不是它的证明——AWS 没有公布这条关键路径的分解。
反解最低带宽,同一个 200B 级配置:
| 能容忍的搬运占比 | 最低链路带宽 |
|---|---|
| 5% | 606.1 Gb/s |
| 10% | 303.1 Gb/s |
| 20% | 151.5 Gb/s |
这三个数字可以直接拿去做初筛。 想要「搬运开销不超过一成」,跨机就得 300 Gb/s 以上的互联;只有 100 Gb/s 通用以太的集群,要把三成 prefill 时间花在搬数据上——除非用 L2 缓存让一部分 token 免于重算(注意:那部分 token 仍要经 RDMA 从缓存读回,省的是算力不是带宽)。
搬运可以流水化:R 是上界,不是必然开销
上面的 R 假设「prefill 全部算完才开始搬」。工程实现通常按层流水:算第 层时搬第 层的 KV。下面是理想流水模型(用于说明量级,不对应任何厂商实现):
其中 是最后一层 KV 必须在 decode 首步之前到位的那一段。两条推论:
- 时,搬运大部分可被隐藏。 暴露量降到 量级(约 )。200B 级 GQA 在 400 Gb/s 下 R = 7.6%,按此模型尾段约 19.3/94 ≈ 0.2 ms——这个 0.2 ms 不含协议、调度、争用与完成通知开销,真实值只会更大。
- 时,暴露量变成线性惩罚。 30B 级 MHA 在 100 Gb/s 上 R = 121%,暴露时间约为 ,相当于把 prefill 时间放大 21%。在本文假设下,这意味着拆分在这条链路上要先解决网络预算问题,而不是先讨论收益。
所以准确的说法是:R 是「网络预算」的判据,不是「拆分收益」的判据。 R 小只说明拆分在网络上不受限;R 大说明换拓扑(多口聚合、NVLink 域)或换路线(L2 缓存)应当排在拆分之前。
流水化本身的前提也容易被忽略:
- 必须能分层流水。 一次性生成全部 KV 再发的实现拿不到这个收益,暴露量就是全额 。
- decode 首步必须等全部层到齐。 分块到达可以边收边建页表,但 至少是一层的传输时间。
- 小消息的达成率低于大消息。 把一次大传输拆成很多次小传输,链路效率与抖动都会变差,这一项在公告里没有披露。
从 token/s/GPU 换算到每百万 token 的账
公告给的是 token/s/GPU,机房账本要的是每百万 token 的成本。两者之间隔一个 GPU 小时单价。设单卡每小时价格 ,每卡每秒产 个 token:一小时单卡产出 个 token、花掉 ;凑够 个 token 需要的卡时是 :
代入 207 token/s/GPU,并假设 美元/卡时(示例假设,不是任何厂商的报价):
同样假设下,101 token/s/GPU 得到 8.25 美元。两者之比就是 2.05——同一批同型号卡时,成本倍数与吞吐倍数是同一个数。 一旦像 Cerebras 那样换硬件,就必须回到每兆瓦的口径。
还有一个常被漏掉的成本项:拆分会增加一份权重副本。AWS 原文写明两个池都加载全量权重,所以「拆开省显存」是错的预期;省下来的是调度冲突,多花的是一份权重与一套运维。
L0/L1/L2:把「重算」换成「读缓存」
前面几节都在算「怎么搬得更快」。11 月 18 日那份 ElastiCache 公告提供了另一条路:减少需要重算的次数,把计算换成读取。
它把 KV 缓存分三层:L0 在 GPU 显存里(最快,装不下多少)、L1 在本机内存与本地 NVMe(大一些,只属于这台机器)、L2 是跨机器共享的分布式层(cache.i8ge.48xlarge,与 GPU 同可用区,走 EFA 上的 RDMA)。请求进来按 L0→L1→L2 顺序查。
这里必须把语义说准:L2 命中不是「不用搬」,而是「用 RDMA 读回 KV 代替重算」。 AWS 原文给的参考量级是:从缓存读 1 GB 数据(8 MB 对象 ×128)的 P50 约 41.7 ms。命中把「计算成本」换成「读取成本」,网络字节数并没有减少,反而多了一条 L2→GPU 的路径。
设前缀命中比例为 (按 token),剩余 个 token 仍要算一遍:
三条推论:
- 只省计算,不省带宽。 命中率高时, 依然随命中 token 数线性增长——这就是为什么 L2 通常与 PD 拆分一起上,而不是替代它。
- 命中是部分命中,不是整条请求跳过 prefill。 新输入的那部分 token 永远要算;把「命中」写成「跳过 prefill」,会让人以为长对话的第二轮几乎零成本,这是错的。
- 收益由实验口径决定,不由单一 推导。 AWS 原文的 40% 是在「SLO 下 RPS 翻倍、并计入缓存节点成本」的实验条件下得到的;80% 的 TTFT 降幅同样是端点值。把它们写成「 接近上限时的端点」,是把实验口径压缩成一个参数,容易误导读者去做纸面推算。
第二层的差别在于省的是什么:PD 拆分省资源争用(把两类负载分开),L2 缓存省重复计算(同一段前缀不算第二遍)。二者叠加时, 里同时有 的 prefill 项和 的读取项。
这张图想说明的一件事:缓存把「重算」换成了「读取」——它不降低任何一次传输的成本,只是让一部分请求不必重新计算。
为什么 Cerebras 的 5× 和 GPU 阵营的 2.05× 不能直接比
两家给的倍数差了一倍多,很容易被拿去做「谁更强」的比较。但把口径拆开就知道,它们度量的不是同一个量。
先看 decode 的算术强度。decode 每生成一个 token,要做大约 FLOPs;同时要读一次参与计算的状态。这里有一个口径分叉:
- 稠密口径:每步读全部权重 ,这是传统稠密模型的情形;
- MoE 口径:每步只读被激活的专家(加共享与注意力权重),约为 。
代入 FP8()、200B 总参数、22B 激活:稠密口径 ,MoE 口径约 2.0 FLOP/字节。而 H200 的脊点是
两个口径都远低于 412,所以「decode 是访存受限」这个结论不变;但数值差 9 倍,必须标明用的是哪一个。 本文后面提到具体速率时一律注明口径。
单流速率同理,写成两个界:
稠密口径下带宽界约 16.8 token/s(),MoE 口径下约 152 token/s(除以 22B 激活)。这两个数的共同点是:算力界(15,742 token/s)比带宽界高两三个数量级,说明单流 decode 的瓶颈在带宽与延迟,不在 FLOPs。 另外,200B 参数即便按 1 字节也要约 200 GB,超过单张 H200 的 141 GB,所以真实部署必然是多卡并行,上面的数只是单卡算术界,不含通信。
batch 放大时的聚合速率要小心写。设 batch 为 、每步读一次权重加 份 KV:
注意算力项与 无关:batch 不会让算力变多,只会让带宽被摊薄。带宽项随 增大而趋近 的天花板。这才是「组大 batch 提速」的正确解释。
Cerebras 那张牌就是冲着带宽界来的:官方博文写晶圆级引擎有「数十 GB SRAM、数十 PB/s 内存带宽」,相对典型 GB300 GPU 是 350× 的 SRAM 容量、5,400× 的内存带宽。带宽界被抬高三个数量级,decode 就不再是带宽瓶颈。
于是两家的「倍数」含义分开了:
- Cerebras 的 5× tokens/MW,基线是 CS-3-only 的聚合部署,度量的是单位功耗产出(电是分母):把 prefill 挪到 GPU 上,同样的功率预算里留给 decode 的瓦数更多。原文写的是「token 生成速度无损」,即速度不变、同样的电产出更多 token。
- AWS 的 2.05× output token/s/GPU,度量的是单位卡产出(卡是分母):同一批卡,在延迟目标约束下多接住一倍请求。
其中 是整套系统功率(含 CPU、内存、网络),单位瓦。这两个分母不能互换:受电力与场地限制时看 ,受卡数与预算限制时看 goodput 与每卡 token 数。混用会得出相反结论。
需要说明:Cerebras 的 5× 是相对自家聚合部署的整体收益,不构成对「350×/5,400× 硬件差异」的分解证明;AWS 的 2.05× 也不能拆成「传输开销 8% + 其它」。两家都没有公布这样的分解。
什么时候不该拆:四种形态对照
把所有讨论压成一张定位表。这张表只做定位,不做推荐——每一格的前提条件不同。
| 形态 | 适用负载 | 需要什么 | 账单落在哪 | 已知失效条件 |
|---|---|---|---|---|
| 聚合(默认) | 短 prompt、低并发、延迟不敏感 | 一台机器 | 无搬运 | 长 prompt 与在线输出混跑、TTFT 与 ITL 不能兼得 |
| PD 分离 | 长 prompt + 长输出并存、两个 SLO 都要 | 足够带宽的互联、KV 搬运算子、两池配比 | 搬运开销 + 两池都装全量权重 | 链路带宽低且模型 KV 占比高(R 进 30% 以上);并发太低时固定开销吃掉收益 |
| EPD 分离 | 多模态(图像/视频/音频)+ 语言模型 | 编码实例、EC 连接器、metadata-only 路径 | 编码侧独立扩缩容 + embedding 搬运 | 媒体输入少;编码与 decode 需求同涨同落 |
| L2 分布式 KV | 多轮对话、长系统提示、前缀高度重复 | 共享缓存层 + RDMA + 连接器 | 缓存命中率不够时纯亏硬件与运维 | 一次性长文档问答(命中率趋近 0) |
几条判据可以单独记:
- 先算 ,再看 goodput。 前者决定网络行不行,后者决定收益够不够。顺序反了会白花钱。
- 看 而不是看缓存容量。 缓存再大,流量形状不对也是零收益。
- 算显存要按两池各一份。 AWS 的示例配置是 prefill 1 副本(2 节点 × TP16)、decode 2 副本(2 节点 × TP16),合计 6 个实例,且两池都装全量权重。拆分不省显存,只省调度冲突。
- 在延迟约束下比较。 只比裸吞吐时,拆分常常「没变快」,然后被误判成无效优化。
一次容量规划:把 20 请求/秒拆成两个池要看哪几个数
抽象公式的用处,是在买机器之前就能排出预算。设目标:200B 级 GQA 模型、4000 输入 / 200 输出 token、稳态 20 请求/秒、每用户中位不低于 50 token/s。
输出侧总需求。 每个请求要吐 200 个 token:
按公告口径估卡数。 207 output token/s/GPU 是那套 16 卡部署在 SLO 下的归一化每卡值(原文没有把它定义为 decode 池的单卡能力),所以只能做同口径的粗估:
反过来算:公告那套 16 卡配置对应
并发侧。 20 请求/秒 × 4 秒(decode 走完 200 token)= 80 个活跃请求在池内——正好是公告测试的最优点附近。这三条放在一起说明:20 请求/秒这个目标比公告那套 16 卡配置高约 20%,需要的卡数也在 20 张上下,而不是 16 张。
prefill 侧独立核算。 单卡算一次 4000 token 的 prefill 是 254.1 ms(上一节表),20 请求/秒需要
即约 6 张卡;配一台 8 卡机(TP8 下单请求 prefill 时间降到约 32 ms,通信开销另算)。两侧相加约 25 张卡,比「按 207 粗估的 19.3 张」高,差额是两池各自的取整与余量。
混跑侧对照。 同 SLO 下 101 output token/s/GPU:
所以 2.05× 在采购语言里就是「同样 SLO 下从约 40 张卡降到约 20 张」。 这个换算只在「同型号卡、同口径、同 SLO」时成立,且它是线性外推的草算,不是厂商报价或实测配置:
| 配法 | 卡数(同 SLO 线性外推) | 适用性判断 |
|---|---|---|
| 混跑单池 | 约 40 | 延迟目标下吞吐低,但实现与运维最简单 |
| PD 两池 | 约 20–25(含 prefill 池与取整) | 需要高带宽互联与两池配比运维 |
| 只加卡不拆 | 边际递减 | 加卡能摊薄排队,但改不了「迭代里 prefill 推迟 decode」这一项 |
最后一行值得单独说:加卡不能改写混跑的迭代结构。 它能把排队摊薄,但每次迭代里 prefill 块依然会推迟 decode,ITL 不会因为多买卡而变好。
一个反直觉的推论:长上下文不是拆分的天敌
直觉会说「上下文越长,KV 越大,越不该拆」。把注意力项补进来,结论会反过来。
prefill 的主项是权重矩阵乘(线性),加上注意力分数的二次项。每个查询头都要做一次 与一次 ,因此二次项必须带 :
代入 200B 级配置(、、)、以 计:线性项 ,二次项 ——二次项已占 14%,说明本文前面忽略它的 R 表把 R 高估了约一成,这个偏差方向对读者是有利的(真实 R 更小)。
分母里的第二项随 增长,所以 随 prompt 变长单调下降。两项相等的交叉长度:
因果掩码只算下三角,常数减半,交叉长度翻倍到约 。到了 10 万 token 量级,二次项已是线性项的 3.5 倍(因果口径 1.75 倍), 分别降到基线的 22%(因果口径 36%)。
结论是:长上下文让搬运的相对代价更低,不是更高。 前提是效率系数不变、带宽不变、注意力实现按上式建模;同时,长上下文的 KV 绝对体积仍然会把显存压满,那是另一个问题。真正让拆分在网络预算上吃紧的是「KV 头多、激活参数少」——同样的 token 数,搬的东西多、算的东西少。
实施清单:拆之前要量哪四个数
把上面的分析折成一份可执行清单。四个数没量清楚之前,任何架构图都不该动手。
第一,每 token 的 KV 字节数 。 从模型 config 的层数、KV 头数、头维度、精度四项直接算。这一步最容易错的是拿查询头数代替 KV 头数——GQA 把 32 个头压到 4 个,误差就是 8 倍。
第二,链路有效带宽 ,而不是标称带宽。 标称 400 Gb/s 的链路,单条消息的达成率常在 60%–80%(经验区间,未实测),取决于消息大小与拓扑深度。小消息(单层 KV 切块)的达成率明显低于大消息。
第三,prefill 的实测时间 。 用真实 prompt 长度分布跑一遍,不要用理论值。理论值与实测的比值(本文的 )在不同模型与 batch 下能差一倍。
第四,缓存命中率 的现实值。 从日志里统计「前缀完全相同」的 token 占比;这一项决定要不要上 L2,而不是 PD。
四项齐了,判断顺序固定:先算 (网络行不行),再看 goodput 曲线(经济上值不值),最后看 (要不要多一层缓存)。顺序不能颠倒。
上线之后还要盯三件事:
- 两池配比是否漂移。 prefill 与 decode 的请求比例会随流量形状改变,固定配比会在几周内失配。
- P99 而不是 P50。 拆分把一次传输拆成多次,尾部变长的概率上升。
- 冷启动时间要实测。 权重副本数从一份变两份,加载流量与启动资源压力都会上升;实际墙钟时间取决于共享存储与并行加载,可能接近也可能远小于两倍,不能纸面推断。
速查:四个数、三个口径、一个判据
如果只记一页纸,记这一页。
四个数是所有判断的输入:每 token KV 字节 、链路有效带宽 、激活参数 、prefill 实测时间 。前三个能从 config 与机房文档读出,第四个必须实测。
三个口径不能混用:
| 口径 | 公式 | 分母 | 什么时候用 |
|---|---|---|---|
| 每卡 token 数 | 输出 token/s 除以卡数 | 卡 | 手里有卡、按预算配 |
| 每兆瓦 token 数 | 电(瓦) | 机房受电力与场地限制 | |
| goodput | 两个 SLO 约束下的最大 | 延迟约束 | 对外承诺服务水平 |
一个判据是网络预算比:
- :网络预算宽松,拆分与否由 goodput 决定;
- :可行,但流水化实现的质量会显著影响结果;
- :先换拓扑(多口聚合、NVLink 域)或上 L2 缓存,再谈拆分。
这三档不是行业标准,是本文按「搬运占 prefill 一成、三成」两条经验线切出来的分级,只为选型时对齐语言。
小结
把这一轮公告读成一句话:2026 年 11 月,推理栈把 prefill、decode、编码三个阶段正式当成可以分开定价的商品。
而定价的汇率,是那个网络预算比:
它在忽略注意力二次项时与 prompt 长度无关,补上二次项后随长度缓慢下降。按官方规格代入:200B 级 GQA 在 400 Gb/s 上 7.6%、在 100 Gb/s 上 30.3%;30B 级 MHA 在 100 Gb/s 上 121%。最后一档说明,同样的拆分在带宽不足的拓扑上会先撞到网络预算。
三个可带走的判断:
- 看到「拆分提速 N 倍」,先问口径。 每兆瓦 token 数(分母是电)、每卡 token 数(分母是卡)、goodput(分母是延迟约束)是三件事,Cerebras 的 5× 与 AWS 的 2.05× 分别属于前两者。
- 看到「KV 搬运是新瓶颈」,先算 R。 长 prompt 不是理由,KV 占比高 + 带宽低才是;而且 R 只回答网络问题,不回答收益问题。
- 看到「缓存能省 40%」,先问实验条件。 那个 40% 来自「SLO 下 RPS 翻倍、并计入缓存节点成本」的官方实验,不是一个命中率参数能推出来的。
本文引用的厂商倍数(5×、2.05×、73/30、40%/80%、59%/67%)均为其官方实测或官方转述;本文自行推导的 R 表、绝对时间表、最低带宽表、容量规划与单流上界均为规格推算,不是真机实测。
📋 来源与核验记录
以下来源均在本轮(2026-11-20)真打开过,HTTP 200 且正文可读:
- Cerebras 官方博客《Cerebras Launches Disaggregated Inference》(2026-11-17):prefill 由 AMD Instinct GPU 承担、decode 由 CS-3 承担;生产实测 5× tokens per MW,基线是 CS-3-only 配置(归一化到聚合部署 1×),数据源为「November 14th shared GPT-OSS-120B endpoint」(图注未标年份);350× SRAM 容量、5,400× 内存带宽(对比典型 GB300 GPU);KV Portal 经 RDMA 搬运 KV;早期合作方含 AWS、Fireworks AI、Gimlet Labs、General Compute。 https://www.cerebras.ai/blog/cerebras-launches-disaggregated-inference
- AWS Machine Learning Blog《Managed NVIDIA Dynamo on Amazon SageMaker HyperPod Inference》(2026-11-17):GLM-5.3 的 FP8 权重超过单台
ml.p5.48xlarge的 640 GB 显存;Qwen3-235B-A22B-FP8 + Dynamo + TensorRT-LLM,两台p5en.48xlarge(16 张 H200),请求 4,000 输入 / 200 输出 token;在 P90 TTFT < 1 秒且每用户中位 ≥ 50 token/s 的点上,分离部署达 2.05× 最高聚合吞吐(207 对 101 output token/s/GPU,并发 80 对 32);两池都加载全量权重;KV-aware 路由同时看前缀复用与负载;示例配置 prefill 1 副本(2 节点 × TP16)、decode 2 副本(2 节点 × TP16),合计 6 实例。 https://aws.amazon.com/blogs/machine-learning/managed-nvidia-dynamo-on-amazon-sagemaker-hyperpod-inference/ - vLLM Blog《Encoder Disaggregation in vLLM: Scaling Multimodal Serving with EPD》(2026-11-11):E/P/D 三段拆分;metadata-only EPD 支持 DeepSeek V4.1 Flash(main 上 #62802);核心能力进 v0.32.0;远端 embedding 走 NIXL(CPU mmap 区间)与 Mooncake TransferEngine(TCP 与 RDMA 两条配置路径);跨编码器输出复用走 Mooncake Store;EC connector 即该文的编码器输出连接器。 https://vllm.ai/blog/2026-11-11-encoder-disaggregation-epd
- AWS Database Blog《Announcing distributed KV caching for self-hosted LLMs with Amazon ElastiCache》(2026-11-18):分布式 KV 缓存 GA,跑在与 GPU 同可用区的
cache.i8ge.48xlarge上,经 EFA 上的 RDMA 连接;支持 vLLM/SGLang/TensorRT-LLM,通过开源 LMCache 连接器只改配置不改代码;每百万 token 成本最多降 40% 来自「SLO 下 RPS 翻倍、并计入缓存节点成本」的实验,TTFT 最多降 80%;L0 显存 / L1 主机内存与 NVMe / L2 分布式三层;从缓存读 1 GB 数据(8 MB 对象 ×128)P50 约 41.7 ms;提供 KVTrace 工具供按自身流量试算。 https://aws.amazon.com/blogs/database/announcing-distributed-kv-caching-for-self-hosted-llms-with-amazon-elasticache/ - vLLM Blog《Taking vLLM Apart: A Practical Guide to Disaggregated Serving》(2026-09-29,方法论补充材料):明确「拆分的价值是 goodput 而非吞吐」;8 卡 MI300X 上 73/100 对 30/100 达成「TTFT ≤ 1 秒 + ITL ≤ 50 毫秒」,约 2.4× goodput;该文援引 llm-d P/D 指南称 16 张 H200 上 gpt-oss-120b 平均端到端延迟低 59%、P95 低 67%(本文未定位 llm-d 原始基准表,按二次转述引用);需要 vLLM v0.31.0 及以上。 https://vllm.ai/blog/2026-09-29-disaggregated-serving-guide
- NVIDIA H200 官方规格页(2026-11-20 读取):141 GB HBM3e、4.8 TB/s 显存带宽、FP16 Tensor Core 1,979 TFLOPS、FP8 Tensor Core 3,958 TFLOPS(脚注标明 With sparsity,本文按稠密折半 989.5 / 1,979 TFLOPS 使用)。 https://www.nvidia.com/en-us/data-center/h200/
本文自行推导(非官方数字,不可当实测引用):
- 每 token KV 字节数与三档配置取值:188.0 / 376.0 / 1024.0 KiB;R 与 prompt 长度无关(忽略注意力二次项)这一结论。
- 三档带宽的 R 表:200B 级 30.3% / 7.6% / 0.95%;400B 级 33.3% / 8.3% / 1.04%;30B 级 MHA 121.0% / 30.3% / 3.78%(3.2 Tb/s 档只有前两档接近 1%)。100 Gb/s 一档的 R 在 30% 上下(精确值 30.3%),MHA 结构在 3.2 Tb/s 上仍要付 3.8%。
- 4000 token 绝对时间表:KV 体积 0.717 GiB、prefill 254.1 ms、传输 77.0 / 19.3 / 2.4 ms、占比 30.3% / 7.6% / 0.95%。
- 最低链路带宽反解:容忍 5% 需 606.1 Gb/s、10% 需 303.1 Gb/s、20% 需 151.5 Gb/s。
- 分块 prefill 算例:每 token prefill 20.2 μs;C=512/1024/2048/4096 对应迭代 22.3/32.7/53.4/94.7 ms、TTFT 357.6/261.6/213.6/189.6 ms(TTFT 降 47%,ITL 恶化到约 4.2 倍)。
- Little 定律量级检查:207×16/200=16.56 请求/秒;80 并发隐含平均系统逗留 4.83 秒,与 decode 4.0 秒相容;101 侧得 8.08 请求/秒、N=32.3,与公告 32 差 1.0%。
- 成本换算:,p=3 美元/卡时(示例假设)下 207 对应 4.03 美元、101 对应 8.25 美元每百万输出 token。
- 容量规划:20 请求/秒 × 200 token = 4000 output token/s;按 207 粗估约 19.3 卡;16 卡配置对应 16.6 请求/秒;并发 80;prefill 侧 5.08 GPU·s/s(约 6–8 卡);两侧合计约 20–25 卡;混跑侧按 101 token/s/GPU 约 39.6 卡。
- 流水化暴露量 :400 Gb/s 下尾段约 19.3/94≈0.2 ms(不含协议与调度开销);R=121% 时约放大 21%。
- 注意力二次项:,、、;T=4000 时二次项占 14%;交叉长度约 2.9e4 token(因果口径约 5.7e4);T=1e5 时 R 降到基线 22%(因果口径 36%)。
- 算术强度与单流界:稠密口径 、MoE 口径约 2.0 FLOP/字节,脊点约 412;单流带宽界 16.8(稠密)/ 152(MoE)token/s,算力界 15,742 token/s。
- 效率系数(链路 0.8、算力 0.35、显存 0.7)与链路达成率 60%–80% 均为工程经验值,未在本机实测。全部输出由
exp-2026-11-20-kv-budget.py计算,落盘exp-2026-11-20-kv-budget-out.json。
免责声明:本文基于官方文档和公开资料整理,AI 辅助生成,MagicNetWorld 尚未完成独立实测。