概念科普 📅 2026-11-04 ✍️ MagicNetWorld 编辑部

利用率七成,等待为什么已经翻倍:三个排队公式、一次批处理的取舍,以及被长上下文吃掉的并发

主题:为什么服务在利用率还没跑满时就开始变慢。口径声明:本文的「七成」指排队模型里的 rho = 到达率 / 服务率,不是监控面板上的 GPU 利用率,两者只在「一个服务台一次只处理一个请求」时才对齐;M/M/1 是最简化的模型(泊松到达、指数服务、单服务台),多服务台(例如一张卡上 162 个并发槽位)的排队会小得多,后文用 Erlang-C 给出对照。核心结论:单服务台下平均系统内请求数与平均排队等待都按 rho/(1-rho) 增长,rho=0.7 时平均排队等待是单次服务时间的 2.33 倍,排队等待的 P99 是 14.16 倍。大模型侧的数字全部基于 Meta Llama-3-8B 的公开结构(32 层、8 个 KV 头、每头 128 维)与 bf16 权重和 KV:权重约 16.06 GB,按本文假设的 5.3 TB/s 带宽,读一遍权重约 3.03 毫秒,这是「只读权重、不含 KV 与 prefill」的理想下界;8k 上下文下批大小约 15 时 KV 读取就与权重相等,批 162 时每步要搬 190 GB;由此得到批 162 时的整卡输出吞吐约 4519 token/秒,而同口径下 8k 上下文的通用上界是带宽除以每 token KV 字节数,约 4936 token/秒,与批大小无关。所有数字均为公式代入,不是实测。

推理服务排队论批处理尾延迟KV Cache容量规划

先说人话:银行大厅里一个窗口,平均每分钟进来两个人,每个客户办一分钟。你算了一下,服务能力是每分钟三个人,现在只用了三分之二——看上去还有三分之一的余量,所以理论上排不了几个人。可你到了现场,取号机上显示前面还有五位,等了七八分钟才轮到你。余量确实存在,但它不是「随时可用的余量」,而是「在时间上忽多忽少地漏出来的余量」:人是一阵一阵来的,窗口也是一阵一阵忙的。队伍不是被平均填满的,而是被随机性填满的。

大模型推理服务是同一个故事,只是把「窗口」换成了 GPU,把「办业务」换成了生成 token。工程上最常见的误判是:看到 GPU 利用率七成,就认为还能再吃三成流量。这里要先钉一个钉子:本文说的「七成」是排队模型里的 ρ=λ/μ\rho=\lambda/\mu,不是监控面板上的 GPU 利用率。 两者只有在「一个服务台一次只处理一个请求」时才对齐;GPU 上一个 batch 通常并行几十上百个请求,那时要用多服务台的模型,结论会温和得多——这一点本文第「多服务台」一节会专门算。

所以这篇的目标不是告诉你「七成一定慢」,而是把三个公式讲透:它们分别回答「余量到底有多少」「等待为什么不是线性变长」「平均之外的那条尾巴为什么更凶」。再把公式接到大模型特有的机制上:批处理、prefill 与 decode 的互相干扰、以及 KV 缓存怎样按上下文长度吃掉并发与带宽。看完你至少能判断一件事:当一个服务「什么都没跑满,用户却已经开始等」时,该先怀疑排队,还是先怀疑代码。

符号与术语约定

下面每个符号第一次出现都会给一句话定义,这里先集中列一遍,后文不再重复。

符号含义一句话定义
λ\lambda到达率单位时间内新到的请求数,单位「请求/秒」
μ\mu服务率单位时间内一个服务台能处理完的请求数,单位「请求/秒」
SS服务时间单个请求占用服务台的平均时间,S=1/μS=1/\mu
ρ\rho利用率到达率除以服务率,ρ=λ/μ\rho=\lambda/\mu,无量纲
LL系统内请求数正在排队加上正在被服务的请求的平均个数
LqL_q队列长度只在排队、还没开始被服务的平均个数,Lq=L−ρL_q=L-\rho
WW逗留时间从到达离开的平均时间,含排队与服务
WqW_q排队时间只算在队列里等的那一段
t99t_{99}99 分位等待有 1% 的请求等待超过这个值
TTFT首 token 时间time to first token,从请求发出到收到第一个 token
TPOT每 token 时间time per output token,decode 阶段平均每生成一个 token 的间隔
goodput有效吞吐满足延迟约束的那部分吞吐,单位仍是「请求/秒」
KV cache键值缓存每个请求为已生成 token 保存的注意力键值,随上下文线性增长
batch批一次前向计算里同时处理的请求数
BwB_w权重字节模型权重占用的字节数,与批大小无关,每步读一遍
NlayerN_{layer}层数Transformer 的层数,只用于算 KV 体积

这里有个容易混淆的地方,先点破:λ\lambda 和 μ\mu 都是「每秒多少个请求」,不是「每秒多少 token」。大模型场景里两者之间差着「平均输出多少 token」这个因子,混用会让后面所有算术错位。本文统一按「请求」计数,token 只在讲批量吞吐时出现。

这一节想让你记住的一件事:利用率是一个比值,不是一个百分比进度条;它衡量的是「到达速度与服务速度的接近程度」,而不是「机器有多忙」,也不是「GPU 面板上的那个百分比」。

第一笔账:利用率是到达速度与服务速度的比

把服务看成一个服务台,请求按某个平均速率到达,服务台按某个平均速率处理。定义只有一行:

ρ=λμ\rho = \frac{\lambda}{\mu}

这个式子里没有任何「忙闲时间」的信息,但它决定了系统的命运。原因是稳定性条件:只有当 λ<μ\lambda < \mu,也就是 ρ<1\rho < 1 时,队列才不会无限增长。当 ρ≥1\rho \ge 1,到达比处理快,队列理论上会一直涨下去——现实里它不会涨到无穷,而是以另一种方式「解决」:内存耗尽、超时、请求被丢弃、或者客户端主动断开。

这里要区分两个「忙」。一个是服务台的忙:窗口有没有人在办业务。另一个是系统的忙:队列里有没有人在等。前者可以只有七成,后者可以已经很长。这两个量之间的桥,就是下一节的公式。

