热点拆解 📅 2026-11-20 ✍️ MagicNetWorld 编辑部

把 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 表与时间表为规格推算,非真机实测;引用的厂商倍数为其真机实测值。

PD 分离prefilldecodeKV cache推理服务

四个发版公告,其实在说同一件事

先把四份材料按时间摆开。它们都在讲「把推理拆成几段、放到不同硬件上」,但各自的账本不一样。

  • 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 无法接着生成。

三种部署形态的请求时间线:聚合、PD 分离、EPD 分离
图 1 三种部署形态下,一次请求在「预填充—搬运—逐 token 生成」上的时间线(本文自绘)

这张图想说明的一件事:拆分没有减少任何一步的工作,它只是让被搬运的那一段显式暴露在时间线上——于是它占多少,成了第一个要算的数。

符号约定与术语表

符号含义单位/取值口径
TTprompt token 数(prefill 输入长度)个
LL模型层数层
nqn_q查询头数个
nkvn_{kv}KV 头数(GQA/MQA 折减后的头数)个
dhd_h每个注意力头的维度维
bbKV 每元素的字节数(FP16=2,FP8=1)字节
MtokM_{tok}每 token 的 KV 字节数字节/token
NactN_{act}每 token 激活参数量(MoE 只算被激活的专家)个
NtotN_{tot}总参数量个
Π\Pi加速器算力(本文一律用稠密值)FLOP/s
ε\varepsilon算力效率,取 0.35无量纲
BWBW链路或显存带宽字节/s
η\eta链路效率,取 0.8无量纲
ηmem\eta_{mem}显存带宽效率,取 0.7无量纲
tpt_p一次 prefill 的计算时间秒
txfert_{xfer}KV 从 prefill 侧搬到 decode 侧的时间秒
RR传输时间 / prefill 计算时间无量纲
hhKV 前缀命中率(按 token 计)0–1
术语一句话定义
prefill把整段 prompt 一次性过模型、生成首 token 并建好 KV cache 的阶段,计算受限
decode逐 token 自回归生成,每步读参与计算的权重与新 KV,访存受限
TTFTtime to first token,首 token 延迟,主要由排队 + prefill + 传输决定
ITL / TPOTinter-token latency / time per output token,相邻 token 间隔
goodput同时满足 TTFT 与 ITL 目标的前提下能承受的请求速率,区别于裸吞吐
PD 分离prefill 与 decode 跑在不同实例上,KV 经网络搬过去
EPD 分离在其上再拆出编码阶段(多模态),三段各自独立扩缩容
KV PortalCerebras 的搬运算子,把 KV 经 RDMA 在 prefill 与 decode 引擎之间传递
EC connectorvLLM 侧把编码器输出(embedding)送到下游实例的连接器,见来源 3

后面所有推导只用四个量:MtokM_{tok}、Π⋅ε\Pi\cdot\varepsilon、NactN_{act}、BW⋅ηBW\cdot\eta。

混在一起时,prefill 是怎么偷走 decode 的时间

先看混跑时的一次迭代。一个 batch 里既有「正在做 prefill 的新请求」,也有「正在逐 token 输出的老请求」,那一步的总时间近似由两部分拼成:

titer=tpchunk+td(B)t_{iter} = t_p^{chunk} + t_d(B)

第一项是这一步塞进去的 prefill 分块耗时,第二项是以 batch 大小 BB 做一次 decode 的耗时。服务器在一次迭代里只能有一个瓶颈,但它必须等两步都做完才能进入下一步,所以老请求的 token 间隔被拉长到 titert_{iter}。

这就是分块 prefill(chunked prefill)的由来:把长 prompt 切成 CC 个 token 的小块,一次迭代只算一块。

TTFT≈⌈TC⌉⋅titerTTFT \approx \left\lceil \frac{T}{C} \right\rceil \cdot t_{iter}

这个式子里藏着一个两难。设 titert_{iter} 受显存与算力约束大致固定,那么:

  • 想压 TTFT,就要让 ⌈T/C⌉\lceil T/C \rceil 小,也就是 CC 大——但 CC 大意味着每一步花在 prefill 上的时间多,正在输出请求的 ITL 被拉长;
  • 想压 ITL,就要让 CC 小——但长 prompt 要被切成更多块,TTFT 线性变差。

