推理系统的四个心智模型:吞吐、Roofline、KV Cache 与调度
大家每天都在 vibe coding:写下一段 prompt,按下回车,几秒后代码开始逐字出现。但很少有人了解,背后的 LLM 服务是怎么承载这种体量的并发请求的。
先看一条请求。从到达服务到吐出完整响应,只经过两个阶段。先做 prefill:把整段 prompt 送进模型,一次算出所有位置的 K/V,并产出第一个 token。之后进入 decode:每产一个 token,都要把此前所有 token 的 K/V 再读一遍。前者像一次大矩阵乘,后者像一场漫长的内存搬运。
这条链路解释了你每天看到的现象。首字延迟取决于 prompt 有多长、算力有多快;输出速度取决于显存带宽;上下文越长越慢,因为每一步都要把更长的 KV 再读一遍;并发一多,每个人都在等同一张卡。推理性能不是「GPU 快不快」,而是这笔账怎么分。
先给结论。decode 是带宽问题,prefill 是算力问题;batch 能把带宽问题变成吞吐,但 KV 会把每字节运算量压回带宽区;KV 是长出来的第二组权重,容量和带宽都要付;调度决定请求在时间线上怎么排,并行决定模型和 KV 在多张卡上怎么分,二者都不消掉总成本。
一、吞吐与延迟:同一条时间线上的两类解读
吞吐与延迟不是两个指标,而是同一条时间线上的两类解读。延迟问一条请求从进到出花了多久,吞吐问单位时间离开了几条请求、多少 token。把两条请求放在一起,答案就开始互相牵制。
工程上最容易混的是指标名字。TTFT、TPOT、TPS 都和 token 的时间有关,但一个问第一个 token 多久到,一个问后续每个 token 隔多久,一个问每秒能产出多少 token。TPS 指 tokens per second,既可以描述单条请求,也可以描述整个系统;SLO(Service Level Objective,服务等级目标)则是对 TTFT、TPOT 这类指标的约束。
| 指标 | 定义 | 主要构成 | 容易混淆的地方 |
|---|---|---|---|
| TTFT | Time To First Token,请求到达到第一个 token 返回 | 排队 + prefill + 首 token 采样 | 它不等于 prefill 时间,排队也计入 |
| TPOT / ITL | Time Per Output Token / Inter-Token Latency,decode 相邻 token 的平均间隔 | 每个 decode step 的权重与 KV 读取 | TPOT 是平均值,ITL 是逐 token;尾延迟要看 p99 |
| E2E 延迟 | 端到端延迟,从请求到达到最后一个 token 返回 | 用平均 TPS 反推 E2E,会把 TTFT 漏掉 | |
| 单请求 TPS | 单条请求每秒输出的 token 数 | 稳定 decode 时约 | 它描述一个人看字的速度,不是系统吞吐 |
| 系统 TPS | 所有请求每秒输出的 token 总数 | 并发 × 单请求 TPS,或总 token 数 / 总时间 | 脱离 SLO 谈系统 TPS,过载时数字反而好看 |
| QPS / RPS | 每秒完成(或到达)的请求数 | 与平均输出长度相乘才是 token 吞吐 | 请求有长有短,QPS 不能直接跨业务比较 |
| 并发 | 同时在途的请求数 | Little’s Law: | 排队中的请求也算在途,不等于正在 decode 的条数 |
| Goodput(有效吞吐) | 满足 SLO 的有效吞吐 | 只统计 TTFT、TPOT 达标的请求 | 系统 TPS 高而 goodput 低,说明在空转 |
延迟侧的关系可以写成一条式子:
其中 是输出 token 数。TTFT 由排队、prefill 和首 token 采样决定,TPOT 由 decode 每一步的带宽与算力决定;两者相加才是用户感知的完整等待。
吞吐侧要先问一句:说的是哪一层 TPS。单请求 TPS 在稳定 decode 时约等于 ,它决定用户看字快不快;系统 TPS 是所有请求的产出之和,近似等于正在 decode 的并发 乘以单请求 TPS,稳态下也等于 。系统 TPS 可以靠 batch 提高;单请求 TPS 未必变快,甚至可能因为每条请求要等整批算完而下降。线上通常同时报 p50 和 p99——p99 指 99% 的请求都不超过的延迟——因为平均值会把尾延迟盖住,batch 和调度的代价最先出现在 p99。
Little’s Law 把这件事写成一句乘法:
系统中的平均请求数,等于到达率乘以平均停留时间。对推理服务,它就是「并发 ≈ QPS × E2E 延迟」;这里的吞吐是请求吞吐,不是 token 吞吐,换成 token 还要乘平均输出长度。
这不是经验公式,是流量守恒。假设一段长度为 的时间里有 条请求,每条待了 个 tick。按请求算,占据的总面积是 ;按时间算,每个 tick 系统里有 条请求,总面积是 。两边相等,就得到 。
它给出的约束很明确:延迟和吞吐不能同时独立设定。给定 SLO 延迟 ,请求吞吐上限就是 。想提高请求吞吐,要么提高并发 ,要么降低延迟 。没有第三条路。
单卡 decode 的并发来自 batch。以 70B 模型为例,GPU 一次读 140 GB 权重,batch 为 1 时只产一个 token,batch 为 32 时产 32 个 token,权重读取被摊薄 32 倍。这就是批处理提高吞吐的全部秘密:不是算得更快,而是让同一次内存搬运服务更多人。
代价也在时间线上。在请求陆续到达、需要凑批的服务里,一条请求要等前面的人凑齐,等 GPU 空出来;batch 越大,等待越久,尾延迟越难看。平均延迟上升,最大延迟上升得更快,因为 batch 里所有请求共享同一个 step 的完成时间,最慢的那条决定整批的节奏。
下面这个模拟把时间摊开。四条请求在 tick 0–3 到达,prefill 各占一个 tick,之后每 tick 产一个 token。批大小从 1 调到 4,看 GPU 行和四条请求行怎么从一条竖线变成一片色块。
§1 · 吞吐与延迟
同一条时间线,两种读法
把四条请求放进同一条 GPU 时间线:串行时每个 tick 只有一个人产出,批处理时一个 tick 同时产出四个人。
4 条请求各生成 4 个 token
1 = 串行;4 = 最多四条同时 decode
tick 0:GPU 为 r1 做 prefill。这一步占满一个 tick,不产出 token;其他已到达的请求继续排队。
在途 2.20 = 请求吞吐 0.20 req/tick × 平均延迟 11.00 tick(右侧乘积 2.20)
先把批大小设在 1,均匀负载:四条请求排队,一条接一条,makespan 20 个 tick,吞吐 0.8 token/tick。GPU 忙碌率 100%,每个 tick 都在干活。再把批大小拉到 4:四个 prefill 之后,四条请求一起 decode,makespan 8 个 tick,吞吐 2 token/tick。GPU 还是 100% 忙。
忙不忙不说明问题,一个 tick 里坐了几个人才说明问题。串行时 GPU 的批槽只坐了一个人,满载率 100%;批处理时前四个 tick 在 prefill,后面四个 tick 才坐满,满载率 50%。同样叫「忙」,产出的 token 差了 2.5 倍。
Little’s Law 在两种设置下都对得上。串行时平均在途 2.2,等于 0.2 req/tick 乘 11 tick;批处理时 3.25,等于 0.5 乘 6.5。在途包括排队中的请求,所以它比「正在 decode 的条数」大——排队的人也在占系统的时间。
换到长尾负载,批处理的平均延迟只从 6.5 涨到 8,最大延迟却从 8 涨到 15。短请求在 tick 6 就全部结束,剩下 r4 一条拖到 tick 17,槽位空着,GPU 仍在「忙」。吞吐从 2 掉到 1.22,掉的部分就是长尾占着位置不产出的时间。
这组模拟里没有真正的排队延迟,因为请求都到得早。真实服务里请求随机到达,batch 越大,等凑批的时间越长;当到达率接近服务率,队列会突然变长。Little’s Law 的另一面是:你可以用并发换吞吐,但换来的吞吐会以延迟的形式记在用户账上。
所以吞吐与延迟的正确读法不是「优化哪一个」,而是「在哪个 SLO 下谈吞吐」。SLO 是约束,吞吐是在约束下测出来的结果。脱离延迟谈吞吐,等于只看发动机转速不看车速。
二、Roofline:每字节运算量决定你在拐点的哪一侧
第二个模型回答一个更底层的问题:一个 token 的时间,到底花在算力还是带宽。Roofline 把算力上限和带宽上限画在一起:
是每字节运算量,单位 FLOP/Byte,意思是每从内存搬一个字节,能做多少次浮点运算。 是带宽允许的算力, 是芯片的算力上限。两条线的交点叫拐点(ridge point):在交点左边,曲线随带宽上升,瓶颈是带宽;在交点右边,曲线变平,瓶颈是算力。它的位置是 。
以 H100 量级为例:FP16 稠密峰值 989 TFLOP/s,HBM 带宽 3.35 TB/s,拐点约 295 FLOP/Byte。每字节运算量低于它,GPU 的算力用不满,时间由内存带宽决定;高于它,带宽不再是瓶颈,时间由算力决定。
decode 落在拐点左边很远的地方。每产一个 token,FLOPs 约 , 是参数量;字节约 的权重加上 KV。batch 为 1、100B 参数、8k 上下文时,每字节运算量约 1.0,比拐点低两个数量级以上。
这意味着 GPU 的 989 TFLOP/s 只用上 3.3 TFLOP/s,其余时间在等 HBM。这不是 kernel 写得不好,是矩阵乘的形状决定的:decode 是矩阵乘向量,每读一个权重只做两次乘加,每字节运算量天然接近 1。
prefill 在拐点右边。整段 prompt 一起进来,权重被所有 token 复用,每字节运算量近似 。8k 上下文就是 16384,远高于 295。prefill 是矩阵乘矩阵,时间由算力决定。
这解释了首 token 延迟与后续 token 间隔为什么是两种问题。TTFT 主要由排队、prompt 长度和算力决定,ITL 主要由带宽和 KV 决定。同一块 GPU 上,两种工作的瓶颈根本不在同一个资源上。
batch 会把 decode 往右推。FLOPs 乘 ,权重字节不乘 ,所以 随 上升。但 KV 字节也随 线性增长。设每个参数的权重字节为 ,上下文长度为 ,每 token 的 KV 字节为 ,每字节运算量变成:
趋向无穷时,第一项消失, 的上限是 。100B 参数、8k 上下文、每 token 128 KiB 的 KV,这个上限是 186——无论 batch 多大,都进不了算力区。1k 上下文时上限是 1490,理论上 batch 到三百多就能越过拐点。
这是第一个反直觉结论:不是 batch 一大就变成算力题。KV 是分母里跟着 batch 一起长的那一项,它决定了 batch 的上限。上下文越长,这个上限越低。
量化会同时改变算力上限和字节数。FP8 把权重字节减半,峰值算力翻倍,算力上限抬高,拐点右移到约 591。但如果 KV 还是 FP16,分母里的 KV 项不变,decode 的每字节运算量只是温和上升,点仍然留在带宽区。量化的收益主要在权重侧;KV 侧要单独量化,才能同时动容量和带宽。
§2 · Roofline
Roofline:这个 token 到底在等算力还是等带宽
横轴是每字节运算量,纵轴是可达算力。曲线由两段组成,交点叫拐点;decode 与 prefill 分别落在它的两侧。
B 同时放大 FLOPs 与 KV 字节
KV 项随上下文线性增长
带宽越宽,斜段越陡,拐点左移
同时改变权重字节与算力上限
decode 的每字节运算量是 0.99,拐点在 295。batch 从 1 加到 256 会把每字节运算量抬起来,但只要 KV 项跟着 B 增长,点就始终贴着带宽区。换到 FP8,权重字节减半、算力上限抬高、拐点右移,但 KV 项不动;每字节运算量只是温和变化,点仍然留在带宽区。
另一个阶段用空心点标出:decode 模式下它是同一上下文的 prefill 点,prefill 模式下它是 batch=1 的 decode 点。两点之间的水平距离,就是「同一块 GPU 上两种完全不同的工作」。
把 batch 从 1 拖到 256,看当前点怎么从左下角往右上爬,但始终没有越过拐点。把上下文从 1k 拖到 8k,点又往回缩。prefill 模式下,点直接跳到图的右侧,贴着算力上限;上下文越长,越靠右。
注意那张字节占比条。decode 的 batch 小、上下文短时,权重占九成以上,瓶颈是「读不动权重」;batch 大、上下文长时,KV 那一半涨起来,瓶颈变成「权重加 KV 都读不动」。Roofline 的横轴只画了每字节运算量,但字节条告诉你这个比值为什么会掉。
Roofline 是上界,不是预测。它假设 kernel 能打满带宽或算力,实际还有小矩阵的效率损失、attention 的 、通信和调度开销。MoE 要用激活参数而不是总参数;prefill 的 也忽略了 attention 部分与 KV 写入。它最适合回答「瓶颈在哪一侧」,不适合精确预测 tokens/s。
三、KV Cache:长出来的第二组权重
decode 每产一个 token,都要读历史所有 token 的 K/V。如果不缓存,每步重算全部 K/V,代价是 ;缓存把每步的注意力读取降到 ,代价是显存。KV Cache 不是优化项,是 decode 能成立的前提。
每 token 的 KV 字节记作 ,有一个干净的公式:
其中 是层数, 是 KV 头数, 是 head_dim, 是每个元素的字节数;前面的 2 是 K 和 V 各一份。以 Llama-3-70B 为例:80 层、8 个 KV 头、head_dim 128、FP16,得到 320 KiB/token。8k 上下文一条请求 2.5 GiB;32 条并发就是 80 GiB,已经超过一张 80 GB H100 的全部显存;而权重本身还要 140 GB,单卡早已装不下。
权重是 140 GB,KV 已经长到和第二组权重同一个量级。更要命的是,decode 每一步两边都要读:权重读一遍,当前 batch 的 KV 也读一遍。容量和带宽,两笔账同时记在 KV 头上。
MHA 是另一个极端。64 个 KV 头,每 token 2.5 MiB,是 GQA 的 8 倍;同样 8k 上下文,一条请求 20 GiB,只算 KV 一张 80 GB 卡也只放得下 3 条,权重还没算。GQA 把 K/V 头数从 64 降到 8,斜率直接除以 8,模型质量只掉一点。这是过去几年最划算的一次结构改动。
MLA 更激进。它不缓存完整的 K/V,而是每层缓存一个低秩潜向量;DeepSeek-V3 量级约 68.6 KiB/token,128k 上下文约 8.6 GiB。代价是每步要做上投影,把潜向量还原成 K/V——用算力换显存和带宽。在 decode 这种带宽受限的阶段,这笔交易通常划算。
KV 的成本有两笔。容量决定能同时服务多少条、多长的上下文;带宽决定每个 decode step 要读多少字节。两者共享同一条 HBM 总线,也共享同一张账单。上下文越长,KV 那一笔越大,decode 的单请求 TPS 越往下掉。
分页解决的是分配问题,不是增长问题。静态预留按最大上下文给每条请求圈地,序列只用 1k 也要占 16k;分页按固定大小的块按需分配,用完一块再要一块,尾块内部还有不到一块的浪费,但不再有大片空地。分页注意力还让前缀共享和 copy-on-write 成为可能。
但 token 数翻倍,块数就翻倍;上下文从 4k 到 16k,KV 还是四倍。分页把「预留造成的浪费」变成「块尾的浪费」,把外部碎片变成内部碎片,不解决「每 token 都要占地方」。它让同样的显存装下更多请求,但没有改变线性增长的斜率。
§3 · KV Cache
KV Cache:显存里长出来的第二组权重
权重是固定成本,KV 是随上下文和并发线性增长的成本。拖长序列,再切到静态预留,看它怎样把 240 个块吃成一片空地。
固定 30,720 token 的教学沙盘,和上面的显存预算无关;只比较分配策略。
分页按需:每条 4k 请求占 32 块,最后一块装 32/128 token;8 条并发里 7 条放得下,其余排队,块尾浪费 2.3%。
把序列从 4k 拖到 16k:分页的块数线性翻四倍,静态预留则从一开始就按 16k 占满;再把并发拖大, 容量墙会比带宽墙先到,还是后到,取决于你选的结构。
默认的 GQA、4k 上下文、8 条并发,单请求 500 MiB,8 条接近 4 GiB,80 GB 预算看起来绰绰有余。把序列拖到 16k、并发拖到 32,KV 涨到六十多 GiB,预算的八成被 KV 吃掉。再把结构切到 MHA,同样设置直接超出预算。
下面这个 240 块池是固定 30,720 token 的独立沙盘,不是上面的 80 GB 预算;它只比较两种分配策略。把序列拖回 4k,再切到静态预留:一条请求仍按 16k 预留 128 块,真正用到的只有 32 块,剩下 96 块空占着。换回分页按需,同样 240 块,8 条 4k 请求只有 7 条放得下,第 8 条排队;序列缩到 1k,就能装 30 条。下面的读取条更直接:切回 GQA,并发 32、8k 上下文时,KV 读取约 31 GiB,不到权重 140 GiB 的四分之一;换成 MHA,同样的并发和上下文会变成约 125 GiB,几乎追平权重。decode 每一步要付两笔带宽。
失效边界也要说清。公式假设所有层同构、没有对齐和元数据开销;实际还有 block 表、碎片、临时激活,可容纳并发会比算出来的低。MLA 的潜向量不是免费的,上投影要算力;GQA 减少头数会损失一点模型质量。前缀缓存只对共享前缀有效,对各自独立的长上下文无效。
四、调度与并行:时间线怎么排,显存怎么分
前三个模型都在算「一个请求或一个 batch 要多少资源」。调度要回答的是:多条请求同时在场,时间和显存怎么分。
静态批次等所有请求到齐,统一 prefill,再一起 decode 到最慢的一条结束。短请求早就算完了,槽位还占着;新请求进不来。GPU 看起来忙,实际在陪跑。这就是气泡:时间线上有颜色,但没有产出。
连续批处理把批次变成动态。每个 iteration 重新组批,完成的请求立刻离开,新到的请求立刻准入。它把气泡填掉,代价是调度开销、KV 块管理,以及 prefill 与 decode 的干扰——一次长 prefill 占住整个 iteration,所有 decode 都要等。
§4 · 调度与并行
调度与并行:时间怎么排,显存怎么分
先看同一组请求在两种调度策略下的时间线,再切到并行地图:DP、EP、CP 切的东西不同,通信成本也不同。
tick 0:GPU 空闲。
静态批次把五条请求的 prefill 排成一列,decode 也必须等最慢的 r2 跑完。 前四个 tick 完全空闲,短请求 r3 自己的 prefill 只要一个 tick,却排在队尾等到 tick 7, 直到 tick 11 才和整批一起拿到第一个 token。
先看调度视图的静态时间线。五条请求最晚在 tick 4 到齐,前四个 tick GPU 完全空闲;prefill 排成一列,decode 要等最慢的 r2 跑完。makespan 19,平均延迟 13.6,平均 TTFT 10。
切到连续批处理,r3 完成后的下一个 tick 就把槽位让给 r5,makespan 降到 15,平均延迟 9.8,TTFT 5.6。省下来的四个 tick,来自「完成的请求不再占着批次」这一件事。
代价写在时间线中间。r4 的两次 prefill 占住 tick 4–5,已经 prefill 完的 r1–r3 只能等;r5 在 tick 4 就到了,却要等到 tick 8 才有槽位。真实系统用 chunked prefill 把长 prefill 切成小块混进 decode batch,或者用 PD 分离把两阶段放到不同的 GPU 池,用 KV 传输换干扰隔离。
并行视图看的是空间切分。DP 不切模型,复制权重,切请求;EP 切 FFN 专家,复制注意力和共享权重,通信是 token 路由的 all-to-all;CP 切序列和 KV,复制权重,通信是 ring attention 的 KV 交换。三个维度切的不是同一个东西,通信模式也完全不同。
DP 扩容最直接,但单卡装不下的模型它救不了:每条请求仍然要在一张卡上放下全部权重和 KV。EP 让单卡放得下更大的模型,但 token 要跨卡找专家,专家越分散,all-to-all 越重。CP 让单条长上下文分散到多卡,但注意力要跨卡交换 KV,长上下文能不能提速取决于互联带宽。
并行改变的是切分方式和通信成本,不消掉总计算量和总 KV。8 卡 DP 的聚合显存是 8 倍,但每条请求的 KV 还是那么大;EP 的总专家数没变,只是分布变了;CP 的总 KV 没变,只是切成了八段。每引入一个并行维度,就引入一条新的通信上限。
所以规模化的顺序通常是:先做 continuous batching,再做量化、GQA/MLA,最后才动并行。前两步不增加通信,收益直接;并行的收益取决于互联带宽和模型能不能切得动。反过来的顺序也能跑,只是你先付了最贵的那笔通信成本。
四个模型合起来
把四个模型叠在一起,一条请求的成本可以这样读。
prefill 是算力题,时间约 除以有效算力。decode 是带宽题,每步读 权重加 字节,单请求 TPS 由带宽除以每 token 字节决定。KV 决定能同时装多少条、多长;调度决定这些请求在时间上怎么排;并行决定它们在空间上怎么分。
| 模型 | 回答的问题 | 关键量 | 先失效的地方 |
|---|---|---|---|
| 吞吐与延迟 | 这条时间线能服务多少请求,用户等多久 | 并发、TTFT、TPOT、系统 TPS、p99 | 到达率接近服务率时,排队主导 |
| Roofline | 每个 token 的时间花在算力还是带宽 | 每字节运算量、拐点、峰值、带宽 | kernel 效率、attention 的平方项、通信 |
| KV Cache | 显存能装下多少上下文与并发 | 每 token 字节、容量、读取带宽 | 对齐、碎片、临时激活、结构假设 |
| 调度与并行 | 时间线怎么排、显存怎么分,通信多贵 | makespan、TTFT、all-to-all、ring | 真实重叠、拓扑、chunked prefill |
四个模型都指向同一件事:推理系统的瓶颈很少是「算不动」,更多是「搬不动」和「装不下」。GPU 的算力在 decode 阶段大量闲置,HBM 带宽和显存容量才是硬约束。
理解了这一点,很多看似矛盾的现象就有了同一个解释。batch 越大吞吐越高但延迟越差,因为并发是用排队换来的。上下文越长越慢,因为 KV 读取随上下文线性增长。卡越多单条请求不一定越快,因为并行的收益要先扣掉通信。吞吐、Roofline、KV、调度,说的其实是同一句话:先把数据搬到位,再谈算力。