很多人对利用率有一个直觉上的误解,以为 ρ=0.7\rho=0.7 意味着「三成时间闲着,所以平均等待应该是服务时间的三成左右」。这个直觉假设了「空闲时间均匀分布、随到随办」。真实系统里的空闲时间是碎片化的:可能连着三分钟没人来,然后一分钟来五个。碎片化的空闲没法被一个请求「拼接」起来用,它只能被浪费。于是等待不是由「总空闲量」决定,而是由「空闲出现的时机」决定。

还有一个更隐蔽的问题:平均利用率是时间平均,不是请求加权平均。一个每分钟只来一个请求、每次要跑满一分钟的服务,它的时间利用率是 100%,但每个请求几乎不排队;一个每分钟来一百个请求、每次只跑十毫秒的服务,它的利用率是 16.7%,可是只要到达稍微集中一点,队列立刻就长出来。看同一个「70%」,两种系统的用户感受可以完全相反。

这一节想让你记住的一件事:ρ<1\rho<1 只保证队列不会无限长,不保证队列很短;稳定和不拥堵是两件事。

一次推理请求的路径与三个观测量
图 1 一次推理请求的路径与三个观测量:排队段由到达与服务速度的比决定,首字由等槽加 prefill 决定,吐字速度由每步字节除以带宽决定(本文自绘)

第二笔账:等待时间按 1/(1−ρ) 爆炸

最经典的模型是 M/M/1:到达是泊松过程(间隔随机、无记忆),服务时间服从指数分布,只有一个服务台。这三个假设都很强,后文会专门说它们什么时候会骗人,但它们给出的形状在绝大多数单服务台排队系统里都成立。

设系统里有 nn 个请求的概率为 pnp_n。在稳态下,从状态 nn 转到 n+1n+1 的速率(λpn\lambda p_n)必须等于从 n+1n+1 转回 nn 的速率(μpn+1\mu p_{n+1}),于是

pn+1=λμpn=ρ pnp_{n+1} = \frac{\lambda}{\mu} p_n = \rho\, p_n

把 pn=(1−ρ)ρnp_n = (1-\rho)\rho^{n} 归一化(所有概率之和为 1),得到系统内请求数的平均值:

L=∑n≥0n (1−ρ)ρn=ρ1−ρL = \sum_{n\ge 0} n\,(1-\rho)\rho^{n} = \frac{\rho}{1-\rho}

再用利特尔法则(Little’s law,平均在场数等于到达率乘平均逗留时间,L=λWL=\lambda W)把它换成时间:

W=Lλ=1μ−λ=S1−ρW = \frac{L}{\lambda} = \frac{1}{\mu-\lambda} = \frac{S}{1-\rho}

排队时间就是逗留时间减去服务时间:

Wq=W−S=ρμ−λ=ρS1−ρW_q = W - S = \frac{\rho}{\mu-\lambda} = \frac{\rho S}{1-\rho}

这几个式子值得盯着看一会儿。ρS/(1−ρ)\rho S/(1-\rho) 里,分子随 ρ\rho 线性涨,分母随 ρ\rho 趋近 1 而趋近 0,所以整体是「线性分子除以趋零分母」的双重放大。把 ρ\rho 从 0.5 抬到 0.9,到达率只涨了 1.8 倍,平均排队时间却从 1 个 SS 涨到 9 个 SS,涨了 9 倍。

利用率 ρ\rho平均系统内请求数 LL平均排队时间 Wq/SW_q/S排队等待的 99 分位 t99/St_{99}/S
0.501.001.007.82
0.601.501.5010.24
0.702.332.3314.16
0.804.004.0021.91
0.909.009.0045.00
0.9519.0019.0091.08

(表中数字为本文按 M/M/1 公式代入 ρ\rho 的推导值,单位是「平均服务时间 SS 的倍数」,不是任何系统的实测。第一列的 LL 是「排队 + 正在服务」的总人数;纯队列长度是 Lq=ρ2/(1−ρ)L_q=\rho^{2}/(1-\rho),比它小 ρ\rho。)

这张表是全文最该记住的一张。它在说一件很反直觉的事:余量的价格不是线性的。从五成用到六成,「贵」了 0.5 个 SS;从八成用到九成,「贵」了 5 个 SS;从九成用到九五成,「贵」了 10 个 SS。最后那五个百分点,代价等于前面所有百分点之和还多。

现实里还有一个更麻烦的效应:服务时间本身会随利用率上升而变长。队列长了,超时重试变多,缓存命中率下降,批处理窗口被拉长——这些都会让 μ\mu 变小,而 μ\mu 变小又让 ρ\rho 变大。这是一个正反馈,Google SRE 把它写成一句话:级联失败是一种随时间的正反馈,一部分系统失败会提高其他部分失败的概率。

这一节想让你记住的一件事:ρ\rho 每往 1 靠近一点,等待的代价就翻一档;容量规划的安全边际买的是「曲线的平坦段」,不是「机器的空闲」。

第三笔账:平均之外的那条尾巴

平均值是最容易骗人的统计量。运维关心的是「有多少人等了很久」,而这个问题的答案在分布尾部,不在均值里。

M/M/1 的排队时间分布有一个干净的闭式结果:先有「完全不用等」的概率质量,再有一段指数尾巴——

P(Wq=0)=1−ρ,P(Wq>t)=ρ e−(μ−λ)t(t≥0)P(W_q = 0) = 1-\rho,\qquad P(W_q > t) = \rho\, e^{-(\mu-\lambda)t}\quad (t\ge 0)

这个式子有两个值得注意的性质。第一,零处的概率质量是 1−ρ1-\rho,也就是「到的时候窗口正好空着」的比例;ρ\rho 越小,不排队的人越多。第二,指数项里的衰减率是 μ−λ\mu-\lambda,也就是「服务能力超出的那部分」,超出得越少,尾巴衰减得越慢。

令 P(Wq>t)=0.01P(W_q>t)=0.01,解出排队等待的 99 分位:

t99=ln⁡(100ρ)μ−λ=ln⁡(100ρ)1−ρ St_{99} = \frac{\ln(100\rho)}{\mu-\lambda} = \frac{\ln(100\rho)}{1-\rho}\,S

这个式子只在 ρ>0.01\rho>0.01 时才有解;ρ≤0.01\rho\le 0.01 时,「不排队」的概率已经超过 99%,P99 直接是 0——这是个容易被忽略的边界,别把公式往外推。

代入 ρ=0.7\rho=0.7:ln⁡70≈4.248\ln 70 \approx 4.248,除以 0.3 得 14.16,即排队等待的 P99 是平均服务时间的 14.16 倍;代入 ρ=0.9\rho=0.9:ln⁡90≈4.500\ln 90 \approx 4.500,除以 0.1 得 45 倍。