同一组 GPU 上,TTFT 与 ITL 是同一个旋钮的两端。 这不是调参水平问题,是资源复用带来的结构性矛盾。把两者放到不同硬件上,这个旋钮才被一分为二。

排队论能给一个直觉(注意:下面是 M/M/1 单服务台的平均等待,需要泊松到达与指数服务时间假设,GPU 上的动态 batching 并不满足这些条件,所以它只是解释性模型,不是预测工具)。设到达率 λ\lambda、服务率 μ\mu,利用率 ρ=λ/μ\rho=\lambda/\mu:

Wq=ρ1−ρ⋅1μW_q = \frac{\rho}{1-\rho} \cdot \frac{1}{\mu}

混跑时,prefill 的突发把瞬时 ρ\rho 推到接近 1,平均等待随之发散;同时 prefill 分块直接占住迭代时间,等效地把服务率 μ\mu 压低。拆开以后,prefill 池与 decode 池各有自己的 ρ\rho 与 μ\mu,互不污染——但平均利用率低于 1 并不保证分位数达标,真正的达标与否必须靠实测的 P90/P99 曲线判断。

拆开真正多赚的是 goodput,不是吞吐

这里必须先把口径分清,否则所有倍数都会变成营销数字。vLLM 那篇方法论长文给的定义很直白:拆分不承诺每卡每秒吐更多 token;它承诺的是「在仍然满足延迟目标的前提下」能接住多少请求,也就是 goodput。

G(τttft,τitl)=max⁡{λ  |  P(TTFT≤τttft)≥q,  P(ITL≤τitl)≥q}G(\tau_{ttft}, \tau_{itl}) = \max\left\{\lambda \;\middle|\; P(TTFT \le \tau_{ttft}) \ge q,\; P(ITL \le \tau_{itl}) \ge q \right\}

同一篇文里给的两组数:在单台 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——因为池变小了,并行度也变小了。

裸吞吐=总 token 数总时间,goodput=达标请求数总时间\text{裸吞吐} = \frac{\text{总 token 数}}{\text{总时间}}, \qquad \text{goodput} = \frac{\text{达标请求数}}{\text{总时间}}

这两个量在低负载时几乎没有区别,在高负载时能差一倍以上。所以看到任何「拆分提速 N 倍」,第一个问题永远是:在什么延迟约束下、用什么口径算的。

分块 prefill 的一次算例:8k prompt 上 TTFT 与 ITL 怎么互相挤

抽象的两难不如一组具体数字。取一个 7B 稠密模型(Nact=Ntot=7×109N_{act}=N_{tot}=7\times10^{9})、24 层、nkv=8n_{kv}=8、dh=128d_h=128、KV 用 FP16,跑在 H200 上按 FP8 稠密 1,979 TFLOPS × 0.35 的效率;prompt 8192 token,decode 侧单步时间设为 12 ms(含通信与调度开销)。

先算每 token 的 prefill 时间:

tp1=2NactΠε=2×7×109693×1012≈20.2 μs/tokent_p^{1} = \frac{2N_{act}}{\Pi\varepsilon} = \frac{2\times 7\times10^{9}}{693\times10^{12}} \approx 20.2\ \mu s/\text{token}

于是分块大小 CC 决定一次迭代里 prefill 占多少:tpchunk=20.2 μs×Ct_p^{chunk} = 20.2\,\mu s \times C。一次迭代的总时间还要加上 decode 的 12 ms:

分块大小 CC迭代数 ⌈8192/C⌉\lceil 8192/C\rceil每次迭代TTFT同批请求的 ITL是否满足 1s / 50ms
5121622.3 ms357.6 ms22.3 ms都满足
1024832.7 ms261.6 ms32.7 ms都满足
2048453.4 ms213.6 ms53.4 msITL 违约
4096294.7 ms189.6 ms94.7 msITL 严重违约

读法很直接:把 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 定律做一个量级检查(不是验证,因为缺少平均系统逗留时间这一实测项)。稳态下系统内并发数等于到达率乘以逗留时间:

N=λ⋅WN = \lambda \cdot W

AWS 那组数的口径是 16 张 H200、每请求 200 个输出 token。分离部署 207 output token/s/GPU:

λdisagg=207×16200≈16.56 请求/秒\lambda_{disagg} = \frac{207 \times 16}{200} \approx 16.56\ \text{请求/秒}

公告写的最优点并发 80,反推隐含的平均系统逗留时间:

W=8016.56≈4.83 秒W = \frac{80}{16.56} \approx 4.83\ \text{秒}

而 decode 阶段按「每用户中位 50 token/s」走完 200 个 token 只需 4.0 秒——4.83 秒比 4.0 秒多出的 0.83 秒,正好落在排队、首 token 等待与传输的位置上,两者相容。

混跑那一侧:101 token/s/GPU → λ=8.08\lambda = 8.08 请求/秒,按 4 秒 decode 时间算 N=32.3N = 32.3,公告写 32,差 1.0%。

结论只能是「数量级相容」,不能更强。 这组检查说明公告的并发与吞吐不互相矛盾;它不证明 2.05× 的统计口径可靠,因为真正的判据是不同并发下的 P90 曲线,而那需要原始数据。这一点本文没法替读者补上。

KV 搬运的账单:一个与 prompt 长度无关的比值

现在进入本文的核心。把一次 prefill 的 KV 体积写出来。每层每个 token 要存 K 和 V 各一份,每份有 nkvn_{kv} 个头、每头 dhd_h 维、每维 bb 字节:

Mtok=2⋅L⋅nkv⋅dh⋅bM_{tok} = 2 \cdot L \cdot n_{kv} \cdot d_h \cdot b

整段 prompt 的 KV 体积就是 T⋅MtokT \cdot M_{tok}。搬运时间按有效带宽算:

txfer=T⋅MtokBW⋅ηt_{xfer} = \frac{T \cdot M_{tok}}{BW \cdot \eta}

prefill 的计算时间,主项是权重矩阵乘,每参数两 FLOPs,MoE 只算激活的部分(注意力二次项单列在下一节):

tp≈2⋅Nact⋅TΠ⋅εt_p \approx \frac{2 \cdot N_{act} \cdot T}{\Pi \cdot \varepsilon}

两式相除——TT 被约掉了:

R=txfertp=Mtok⋅Π⋅ε2⋅Nact⋅BW⋅ηR = \frac{t_{xfer}}{t_p} = \frac{M_{tok} \cdot \Pi \cdot \varepsilon}{2 \cdot N_{act} \cdot BW \cdot \eta}

这个结果值得停一下。 通常的直觉是「prompt 越长,KV 越大,搬运越吃亏」。但在忽略注意力二次项、效率固定的这组假设下,prefill 计算量同样随 TT 线性增长,两者一起长大,比值不动。

真正决定 RR 的只有四件事:每 token 的 KV 字节数、算力、激活参数量、链路带宽。长 prompt 不会让搬运的相对代价变高;绝对时间变长,相对占比不变。(下一节会补上二次项对这条结论的修正。)

也因此,RR 是一个网络预算指标:它说「这条链路够不够快」,不说「拆了能不能赚钱」。收益要看 goodput 曲线,成因是混跑干扰减少、排队行为改变、两池各自调优——这些都不在 RR 里。

给定一个可接受的占比 R∗R^{\ast},可以反解出最低需要的链路带宽:

BW∗=Mtok⋅Π⋅ε2⋅Nact⋅R∗⋅ηBW^{\ast} = \frac{M_{tok} \cdot \Pi \cdot \varepsilon}{2 \cdot N_{act} \cdot R^{\ast} \cdot \eta}

这条式子是选型时的第一道筛:先定你能忍多少开销,再看网络够不够。反过来也成立——只有 100 Gb/s 机器间链路时,RR 就在 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 的逐字段引用。

配置LLnkvn_{kv}dhd_hbbNactN_{act}MtokM_{tok}
200B 级 GQA944128222B188.0 KiB
400B 级 GQA948128240B376.0 KiB
30B 级 MHA6432128230B1024.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/s400 Gb/s EFA3.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%