现在把这两个点和均值的增幅放在一起看,得到一个必须说准的结论:从 ρ=0.7\rho=0.7 到 0.90.9,平均排队等待从 2.33 个 SS 涨到 9 个 SS,相对增幅约 3.86 倍;P99 从 14.16 涨到 45,相对增幅约 3.18 倍。所以「P99 相对涨得更快」是不成立的——真正不对称的是绝对量:均值多等了 6.67 个 SS,P99 多等了 30.8 个 SS,是前者的四倍多。对用户来说,多等 30 个 SS 和多等 6 个 SS 完全不是一回事。

这解释了一个常见的现象:压测时看平均延迟「还行」,上线后用户投诉「卡」。压测的流量通常是匀速的、脚本化的,尾部的触发条件(突发到达、长请求、GC、批窗口抖动)根本没被触发。等真实流量进来,尾部才长出来。

这一节想让你记住的一件事:均值告诉你系统「大体上」怎么样,P99 告诉你用户「具体感受到了什么」;在高利用率下,P99 与均值的差距不是按比例拉开,而是按绝对时间拉开。

为什么「GPU 利用率」这个指标会骗你

很多监控面板给的「GPU 利用率」,是「采样周期内有计算任务在跑」的时间占比。这个定义对运维有用,但它不是「算力被用掉了百分之多少」,更不是排队模型里的 ρ\rho。同一句「利用率 100%」,在两种完全不同的意义上都成立。

第一种是带宽打满:decode 每一步都要把权重从显存搬一遍,如果搬运时间占满了每一步的时间,带宽利用率接近 100%,而算力单元大部分时间在等数据。

第二种是算力打满:prefill 阶段大量 token 并行计算,算力接近峰值,此时带宽反而闲着。

把这两个口径算一遍就清楚了。用本文的假设参数:8B bf16 权重 16.06 GB,带宽 5.3 TB/s,bf16 峰值 1307 TFLOPS。批大小 32、上下文 512 token 时,一步要搬的字节是

bytes=Bw+B⋅Sctx⋅kv\text{bytes} = B_w + B \cdot S_{ctx} \cdot \text{kv}

代入得 16.06+32×512×131072÷109≈16.06+2.15=18.216.06 + 32 \times 512 \times 131072 \div 10^{9} \approx 16.06 + 2.15 = 18.2 GB,按带宽算需要 3.43 毫秒。这一步用掉的算力是 32×2×8.03=51432 \times 2 \times 8.03 = 514 GFLOP,而这 3.43 毫秒里理论可提供的算力是 1307×0.00343≈4.491307 \times 0.00343 \approx 4.49 TFLOP。于是:

带宽利用率≈100%,算力利用率≈0.5144.49≈11.5%\text{带宽利用率} \approx 100\%,\qquad \text{算力利用率} \approx \frac{0.514}{4.49} \approx 11.5\%

同一个瞬间,一个指标说「满了」,另一个说「才用了一成」。这不是矛盾,是两个不同的分母。

还有一种更隐蔽的跳变:prefill 与 decode 混跑时,同一张卡会在「算力打满」与「带宽打满」两种状态之间来回切换。监控上看到的是一条利用率 80% 的平线,实际上它可能是「一半时间算力满载、一半时间带宽满载」的平均——但这两种满载对延迟的影响完全不同:前者拉长首字时间,后者拉长吐字间隔。看平均利用率永远分不出这两种情况,只能靠分阶段计时。

这在容量规划上会造成实实在在的误判:看到算力利用率只有一成,就认为「还有九成余量,可以多塞点」;实际上瓶颈根本不在算力,塞进去的请求只会排队。反过来,看到带宽利用率 100% 就认为「必须换卡」,也不对——把 batch 加大、把上下文压短、把 KV 量化,都能在同一张卡上换出更多有效吞吐。

这一节想让你记住的一件事:利用率必须带分母;「算力用了多少」和「带宽用了多少」是两个数,决定容量的往往是后者。

大模型服务里,服务速度不是一个常数

前面几节把 μ\mu 当成常数。到了大模型推理,这个假设立刻碎了:μ\mu 取决于 batch 大小、上下文长度、显存带宽、以及这一批里有多少 token 要做 prefill。

先只看 decode 阶段的权重账。对一个参数量为 NN 的稠密模型,生成一个 token 需要大约 2N2N 次浮点运算(每个权重参与一次乘加)。同时,因为自回归解码每步只处理一个 token,权重必须被完整读一遍。于是单步时间近似为「读权重的时间」与「算这一步的时间」中的较大者:

tstep≈max⁡(BwBW, 2NBpeak)t_{\text{step}} \approx \max\left(\frac{B_w}{\text{BW}},\ \frac{2NB}{\text{peak}}\right)

其中 BwB_w 是权重字节数,BW\text{BW} 是显存带宽,peak\text{peak} 是算力峰值,BB 是批大小。这个式子的结构决定了一件事:批越小,越受带宽限制;批越大,越受算力限制。两者相等的那个批大小,就是「从带宽瓶颈切到算力瓶颈」的拐点。

代入一组本文假设的参数做个算例:8B 参数、bf16(每参数 2 字节)→ 权重约 16.06 GB;假设加速卡带宽 5.3 TB/s、bf16 峰值 1307 TFLOPS(这两个数是本文为了演示取的量级假设,不绑定任何具体型号)。则有:

  • 读权重:16.06×109÷5.3×1012≈3.0316.06\times10^{9} \div 5.3\times10^{12} \approx 3.03 毫秒
  • 单 token 计算:2×8.03×109÷1307×1012≈12.32\times 8.03\times10^{9} \div 1307\times10^{12} \approx 12.3 微秒
  • 拐点批大小:3.03 ms÷12.3 μs≈2463.03\text{ ms} \div 12.3\,\mu s \approx 246

也就是说,在批大小 32、上下文很短时,这张卡几乎全部时间都在等显存把权重搬过来,算力单元闲着。此时一步仍是 3.03 毫秒,但这一步同时推进了 32 个请求,于是整卡吞吐约 32÷3.03 ms≈1056032 \div 3.03\text{ ms} \approx 10560 token/秒,而单个请求的速度仍是 1÷3.03 ms≈3301 \div 3.03\text{ ms}\approx 330 token/秒——在这个「只读权重」的模型里,批处理几乎不改变单个请求的速度,它改变的是「一张卡同时服务多少个请求」。

但这个算例只算了权重,没算 KV,也没算 prefill 和排队。这是个必须立刻补上的缺口:上下文越长,KV 读取越大,很快反超权重。两者相等的批大小是

B∗=BwSctx⋅kvB^{*} = \frac{B_w}{S_{ctx}\cdot \text{kv}}

代入 8k 上下文:16.06×109÷(8192×131072)≈15.016.06\times10^{9} \div (8192 \times 131072) \approx 15.0。也就是说,8k 上下文时批大小到 15,KV 读取就已经和权重一样重;再往上,decode 的带宽几乎全花在 KV 上。这个数字比大多数人直觉里的小得多。

这一节想让你记住的一件事:batch 抬的是吞吐不是单请求速度,而且这个结论只在「上下文短、KV 可以忽略」时成立;上下文一长,主导项就换人了。

批处理的两面:抬上去的 μ 与加上去的等待

既然批处理能摊薄权重读取,为什么不能无限加大 batch?因为它同时做了两件相反的事。

第一件是排队:请求必须等到一个批凑齐才能开始算。在静态批处理里,更糟——一批里所有请求必须等最慢的那个跑完,整批才能释放,新来的请求只能等下一批。Orca 在 OSDI 2022 描述的就是这个问题:批次在迭代之间不可变,早完成的请求无法提前返回,新到的请求必须等当前批整体结束。

第二件是干扰:prefill(处理整个输入提示、产出第一个 token)是算力密集的,decode(逐 token 生成)是带宽密集的。把两者混在同一批里,一次长 prefill 会把所有正在 decode 的请求卡住一个 prefill 的时长,表现为 TPOT 的尖刺。Sarathi-Serve 的做法是把 prefill 切成近似等长的小块(chunked prefill),让每个迭代里 prefill 与 decode 的工作量接近均匀,从而「不暂停正在进行的 decode 就往批里加新请求」。

调度方式批的边界主要收益主要代价
静态批整批一起开始、一起结束实现最简单早完成的请求占着位置,新请求等整批
连续批(迭代级调度)每个迭代都能进出请求吞吐明显提升,短请求早返回批大小抖动,单步时间不均
连续批 + 分块 prefill每迭代的 prefill 量被切成小块TPOT 尖刺变小,长提示不再卡住解码首 token 时间略被拉长,实现复杂
prefill/decode 分离部署两个阶段在不同 GPU 上跑各自的并行策略可以独立优化要搬运 KV,多一笔网络开销

(表中机制描述来自 Orca、Sarathi-Serve、DistServe 三篇的公开摘要;收益与代价的排序是本文的归纳,不是论文的实测对比。)

这里有一个必须说准的取舍:连续批保证的是吞吐,不保证尾延迟下降。它让 GPU 更少空转,减少队头阻塞,通常也会改善尾延迟,但这取决于负载形状,不能反过来当成因果承诺。队列仍然在那里,只是被更快地消费。

DistServe 提供了一个更有用的视角:不要用「每秒多少请求」衡量容量,而要用「在 TTFT 与 TPOT 两个约束都满足的前提下,每秒最多能服务多少请求」,也就是 goodput。它的观察是,prefill 与 decode 对延迟的诉求不同(前者看 TTFT,后者看 TPOT),共置部署时两者互相干扰,只能牺牲一个或者过度配置资源;拆开部署后可以各自按需分配并行策略。这个思路对容量规划的意义是:同一张卡,在不同的 SLO 下「容量」是不同的数。

还有一个常被忽略的细节:批处理改变的不只是速度,还有排队的粒度。静态批处理下,一个新请求的等待单位是「一整批的时长」;连续批处理下,只要还有空位,它等的是「一个迭代的时长」。但这不等于「把 SS 缩小三个数量级就能直接套前面的公式」——请求的完整服务需求没有变短,变的是「什么时候能进来」。要算这种系统的等待,得用多服务台模型(下面一节),不能拿单服务台的 SS 硬套。

这一节想让你记住的一件事:批处理把 μ\mu 抬上去的同时,把「等批凑齐」的成本加了进来;真正的容量指标是满足 SLO 的吞吐,而不是 GPU 利用率或裸 QPS。

长上下文:内存里的并发与带宽上的天花板

前面说限制并发的是显存,现在把这笔账算清。Transformer 的 KV 缓存大小按下面的式子增长:

KV bytes per token=2×Nlayer×Hkv×dhead×b\text{KV bytes per token} = 2 \times N_{layer} \times H_{kv} \times d_{head} \times b

其中 2 是键和值各一份,NlayerN_{layer} 是层数,HkvH_{kv} 是 KV 头数(分组查询注意力下小于查询头数),dheadd_{head} 是每头维度,bb 是每元素字节数。

以 Meta Llama-3-8B(NousResearch 镜像)的公开配置为例:32 层、8 个 KV 头、隐藏维 4096、32 个查询头(故每头维度 128)、bf16。代入得:

2×32×8×128×2=131072 字节=128 KiB per token2 \times 32 \times 8 \times 128 \times 2 = 131072\ \text{字节} = 128\ \text{KiB per token}

这个数字很好记:每 1000 个 token 约 131 MB(约 125 MiB)。一条 8192 token 的序列,光 KV 就要 1 GiB。而 8B 模型的权重只有约 16.06 GB。于是显存里留给 KV 的部分,决定了「同时能装下多少条序列」:

并发序列数≈M−Bw−OKV bytes per token×上下文长度\text{并发序列数} \approx \frac{M - B_w - O}{\text{KV bytes per token} \times \text{上下文长度}}

其中 MM 是显存总量,OO 是工作区与碎片余量(本文按 2 GB 估)。假设一张 192 GB 的卡,代入上式:

上下文长度每条序列 KV可容纳序列数decode 带宽天花板
2048256 MiB648约 19744 token/秒
81921 GiB162约 4936 token/秒
327684 GiB40约 1234 token/秒
13107216 GiB10约 309 token/秒

(前三列数字为本文按上式计算,未计显存碎片与分页管理的额外开销,属上限估计。第四列见下式。后两行是「同一结构、同样显存」的外推:原始 Llama-3-8B 的配置窗口是 8192,32k 与 128k 并不代表该模型原生支持,只表示若上下文真的拉到那么长,资源账会怎么变。)