三行读完,能读出三条:

  1. GQA 把 KV 压下来,是跨机拆分可行的前提。 同一个 30B 级模型若用 32 个 KV 头的 MHA,每 token 要搬 1024 KiB,是 200B 级 GQA 的 5.4 倍,在 100 Gb/s 上搬运时间比(线性口径的)prefill 计算还长(121%)。
  2. 400 Gb/s 是当下跨机拆分的常用档。 在这一档,两档 GQA 模型的搬运开销在 8% 上下。
  3. 聚合链路把开销压到 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/s0.717 GiB254.1 ms77.0 ms30.3%
400 Gb/s EFA0.717 GiB254.1 ms19.3 ms7.6%
3.2 Tb/s 聚合0.717 GiB254.1 ms2.4 ms0.95%

这张表顺手回答了「一次 4000 token 的请求要搬多少数据」:0.72 GiB。AWS 的压测口径正是 4,000 输入 + 200 输出 token,所以在 400 Gb/s 量级链路上,按本文假设搬运对 TTFT 的贡献是十几毫秒,比 1 秒目标低一个数量级以上。这是「与 2.05× 相容」的一种解释,不是它的证明——AWS 没有公布这条关键路径的分解。

反解最低带宽,同一个 200B 级配置:

能容忍的搬运占比 R∗R^{\ast}最低链路带宽
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 全部算完才开始搬」。工程实现通常按层流水:算第 ii 层时搬第 i−1i-1 层的 KV。下面是理想流水模型(用于说明量级,不对应任何厂商实现):

texposed≈max⁡(0,  txfer−tp)+ttailt_{exposed} \approx \max\left(0,\; t_{xfer} - t_p\right) + t_{tail}

其中 ttailt_{tail} 是最后一层 KV 必须在 decode 首步之前到位的那一段。两条推论:

  1. R≤1R \le 1 时,搬运大部分可被隐藏。 暴露量降到 ttailt_{tail} 量级(约 txfer/Lt_{xfer}/L)。200B 级 GQA 在 400 Gb/s 下 R = 7.6%,按此模型尾段约 19.3/94 ≈ 0.2 ms——这个 0.2 ms 不含协议、调度、争用与完成通知开销,真实值只会更大。
  2. R>1R > 1 时,暴露量变成线性惩罚。 30B 级 MHA 在 100 Gb/s 上 R = 121%,暴露时间约为 txfer−tpt_{xfer}-t_p,相当于把 prefill 时间放大 21%。在本文假设下,这意味着拆分在这条链路上要先解决网络预算问题,而不是先讨论收益。

所以准确的说法是:R 是「网络预算」的判据,不是「拆分收益」的判据。 R 小只说明拆分在网络上不受限;R 大说明换拓扑(多口聚合、NVLink 域)或换路线(L2 缓存)应当排在拆分之前。

流水化本身的前提也容易被忽略:

  • 必须能分层流水。 一次性生成全部 KV 再发的实现拿不到这个收益,暴露量就是全额 txfert_{xfer}。
  • decode 首步必须等全部层到齐。 分块到达可以边收边建页表,但 ttailt_{tail} 至少是一层的传输时间。
  • 小消息的达成率低于大消息。 把一次大传输拆成很多次小传输,链路效率与抖动都会变差,这一项在公告里没有披露。

从 token/s/GPU 换算到每百万 token 的账

公告给的是 token/s/GPU,机房账本要的是每百万 token 的成本。两者之间隔一个 GPU 小时单价。设单卡每小时价格 pp,每卡每秒产 TPSTPS 个 token:一小时单卡产出 3600×TPS3600 \times TPS 个 token、花掉 pp;凑够 10610^{6} 个 token 需要的卡时是 106/(3600 TPS)10^{6}/(3600\,TPS):

C1M=p⋅1063600⋅TPSC_{1M} = p \cdot \frac{10^{6}}{3600 \cdot TPS}

代入 207 token/s/GPU,并假设 p=3p = 3 美元/卡时(示例假设,不是任何厂商的报价):

C1M=3×1063600×207≈4.03 美元/百万输出 tokenC_{1M} = 3 \times \frac{10^{6}}{3600 \times 207} \approx 4.03\ \text{美元/百万输出 token}

同样假设下,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 的路径。

设前缀命中比例为 hh(按 token),剩余 (1−h)T(1-h)T 个 token 仍要算一遍:

tpremain=(1−h)⋅tp,tread=h T MtokBWL2⋅ηt_p^{remain} = (1-h)\cdot t_p, \qquad t_{read} = \frac{h\,T\,M_{tok}}{BW_{L2}\cdot\eta}

TTFT≈Wq+tread+tpremain+txferremainTTFT \approx W_q + t_{read} + t_p^{remain} + t_{xfer}^{remain}

三条推论:

  1. hh 只省计算,不省带宽。 命中率高时,treadt_{read} 依然随命中 token 数线性增长——这就是为什么 L2 通常与 PD 拆分一起上,而不是替代它。
  2. 命中是部分命中,不是整条请求跳过 prefill。 新输入的那部分 token 永远要算;把「命中」写成「跳过 prefill」,会让人以为长对话的第二轮几乎零成本,这是错的。
  3. 收益由实验口径决定,不由单一 hh 推导。 AWS 原文的 40% 是在「SLO 下 RPS 翻倍、并计入缓存节点成本」的实验条件下得到的;80% 的 TTFT 降幅同样是端点值。把它们写成「hh 接近上限时的端点」,是把实验口径压缩成一个参数,容易误导读者去做纸面推算。

第二层的差别在于省的是什么:PD 拆分省资源争用(把两类负载分开),L2 缓存省重复计算(同一段前缀不算第二遍)。二者叠加时,TTFTTTFT 里同时有 (1−h)(1-h) 的 prefill 项和 treadt_{read} 的读取项。

KV 缓存三层结构与命中判定:L0 显存、L1 本机内存与 NVMe、L2 共享分布式层
图 2 请求按 L0→L1→L2 顺序查 KV,命中即用读取代替重算,未命中才付全额计算(本文自绘)

这张图想说明的一件事:缓存把「重算」换成了「读取」——它不降低任何一次传输的成本,只是让一部分请求不必重新计算。

为什么 Cerebras 的 5× 和 GPU 阵营的 2.05× 不能直接比

两家给的倍数差了一倍多,很容易被拿去做「谁更强」的比较。但把口径拆开就知道,它们度量的不是同一个量。

先看 decode 的算术强度。decode 每生成一个 token,要做大约 2Nact2N_{act} FLOPs;同时要读一次参与计算的状态。这里有一个口径分叉:

  • 稠密口径:每步读全部权重 Ntot⋅bN_{tot}\cdot b,这是传统稠密模型的情形;
  • MoE 口径:每步只读被激活的专家(加共享与注意力权重),约为 Nact⋅bN_{act}\cdot b。

Idec=2NactWstep,Wstep∈{ Ntot b,  Nact b }I_{dec} = \frac{2N_{act}}{W_{step}},\qquad W_{step} \in \{\,N_{tot}\,b,\; N_{act}\,b\,\}

代入 FP8(b=1b=1)、200B 总参数、22B 激活:稠密口径 Idec=0.22I_{dec}=0.22,MoE 口径约 2.0 FLOP/字节。而 H200 的脊点是

Iridge=ΠBW=1,979×10124.8×1012≈412 FLOP/字节I_{ridge} = \frac{\Pi}{BW} = \frac{1{,}979\times 10^{12}}{4.8\times 10^{12}} \approx 412\ \text{FLOP/字节}

两个口径都远低于 412,所以「decode 是访存受限」这个结论不变;但数值差 9 倍,必须标明用的是哪一个。 本文后面提到具体速率时一律注明口径。

单流速率同理,写成两个界:

TPS1=min⁡(Π⋅ε2Nact, BW⋅ηmemWstep)TPS_{1} = \min\left(\frac{\Pi\cdot\varepsilon}{2N_{act}},\ \frac{BW\cdot\eta_{mem}}{W_{step}}\right)

稠密口径下带宽界约 16.8 token/s(3.36×1012/200×1093.36\times10^{12}/200\times10^{9}),MoE 口径下约 152 token/s(除以 22B 激活)。这两个数的共同点是:算力界(15,742 token/s)比带宽界高两三个数量级,说明单流 decode 的瓶颈在带宽与延迟,不在 FLOPs。 另外,200B 参数即便按 1 字节也要约 200 GB,超过单张 H200 的 141 GB,所以真实部署必然是多卡并行,上面的数只是单卡算术界,不含通信。