第四列值得单独解释,因为它是一个和批大小无关的硬上限。在上下文很长时,每一步要搬的字节主要是 KV:

吞吐上限≈BWSctx⋅kv\text{吞吐上限} \approx \frac{\text{BW}}{S_{ctx}\cdot \text{kv}}

推导很简单:每生成一个 token,就要读一整行 KV(Sctx⋅kvS_{ctx}\cdot\text{kv} 字节),所以每秒最多能生成的 token 数就是带宽除以这个字节数。批大小不在式子里——加批只改变「这些 token 分给多少个用户」,不改变「一秒最多出多少 token」。

这张表解释了长上下文服务最容易被忽略的连锁反应。第一层是内存:上下文翻四倍,并发上限降到约四分之一。第二层是带宽:并发掉了,但总吞吐也上不去,因为天花板按上下文反比下降。两层叠加的结果是,同样的到达率下 μ\mu 掉到四分之一、甚至更低,ρ\rho 随之升高。原本跑在 0.7 的服务,用户把上下文从 8k 改成 32k 之后,工作点会被推到 2.8 倍——理论上不可行,实际表现是队列爆掉、超时、大批请求被丢弃。

还有一层损耗本文没有计入:显存碎片。上面的并发数是「理想装箱」的结果,真实系统里序列长度不一、生灭交替,会出现「总量够、但没有连续空间」的情况,实际并发通常低于上限一到两成。分页式管理就是为了把这种碎片压下去,代价是多一层地址映射的开销。

这一节想让你记住的一件事:上下文长度不是免费的参数,它按 token 线性吃掉显存、按反比压低带宽天花板,最终通过 μ\mu 传导到排队曲线上。

一个完整算例:8k 上下文、162 个槽位,等待到底有多少

把前面的零件装起来跑一遍。设定:8B 模型、bf16、8k 上下文、192 GB 显存、5.3 TB/s 带宽、1307 TFLOPS 峰值,每个请求输出 500 个 token。

第一步,定并发。按上一节的表,8k 上下文下最多装 162 条序列,所以 B=162B=162。注意这里的 162 不是「一个服务台」,而是 162 个并行的槽位:每个槽位一次服务一条序列,服务时间 17.9 秒(下面会算)。

第二步,算一步的字节数:

bytes=16.06 GB+162×8192×131072 B≈16.06+173.9=190.0 GB\text{bytes} = 16.06\ \text{GB} + 162 \times 8192 \times 131072\ \text{B} \approx 16.06 + 173.9 = 190.0\ \text{GB}

第三步,算一步的时间与吞吐:

tstep=190.0×1095.3×1012≈35.9 ms,吞吐=1620.0359≈4519 token/秒t_{\text{step}} = \frac{190.0\times10^{9}}{5.3\times10^{12}} \approx 35.9\ \text{ms},\qquad \text{吞吐} = \frac{162}{0.0359} \approx 4519\ \text{token/秒}

这里有个容易被忽略的细节:这一步要读的 KV 不是「一个请求的 KV」,而是「批里所有请求的 KV」。批越大,每步读的 KV 越多,所以吞吐不会随批线性增长,而是被那条带宽天花板拦住——B=162B=162 时效率已经到 162/(15.0+162)≈91.5%162/(15.0+162)\approx 91.5\%,再翻倍批大小也只能多出不到一成。

单请求速度是 1÷0.0359≈27.91 \div 0.0359 \approx 27.9 token/秒——比短上下文时的 330 token/秒低了近十二倍。一个 500 token 的回复需要 500×0.0359≈17.9500 \times 0.0359 \approx 17.9 秒。

decode 一步的字节账
图 2 decode 一步的字节账:8B 权重 16.06 GB 只是开胃菜,162 条 8k 序列的 KV 读取 173.9 GB 才是主菜(本文自绘)

第四步,算等待,但不能直接套单服务台公式。162 个槽位、每槽 17.9 秒,系统容量是 162/17.9≈9.05162/17.9 \approx 9.05 请求/秒;若运行在 ρ=0.7\rho=0.7,则 λ≈6.3\lambda \approx 6.3 请求/秒。此时该用的是多服务台排队(c=162c=162 的 Erlang-C),而不是把 S=17.9S=17.9 秒直接塞进 M/M/1:

Pwait=acc!⋅cc−a∑k=0c−1akk!+acc!⋅cc−a,a=λS=cρP_{\text{wait}} = \frac{\dfrac{a^{c}}{c!}\cdot\dfrac{c}{c-a}}{\displaystyle\sum_{k=0}^{c-1}\frac{a^{k}}{k!}+\dfrac{a^{c}}{c!}\cdot\dfrac{c}{c-a}},\qquad a=\lambda S=c\rho

代入 c=162c=162、a=113.4a=113.4:等槽位的概率小到可以忽略(数值上低于千分之一),平均等槽时间不足 1 毫秒。即使把利用率推到 ρ=0.9\rho=0.9,等槽概率也只有约 14%,平均等槽约 0.15 秒——和 17.9 秒的服务时间比,仍然可以忽略。

这正是「模型选错」的代价:如果按单服务台、把 S=17.9S=17.9 秒硬套公式,算出来的等待会比真实情况高几个数量级。原因是服务台一多,随机性被池化摊平了:162 条序列各自独立起伏,整体反而很稳。

但排队不等于全部。用户感知的是两个数:

  • TTFT ≈ 等槽时间 + 一次 prefill。8k 提示的 prefill 约 2×8.03×109×8192÷1307×1012≈1012 \times 8.03\times10^{9} \times 8192 \div 1307\times10^{12} \approx 101 毫秒(算力口径,忽略注意力本身的二次项)。所以 TTFT 大约 0.1 秒量级。
  • TPOT 就是一步的时间,35.9 毫秒,约每秒 28 个 token。
  • 整段 17.9 秒,但用户不等整段——他看到的是「多久出第一个字」与「字往外蹦得多快」。

这一节想让你记住的一件事:「利用率高就等很久」只在服务台很少时成立;槽位一多,排队会被摊平,真正决定体验的是每个槽位的服务时间与它的波动,而不是 ρ\rho 这个数本身。

尾延迟放大与重试风暴

单机排队之外,还有一层放大发生在调用链上。一个前端请求往往要扇出到 nn 个后端分片,只要有一个分片慢,整个请求就慢。如果每个分片「变慢」的概率是独立的 pp,那么至少一个变慢的概率是:

P(整体变慢)=1−(1−p)nP(\text{整体变慢}) = 1 - (1-p)^{n}

代入 p=1%p=1\%:

扇出分片数 nn整体至少一个变慢的概率
87.7%
1614.9%
3227.5%
6447.4%
10063.4%

(本文按二项分布公式计算,假设各分片独立;实际系统中分片共享资源,相关性会让结果偏离这个表。)

这张表说明:尾延迟不是「少数用户体验差」,它在扇出结构里会被放大成「多数请求都受影响」。1% 的分片级慢,在 100 路扇出下变成 63% 的请求级慢。所以「我们的 P99 只有 1%」这句话,在分布式系统里几乎不成立——P99 是分片级的,用户看到的是请求级的。

更麻烦的是重试。超时重试会把「慢」变成「更多负载」。如果每个请求平均额外重试 rr 次,那么后端实际承受的到达率是

λeff=λ (1+r)\lambda_{\text{eff}} = \lambda\,(1+r)

r=0.5r=0.5 时负载涨一半,r=1r=1 时翻倍,r=4r=4 时五倍。而负载一涨,ρ\rho 就涨,ρ\rho 一涨,超时更多,重试更多——这就是 Google SRE 所说的正反馈型级联失败。SRE 书里给的处置不是「加机器」,而是在客户端做自适应限流:客户端统计最近两分钟的发出请求数 requests 与被接受数 accepts,当 requests 超过 accepts 的 KK 倍(书中示例 K=2K=2)时,开始按下面的概率在本地丢弃新请求:

P(本地拒绝)=max⁡(0, requests−K⋅acceptsrequests+1)P(\text{本地拒绝}) = \max\left(0,\ \frac{\text{requests} - K \cdot \text{accepts}}{\text{requests} + 1}\right)

这个式子值得单独体会:它不是一个固定的限流阈值,而是「按最近被拒的比例动态调整」。它的目的是让客户端在服务端崩溃之前先自己减速,把「重试风暴」掐在源头。

这一节想让你记住的一件事:尾延迟会随扇出被放大、随重试被二次放大;限流的正确位置往往在客户端,而不是在服务端加机器。

加机器为什么有时没用

「慢了就加卡」是最常见的反应,但它只在特定条件下有效。判断的依据是:加卡之后,每卡的批大小有没有下降。

如果负载固定、可以分摊,加卡确实能降 TPOT。回到刚才的算例:162 个请求分到两张卡、每卡 81 条,每步要搬的字节变成 16.06+81×1.0737≈103.016.06 + 81\times1.0737 \approx 103.0 GB,一步 19.4 毫秒,单请求速度从 27.9 涨到 51.4 token/秒,500 token 从 17.9 秒降到 9.7 秒。前提是权重能在每张卡上各放一份、序列之间不需要跨卡读 KV。

如果加卡是为了「接更多流量」,每卡仍然跑满批,那么每步还是 35.9 毫秒,TPOT 一点不变——加卡提高的是总吞吐(从 4519 到约 9000 token/秒,不到两倍,因为权重被重复读了一遍),不是单请求速度。

如果瓶颈根本不在 GPU 上——同一台机器的 tokenizer 与预处理、网络、调度器、存储——加卡完全无效。这就是 Amdahl 定律:设可并行的比例是 pp,并行度是 kk,端到端加速比的上限是

speedup(k)=1(1−p)+p/k\text{speedup}(k) = \frac{1}{(1-p) + p/k}

p=0.9p=0.9、k=∞k=\infty 时上限是 10 倍;p=0.5p=0.5 时上限只有 2 倍。加卡买到的是 p/kp/k 这一项,买不到 1−p1-p 那一项。

所以判断「该不该加卡」有一个顺序:先看单请求的 TPOT 是不是被单卡带宽顶住了(是→如果负载可分摊且权重装得下,加卡能降 TPOT;如果每卡仍满批,加卡只增吞吐);再看是不是单点共享资源卡住(是→先拆它);最后才看总容量够不够。

这一节想让你记住的一件事:加卡改变的是「服务台的个数」,能不能降单请求延迟,取决于每卡的批大小会不会跟着下降。

怎么量:三段延迟与直方图

前面所有公式都要求你知道 λ\lambda、μ\mu、SS。这三个量在真实系统里都不好测,最容易犯的错是把「总延迟」当成一个数。

正确的拆法是把一次请求切成三段:

  1. 排队时间:从请求进入调度器到开始第一次计算。这一段由并发是否打满决定。
  2. prefill 时间:处理输入提示、产出第一个 token。这一段近似正比于提示长度,算力密集。
  3. decode 时间:从第二个 token 到最后一个 token。这一段近似等于「输出 token 数 × 单步时间」,带宽密集。

三段相加才是总延迟,而它们的瓶颈完全不同:排队看余量,prefill 看算力与提示长度,decode 看带宽与上下文。把它们混成一个「P99 延迟 3 秒」,你既不知道该扩容还是该减上下文,也不知道该改调度还是该换卡。

第二个容易犯的错是只看均值。前面已经算过,ρ=0.5\rho=0.5 时排队等待的 P99 就是平均值的近八倍(7.82 对 1)。如果监控只报均值,你会一直觉得「还行」。

第三个错更隐蔽,叫协调遗漏(coordinated omission):闭环压测时,客户端发一个请求、等它回来、再发下一个。当系统变慢时,客户端也跟着变慢,于是它在最慢的那段时间里少发了请求——恰恰把最该被记录的那部分延迟漏掉了。结果是压测报告里的 P99 好得离谱,上线后完全对不上。

修法很朴素:用固定到达率的开环压测(按计划时刻发请求,不管前一个有没有回来),并把延迟记成直方图而不是累加器。这样测出来的分位数才是「用户实际会遇到的分布」。同时要报样本量与观测窗口:P99 只由最慢的 1% 决定,样本太少时这个数会剧烈跳动,单看一个数没有意义。

这一节想让你记住的一件事:延迟要分段测、分位数要直方图算、压测要开环发;否则你测到的不是系统,是测试脚本。

工程上能做的四件事

把前面的账合起来,能落到操作层面的其实只有四件事,而且它们对应的是四个不同的杠杆。