batch 放大时的聚合速率要小心写。设 batch 为 BB、每步读一次权重加 BB 份 KV:

TPS(B)=min⁡(Π⋅ε2Nact, B⋅BW⋅ηmemWstep+B T Mtok)TPS(B) = \min\left(\frac{\Pi\cdot\varepsilon}{2N_{act}},\ \frac{B\cdot BW\cdot\eta_{mem}}{W_{step} + B\,T\,M_{tok}}\right)

注意算力项与 BB 无关:batch 不会让算力变多,只会让带宽被摊薄。带宽项随 BB 增大而趋近 BWηmem/(TMtok)BW\eta_{mem}/(T M_{tok}) 的天花板。这才是「组大 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,度量的是单位卡产出(卡是分母):同一批卡,在延迟目标约束下多接住一倍请求。

EMW=TPS(B)Psys[token⋅s−1⋅W−1]E_{MW} = \frac{TPS(B)}{P_{sys}}\quad\left[\text{token}\cdot\text{s}^{-1}\cdot\text{W}^{-1}\right]

其中 PsysP_{sys} 是整套系统功率(含 CPU、内存、网络),单位瓦。这两个分母不能互换:受电力与场地限制时看 EMWE_{MW},受卡数与预算限制时看 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)

几条判据可以单独记:

  • 先算 RR,再看 goodput。 前者决定网络行不行,后者决定收益够不够。顺序反了会白花钱。
  • 看 hh 而不是看缓存容量。 缓存再大,流量形状不对也是零收益。
  • 算显存要按两池各一份。 AWS 的示例配置是 prefill 1 副本(2 节点 × TP16)、decode 2 副本(2 节点 × TP16),合计 6 个实例,且两池都装全量权重。拆分不省显存,只省调度冲突。
  • 在延迟约束下比较。 只比裸吞吐时,拆分常常「没变快」,然后被误判成无效优化。

一次容量规划:把 20 请求/秒拆成两个池要看哪几个数

抽象公式的用处,是在买机器之前就能排出预算。设目标:200B 级 GQA 模型、4000 输入 / 200 输出 token、稳态 20 请求/秒、每用户中位不低于 50 token/s。

输出侧总需求。 每个请求要吐 200 个 token:

20×200=4000 output token/s20 \times 200 = 4000\ \text{output token/s}

按公告口径估卡数。 207 output token/s/GPU 是那套 16 卡部署在 SLO 下的归一化每卡值(原文没有把它定义为 decode 池的单卡能力),所以只能做同口径的粗估:

4000207≈19.3 卡\frac{4000}{207} \approx 19.3\ \text{卡}

反过来算:公告那套 16 卡配置对应

207×16200≈16.6 请求/秒\frac{207\times16}{200} \approx 16.6\ \text{请求/秒}

并发侧。 20 请求/秒 × 4 秒(decode 走完 200 token)= 80 个活跃请求在池内——正好是公告测试的最优点附近。这三条放在一起说明:20 请求/秒这个目标比公告那套 16 卡配置高约 20%,需要的卡数也在 20 张上下,而不是 16 张。

prefill 侧独立核算。 单卡算一次 4000 token 的 prefill 是 254.1 ms(上一节表),20 请求/秒需要

20×0.25411≈5.08 GPU⋅s/s\frac{20 \times 0.2541}{1} \approx 5.08\ \text{GPU·s/s}

即约 6 张卡;配一台 8 卡机(TP8 下单请求 prefill 时间降到约 32 ms,通信开销另算)。两侧相加约 25 张卡,比「按 207 粗估的 19.3 张」高,差额是两池各自的取整与余量。

混跑侧对照。 同 SLO 下 101 output token/s/GPU:

4000101≈39.6 卡\frac{4000}{101} \approx 39.6\ \text{卡}

所以 2.05× 在采购语言里就是「同样 SLO 下从约 40 张卡降到约 20 张」。 这个换算只在「同型号卡、同口径、同 SLO」时成立,且它是线性外推的草算,不是厂商报价或实测配置:

配法卡数(同 SLO 线性外推)适用性判断
混跑单池约 40延迟目标下吞吐低,但实现与运维最简单
PD 两池约 20–25(含 prefill 池与取整)需要高带宽互联与两池配比运维
只加卡不拆边际递减加卡能摊薄排队,但改不了「迭代里 prefill 推迟 decode」这一项

最后一行值得单独说:加卡不能改写混跑的迭代结构。 它能把排队摊薄,但每次迭代里 prefill 块依然会推迟 decode,ITL 不会因为多买卡而变好。

一个反直觉的推论:长上下文不是拆分的天敌

直觉会说「上下文越长,KV 越大,越不该拆」。把注意力项补进来,结论会反过来。

prefill 的主项是权重矩阵乘(线性),加上注意力分数的二次项。每个查询头都要做一次 QKTQK^{T} 与一次 AVAV,因此二次项必须带 nqn_q:

Fprefill≈2NactT+4 L nq dh T2F_{prefill} \approx 2N_{act}T + 4\,L\,n_q\,d_h\,T^{2}

代入 200B 级配置(L=94L=94、nq=32n_q=32、dh=128d_h=128)、以 T=4000T=4000 计:线性项 1.76×10141.76\times10^{14},二次项 2.46×10132.46\times10^{13}——二次项已占 14%,说明本文前面忽略它的 R 表把 R 高估了约一成,这个偏差方向对读者是有利的(真实 R 更小)。

R(T)=Mtok Π εBW η (2Nact+4L nq dh T)R(T) = \frac{M_{tok}\,\Pi\,\varepsilon}{BW\,\eta\,\left(2N_{act} + 4L\,n_q\,d_h\,T\right)}

分母里的第二项随 TT 增长,所以 RR 随 prompt 变长单调下降。两项相等的交叉长度:

T∗=2Nact4L nq dh≈2.9×104 tokenT^{\ast} = \frac{2N_{act}}{4L\,n_q\,d_h} \approx 2.9\times 10^{4}\ \text{token}

因果掩码只算下三角,常数减半,交叉长度翻倍到约 5.7×1045.7\times 10^{4}。到了 10 万 token 量级,二次项已是线性项的 3.5 倍(因果口径 1.75 倍),RR 分别降到基线的 22%(因果口径 36%)。

结论是:长上下文让搬运的相对代价更低,不是更高。 前提是效率系数不变、带宽不变、注意力实现按上式建模;同时,长上下文的 KV 绝对体积仍然会把显存压满,那是另一个问题。真正让拆分在网络预算上吃紧的是「KV 头多、激活参数少」——同样的 token 数,搬的东西多、算的东西少。

实施清单:拆之前要量哪四个数

把上面的分析折成一份可执行清单。四个数没量清楚之前,任何架构图都不该动手。

第一,每 token 的 KV 字节数 MtokM_{tok}。 从模型 config 的层数、KV 头数、头维度、精度四项直接算。这一步最容易错的是拿查询头数代替 KV 头数——GQA 把 32 个头压到 4 个,误差就是 8 倍。

第二,链路有效带宽 BWeffBW_{eff},而不是标称带宽。 标称 400 Gb/s 的链路,单条消息的达成率常在 60%–80%(经验区间,未实测),取决于消息大小与拓扑深度。小消息(单层 KV 切块)的达成率明显低于大消息。

第三,prefill 的实测时间 tpt_p。 用真实 prompt 长度分布跑一遍,不要用理论值。理论值与实测的比值(本文的 ε\varepsilon)在不同模型与 batch 下能差一倍。

第四,缓存命中率 hh 的现实值。 从日志里统计「前缀完全相同」的 token 占比;这一项决定要不要上 L2,而不是 PD。

四项齐了,判断顺序固定:先算 RR(网络行不行),再看 goodput 曲线(经济上值不值),最后看 hh(要不要多一层缓存)。顺序不能颠倒。

上线之后还要盯三件事:

  • 两池配比是否漂移。 prefill 与 decode 的请求比例会随流量形状改变,固定配比会在几周内失配。
  • P99 而不是 P50。 拆分把一次传输拆成多次,尾部变长的概率上升。
  • 冷启动时间要实测。 权重副本数从一份变两份,加载流量与启动资源压力都会上升;实际墙钟时间取决于共享存储与并行加载,可能接近也可能远小于两倍,不能纸面推断。

速查:四个数、三个口径、一个判据

如果只记一页纸,记这一页。