第一件,把工作点定在曲线的平坦段。从表一可以看出,0.6 到 0.7 之间,平均排队等待从 1.5 个 SS 涨到 2.33 个 SS;0.8 到 0.9 之间,从 4 涨到 9。两段的绝对增量是 0.83 个 SS 与 5 个 SS,后者是前者的六倍。把水位线画在 0.7 附近,付出的是一部分利用率,买回来的是「突发流量不会立刻转成用户等待」。服务时间越长、槽位越少的系统,水位线要画得越低。

第二件,用 goodput 而不是 QPS 做容量指标。QPS 只统计「发出去了多少」,goodput 统计「多少满足了 TTFT 与 TPOT 约束」。两者的差在低负载时是零,在高负载时会突然拉开——那个拉开的位置,才是真正的容量边界。

第三件,在调度层把 prefill 的尖刺磨平。分块 prefill 与 prefill/decode 分离,本质上都是在保护 decode 的 TPOT:前者让每个迭代的工作量接近均匀,后者让两种负载不再抢同一块算力。这两种做法都不提高理论峰值,但它们让「同样的 μ\mu 更可预测」。

第四件,把过载处置写成确定行为。限流、降级(返回更短的回答、跳过检索、缩小候选集)、超时上限、重试预算,这四样必须在系统设计时就定下来,而不是等出事那天临时决定。SRE 书的原则很直接:过载时要有能力「服务降级响应」,而不是让整个系统一起变慢。

这四件事有一个共同点:它们都不改变模型、不改变硬件、不改变算法。它们改变的是「系统在接近饱和时如何表现」,而这恰恰是用户感知最强、也最容易被忽略的部分。

这一节想让你记住的一件事:容量规划不是「买多少卡」,而是「把水位线画在哪里、把过载时的行为定义成什么样」。

四句常见的错话

下面四句话在工程讨论里出现频率极高,每一句都能用前面的公式直接驳掉。

第一句是「利用率才六成,再加点没问题」。这句话的问题在于它只看了 ρ\rho,没看 SS 的量级,也没看服务台的个数。单服务台、S=3S=3 毫秒时,0.6 对应 4.5 毫秒等待,确实没问题;单服务台、S=18S=18 秒时,等待就是 27 秒。同一个利用率,两个完全不同的世界。

第二句是「加两张卡就快了」。加卡提高的是总吞吐;能不能降单请求延迟,取决于每卡批大小会不会跟着下降,以及权重能不能在每卡各放一份。

第三句是「上下文从 8k 提到 32k,只是参数变了个数」。这句话在算法侧成立,在服务侧不成立:上下文翻四倍,KV 翻四倍,并发上限降到约四分之一,带宽天花板也降到约四分之一。同一个模型、同一张卡,能同时服务的人数掉到四分之一。

第四句是「模型没换,服务不该变」。模型确实没换,但上下文长度、并发数、批大小、KV 命中率任何一个变了,μ\mu 就变了。服务系统的行为不是模型的属性,而是「模型 + 调度 + 流量形状」三者的合成。

这四句话的共同毛病是一样的:把「一个数字变了」当成「系统没变」。排队系统里没有哪个参数是孤立的,改一个,μ\mu 会跟着动,ρ\rho 会跟着动,等待按具体公式跟着动——但不要笼统地说「按平方级」,不同模型的增长阶并不相同。

这一节想让你记住的一件事:讨论容量时永远要同时报四个数:利用率、服务时间的量级、服务台的个数、等待的分位数;少一个就无法判断这句话对不对。

边界与未解:这个模型什么时候会骗你

必须把话说明白:本文的公式是教学模型,不是容量规划工具。它们的假设在真实系统里几乎全都不成立。

其一,到达不是泊松的。真实流量有昼夜周期、有营销活动带来的脉冲、有客户端重试造成的同步波。泊松假设下「间隔无记忆」,真实流量里「刚刚来过一大批」往往意味着「马上还会来」。

其二,服务时间不是指数的。大模型的请求长度分布是重尾的:大部分请求几百 token,少数请求几万 token。指数分布的变异系数是 1,而重尾分布的变异系数可以远大于 1。在 G/G/1 的 Kingman 近似里,排队时间与「到达与服务变异系数的平均」成正比:

E[Wq]≈ρ1−ρ⋅ca2+cs22⋅SE[W_q] \approx \frac{\rho}{1-\rho} \cdot \frac{c_a^2 + c_s^2}{2} \cdot S

这里 ca2c_a^2、cs2c_s^2 分别是到达间隔与服务时间的变异系数平方(方差除以均值平方)。这条式子比 M/M/1 更有用,因为它显式地把「请求长度有多不均匀」写进了公式:在到达接近规则(ca2c_a^2 很小)时,等待大致随 cs2c_s^2 线性增长;若两项都大,等待是两项之和的函数,不能只看一个。

其三,batch 让 μ\mu 与状态相关。批越大,单步时间越长,但每步服务的请求也越多;这不是一个常数服务率,而是一个「随负载变化」的服务率。M/M/1 假设服务率固定,所以它会低估高负载下的吞吐,也会低估批处理带来的排队延迟。

其四,单服务台假设在 GPU 上通常不成立。一个 batch 里的请求是并行的,应该用多服务台(M/M/c 或 Erlang-C),这也是本文算例里「单服务台会高估几个数量级」的原因。多服务台会让曲线更平,但 ρ→1\rho\to 1 时照样爆炸,只是爆得晚一些。

其五,本文的带宽算法是理想上界。把所有必须读的字节相加再除以带宽,等价于假设「零额外开销、访存与计算完美重叠」。真实系统有调度开销、显存碎片、读写竞争,实际吞吐通常低于这个上界,不会高于它。

所以正确的用法是:用这些公式判断形状与量级,用真实测量判断具体数值。测量时也要分阶段:把 TTFT 拆成「等槽 + prefill」,把 TPOT 单独看 decode,否则一个总延迟数字根本定位不到瓶颈在哪。

这一节想让你记住的一件事:公式的价值在于告诉你「往哪个方向改会有用」,而不是告诉你「线上的数应该是多少」。

小结

回到开头那个银行大厅。余量确实存在,但它是以碎片的形式存在的;队伍不是被平均填满的,而是被随机性填满的。四件事可以把这篇的账收起来:

第一,利用率是一个比值,在单服务台下 ρ/(1−ρ)\rho/(1-\rho) 决定了等待的量级。七成对应「平均排队等待 2.33 倍、P99 14.16 倍」;但服务台一多,这条曲线就会变平,所以先数清你有几个服务台。