四个数是所有判断的输入:每 token KV 字节 MtokM_{tok}、链路有效带宽 BWeffBW_{eff}、激活参数 NactN_{act}、prefill 实测时间 tpt_p。前三个能从 config 与机房文档读出,第四个必须实测。

三个口径不能混用:

口径公式分母什么时候用
每卡 token 数输出 token/s 除以卡数卡手里有卡、按预算配
每兆瓦 token 数EMW=TPS(B)PsysE_{MW} = \dfrac{TPS(B)}{P_{sys}}电(瓦)机房受电力与场地限制
goodput两个 SLO 约束下的最大 λ\lambda延迟约束对外承诺服务水平

一个判据是网络预算比:

R=Mtok Π ε2Nact BW ηR = \frac{M_{tok}\,\Pi\,\varepsilon}{2N_{act}\,BW\,\eta}

  • R≤0.1R \le 0.1:网络预算宽松,拆分与否由 goodput 决定;
  • 0.1<R≤0.30.1 < R \le 0.3:可行,但流水化实现的质量会显著影响结果;
  • R>0.3R > 0.3:先换拓扑(多口聚合、NVLink 域)或上 L2 缓存,再谈拆分。

这三档不是行业标准,是本文按「搬运占 prefill 一成、三成」两条经验线切出来的分级,只为选型时对齐语言。

小结

把这一轮公告读成一句话:2026 年 11 月,推理栈把 prefill、decode、编码三个阶段正式当成可以分开定价的商品。

而定价的汇率,是那个网络预算比:

R=Mtok⋅Π⋅ε2Nact⋅BW⋅ηR = \frac{M_{tok}\cdot\Pi\cdot\varepsilon}{2N_{act}\cdot BW\cdot\eta}

它在忽略注意力二次项时与 prompt 长度无关,补上二次项后随长度缓慢下降。按官方规格代入:200B 级 GQA 在 400 Gb/s 上 7.6%、在 100 Gb/s 上 30.3%;30B 级 MHA 在 100 Gb/s 上 121%。最后一档说明,同样的拆分在带宽不足的拓扑上会先撞到网络预算。

三个可带走的判断:

  1. 看到「拆分提速 N 倍」,先问口径。 每兆瓦 token 数(分母是电)、每卡 token 数(分母是卡)、goodput(分母是延迟约束)是三件事,Cerebras 的 5× 与 AWS 的 2.05× 分别属于前两者。
  2. 看到「KV 搬运是新瓶颈」,先算 R。 长 prompt 不是理由,KV 占比高 + 带宽低才是;而且 R 只回答网络问题,不回答收益问题。
  3. 看到「缓存能省 40%」,先问实验条件。 那个 40% 来自「SLO 下 RPS 翻倍、并计入缓存节点成本」的官方实验,不是一个命中率参数能推出来的。

本文引用的厂商倍数(5×、2.05×、73/30、40%/80%、59%/67%)均为其官方实测或官方转述;本文自行推导的 R 表、绝对时间表、最低带宽表、容量规划与单流上界均为规格推算,不是真机实测。

📋 来源与核验记录

以下来源均在本轮(2026-11-20)真打开过,HTTP 200 且正文可读:

  1. 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
  2. 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/
  3. 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
  4. 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/
  5. 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
  6. 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%。
  • 成本换算:C1M=p⋅106/(3600⋅TPS)C_{1M}=p\cdot10^{6}/(3600\cdot TPS),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 卡。
  • 流水化暴露量 texposed≈max⁡(0,txfer−tp)+ttailt_{exposed}\approx\max(0,t_{xfer}-t_p)+t_{tail}:400 Gb/s 下尾段约 19.3/94≈0.2 ms(不含协议与调度开销);R=121% 时约放大 21%。
  • 注意力二次项:F≈2NactT+4LnqdhT2F\approx2N_{act}T+4Ln_qd_hT^2,nq=32n_q=32、L=94L=94、dh=128d_h=128;T=4000 时二次项占 14%;交叉长度约 2.9e4 token(因果口径约 5.7e4);T=1e5 时 R 降到基线 22%(因果口径 36%)。
  • 算术强度与单流界:稠密口径 Idec=0.22I_{dec}=0.22、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 尚未完成独立实测。