第二,「利用率」必须带分母。同样是 100%,可以是带宽打满、算力只用一成,也可以是算力打满、带宽闲着。决定容量的是那个真正被顶住的分母。

第三,大模型服务里服务速度不是常数。batch 把权重读取摊薄,抬的是吞吐;长上下文按每 token 128 KiB 吃掉显存,并且在带宽上设了一条与批大小无关的天花板;prefill 与 decode 混跑,伤的是尾部的 TPOT。

第四,尾延迟会沿调用链放大,也会被重试二次放大。所以过载处置要前移到客户端,容量指标要换成 goodput,工作点要画在平坦段。

这四条都不新,但它们在同一个系统里同时成立时,效果是叠乘的。理解这一点,比记住任何一个具体数字都值钱。

速查:六个式子

  • 利用率:ρ=λ/μ\rho = \lambda/\mu
  • 平均排队时间:Wq=ρS/(1−ρ)W_q = \rho S/(1-\rho)
  • 排队等待的 99 分位:t99=ln⁡(100ρ) S/(1−ρ)t_{99} = \ln(100\rho)\,S/(1-\rho)
  • 每个 token 的 KV:2NlayerHkvdheadb2 N_{layer} H_{kv} d_{head} b
  • 长上下文带宽天花板:BW/(Sctx⋅kv)\text{BW}/(S_{ctx}\cdot kv)
  • 扇出放大:1−(1−p)n1-(1-p)^n

📋 来源与核验记录

本文为概念科普,公式为标准排队论结果(M/M/1 稳态分布、利特尔法则、Erlang-C、Kingman 近似、二项分布、Amdahl 定律),由本文自行推导与代入,不属于任何单一来源;文中所有数值均标注了「本文推导」或「本文假设」,未引用任何未核实的实测数据。

一手来源(本轮逐条打开核读):

  1. Google SRE Book,第 21 章《Handling Overload》(Alejandro Forero Cuervo)——过载处置、服务降级、客户端自适应限流与拒绝概率公式(书中以 accepts 倍数 K 表达,示例 K=2)。https://sre.google/sre-book/handling-overload/
  2. Google SRE Book,第 22 章《Addressing Cascading Failures》(Mike Ulrich)——级联失败的正反馈定义、服务器过载与重试放大。https://sre.google/sre-book/addressing-cascading-failures/
  3. Orca: A Distributed Serving System for Transformer-Based Generative Models,OSDI 2022(Yu 等)——迭代级调度(连续批处理)的动机与机制、静态批的缺陷。https://www.usenix.org/conference/osdi22/presentation/yu
  4. Sarathi-Serve: Taming Throughput-Latency Tradeoff in LLM Inference,arXiv:2403.02310(2024)——分块 prefill 与无停顿调度。https://arxiv.org/abs/2403.02310
  5. DistServe: Disaggregating Prefill and Decoding for Goodput-optimized LLM Serving,arXiv:2401.09670(2024)——TTFT 与 TPOT 分阶段 SLO、goodput 定义、共置部署的干扰。https://arxiv.org/abs/2401.09670
  6. Efficiently Scaling Transformer Inference,arXiv:2211.05102(2022,Pope 等)——推理效率的分析模型、访存与算力的权衡、多查询注意力对上下文长度的放大作用。https://arxiv.org/abs/2211.05102
  7. Meta Llama-3-8B 的 NousResearch 镜像配置(config.json,本轮读取)——32 层、8 个 KV 头、hidden 4096、32 个查询头、最大位置 8192、bf16,用于 KV 缓存与权重占用的算术。https://huggingface.co/NousResearch/Meta-Llama-3-8B/blob/main/config.json

本文自行推导的清单(非来源数据):

  • M/M/1 的稳态分布、L=ρ/(1−ρ)L=\rho/(1-\rho)、W=S/(1−ρ)W=S/(1-\rho)、Wq=ρS/(1−ρ)W_q=\rho S/(1-\rho)、P(Wq>t)=ρe−(μ−λ)tP(W_q>t)=\rho e^{-(\mu-\lambda)t}、t99=ln⁡(100ρ)S/(1−ρ)t_{99}=\ln(100\rho)S/(1-\rho),以及 Erlang-C 的等槽概率公式。
  • 表一全部数值(按上式代入 ρ\rho 计算,单位为平均服务时间的倍数)。
  • 8B bf16 权重 16.06 GB、KV 每 token 131072 字节(=128 KiB)、8192 token 对应 1 GiB、192 GB 显存下的并发序列数(假设工作区与碎片余量 2 GB)。
  • decode 单步 3.03 毫秒(只读权重的理想下界)、单 token 计算 12.3 微秒、拐点批大小约 246、8k 上下文下 KV 与权重相等的批大小约 15、批 32 且上下文 512 时整卡吞吐约 10560 token/秒、8k/162 并发下每步 35.9 毫秒与整卡吞吐约 4519 token/秒——均基于本文假设的带宽 5.3 TB/s 与峰值 1307 TFLOPS,不代表任何具体型号的实测。
  • 带宽天花板表(BW/(Sctx⋅kv)\text{BW}/(S_{ctx}\cdot\text{kv}))、Erlang-C 在 c=162、rho=0.7/0.9 下的等槽概率与平均等待、扇出放大表(1−(1−p)n1-(1-p)^n,p=1%p=1\%,假设独立)。
  • 重试放大式 λ(1+r)\lambda(1+r) 与 Amdahl 式均为标准结果,本文只做代入说明。

未能核实或明确未做的部分:

  • 未在真实集群复现任何论文实验,未测量任何线上系统的排队分布。
  • M/M/1 的「指数服务时间」与「泊松到达」假设在真实流量下不成立,本文用 Kingman 近似说明了偏差方向,但没有给出真实分布的拟合结果。
  • Orca、Sarathi-Serve、DistServe、Efficiently Scaling Transformer Inference 四篇的机理描述取自公开摘要;它们的收益幅度(吞吐提升多少倍)本文未引用、未复述,因为未逐篇核对实验设置。
  • 文中加速卡的带宽 5.3 TB/s 与峰值 1307 TFLOPS 是本文为了演示取的量级假设,不绑定任何具体型号,也未核对任何产品规格页。
  • 32k 与 128k 两行是「同一结构、同样显存」的外推,不代表 Llama-3-8B 原生支持该长度(其配置的最大位置是 8192)。