上线第一天,测试同学掐表:问一句二十来字的问题,第一段回答等了三秒才出来;文字开始蹦以后,后面却很快,一行一行往上刷。老板问,既然后面那么快,开头为什么慢?同一天晚上做压测,八路并发刚跑满,服务就 OOM 重启,也就是显存被耗尽,日志里每一路的上下文只有四千 token 左右。

这两个现象看着无关,其实是同一本账的两面。首 token 慢,慢在它要把整段提示一次性算完,这段计算不能像输出那样一个词一个词地摊开;并发一上来就 OOM,爆的不是模型权重,而是每个请求各自持有的缓存和临时缓冲。前者是计算模式问题,后者是显存账问题。

这篇把推理拆成两段:prefill 和 decode。先讲它们各自在算什么、为什么快慢不同;再讲 KV cache 到底存了什么、为什么它随长度线性长;然后用一段程序把一千、四千、一万六长度和八路并发的缓存算出来;最后把首 token 延迟和整机显存各拆成几块,告诉你 OOM 时先看哪里。GPU 上的真实延迟和吞吐未在本机实测,文中只给公式和粗估。

首 token 慢,后面的 token 快

生成不是一次性把整段话吐出来。模型每跑一次前向,只产出一个 token;把这个 token 接到输入后面,再跑一次,再产出一个。你在屏幕上看到的一行行文字,是几十上百次前向拼出来的。所以「快慢」要分两个指标看:第一个 token 要多久,也就是首 token延迟;之后每个 token 间隔多久,也就是输出速度。

第一个 token 之前,模型必须先把你的整段提示读进去。二十个字的提问,加上系统提示、历史消息,可能是一两千个 token。这些 token 要一起过所有层,算出注意力,再算出第一个输出。这段计算量大,但可以并行,GPU 的算力能用上。

之后的每个 token,模型只需要处理新加的那一个,但它仍然要把所有层的权重读一遍,还要读之前所有 token 的缓存。单步的计算量小,可显存带宽成了瓶颈,GPU 的计算单元大量空转。于是出现一个反直觉的结果:首 token 那一段看起来「卡」,其实 GPU 很忙;后面的 token 看起来「流畅」,其实每一步都在等内存。

长提示的首 token 特别慢,是因为 prefill 的计算量跟着涨,并行度再高,绝对时间也会拉长。输出速度主要取决于模型大小、显存带宽和批大小,但缓存变长后每步读得更多,长上下文下同样会慢。

两个阶段:prefill 与 decode

把一次请求切成两段,就清楚了。

一次生成请求的两个阶段
请求进入队列
prefill:整段提示并行过网络
产出第一个 token
decode:每次只处理一个新 token
逐 token 输出直到结束

prefill 阶段,输入是 n 个 token,注意力矩阵是 n 乘 n,矩阵乘法规模大,属于计算密集型。GPU 的算力单元被喂饱,利用率高。这个阶段的耗时大致随 token 数增长,注意力的部分还带平方项,所以超长提示的 prefill 会明显变贵。

decode 阶段,输入只有一个新 token,但要和历史所有 token 做注意力。矩阵乘向量,算术强度低,属于显存带宽密集型。所谓算术强度,就是每读一个字节能完成多少次运算;decode 每读大量权重只做很少的乘加,带宽跟不上,算力就闲着。

两个阶段对硬件的要求不一样。prefill 喜欢算力强、矩阵乘法快的卡;decode 喜欢带宽高、缓存大的卡。同一张卡,prefill 时利用率能到很高,decode 时可能只有一小部分。很多推理优化的核心,就是把这两种负载安排好,别让它们互相堵。

真实服务里,请求是连续到达的,不会等你做完一个再做下一个。于是调度器会把不同阶段的请求拼在一起:新请求做 prefill,老请求做 decode,凑成一个批次。这就是连续批处理的基本思路,后面会展开。

KV cache 存的是什么

要理解缓存,先回忆注意力。每一层里,每个 token 都会算出三个向量:查询、键、值,简称 Q、K、V。查询用来和别的 token 的键做匹配,算出权重,再把别的 token 的值加权求和。

如果不缓存,每生成一个新 token,都要把前面所有 token 的键和值重新算一遍。第 t 步算 t 个,总共就是平方级的重复计算,整体接近立方级。缓存的做法很直接:每层、每个头,把已经算过的键和值存下来,下一步直接拿来用,只算新 token 自己的那一份。

所以 KV cache 存的不是输出文本,也不是模型参数,而是每一层、每个注意力头、每个历史 token 的键向量和值向量。它按层数、头数、头维度、序列长度、批大小相乘,精度通常是半精度。它不占磁盘,占显存,而且每个请求一份,互不共享。

多头注意力里,键和值的头数可以和查询的头数不同。让多个查询头共享一组键值头,叫分组查询注意力,英文缩写 GQA。共享之后,缓存的头数变少,显存直接按比例下降;极端情况是所有查询头共享一组,叫多查询注意力。这是现在很多模型省显存的主要手段之一,选模型时值得看一眼。

缓存越大,decode 每步要读的数据越多,长上下文下输出变慢,很大一部分是搬缓存搬的。缓存可以量化、分页或放到主机内存,但每一种都拿精度或延迟换空间,没有免费选项。

算一算:KV cache 到底多大

下面这段程序按一个常见的结构假设算缓存大小:32 层、32 个注意力头、每个头 128 维、半精度两字节。序列长度取一千、四千、一万六三档,并发取单条和八条。它只做乘法和单位换算,不连接任何推理框架。

# -*- coding: utf-8 -*-
# KV cache 显存粗估:按 LLaMA 式 7B 结构假设,未在本机 GPU 实测

layers = 32
heads = 32
head_dim = 128
bytes_per_elem = 2  # fp16 / bf16

per_token = 2 * layers * heads * head_dim * bytes_per_elem
print("结构假设: layers=%d heads=%d head_dim=%d 精度=%d 字节" % (layers, heads, head_dim, bytes_per_elem))
print("每 token 的 K 和 V: %d 字节 (%.1f KiB)" % (per_token, per_token / 1024))
print()

def cache(seq, batch=1):
    return per_token * seq * batch

def gb(n):
    return n / 1024 ** 3

def mb(n):
    return n / 1024 ** 2

print("单条序列:")
for seq in (1024, 4096, 16384):
    n = cache(seq)
    print("  %5d token: %8.1f MiB (%.2f GiB)" % (seq, mb(n), gb(n)))

print()
print("并发 8 条:")
for seq in (1024, 4096, 16384):
    n = cache(seq, 8)
    print("  %5d token x 8: %8.1f MiB (%.2f GiB)" % (seq, mb(n), gb(n)))

print()
weights_7b = 7e9 * bytes_per_elem
print("7B 权重 bf16 约 %.2f GiB" % gb(weights_7b))
print("16K x 8 并发时 KV 占 %.2f GiB,约为权重的 %.1f 倍" % (gb(cache(16384, 8)), gb(cache(16384, 8)) / gb(weights_7b)))
print()
print("32 并发、4K 上下文时 KV 占 %.2f GiB" % gb(cache(4096, 32)))
python kv_budget.py
结构假设: layers=32 heads=32 head_dim=128 精度=2 字节
每 token 的 K 和 V: 524288 字节 (512.0 KiB)

单条序列:
   1024 token:    512.0 MiB (0.50 GiB)
   4096 token:   2048.0 MiB (2.00 GiB)
  16384 token:   8192.0 MiB (8.00 GiB)

并发 8 条:
   1024 token x 8:   4096.0 MiB (4.00 GiB)
   4096 token x 8:  16384.0 MiB (16.00 GiB)
  16384 token x 8:  65536.0 MiB (64.00 GiB)

7B 权重 bf16 约 13.04 GiB
16K x 8 并发时 KV 占 64.00 GiB,约为权重的 4.9 倍

32 并发、4K 上下文时 KV 占 64.00 GiB

先说明口径:这是粗估,不是实测。公式是二乘层数、头数、头维度、序列长度、批大小,再乘精度字节数。前面的二代表键和值两份;头数乘头维度等于隐藏维度,这里三十二乘一百二十八等于四千零九十六。没有算缓存管理的碎片,也没有算临时缓冲和框架开销。

数字读完,结论很直白:每个 token 的缓存是五百一十二 KiB,听起来不大,乘上一万六就是八个 GiB,再乘八路并发就是六十四 GiB。一个七 B 模型半精度权重才十三 GiB 左右,缓存已经是权重的四点九倍。这就是为什么「权重明明放得下,一加并发就 OOM」。

还有一个容易忽略的点:缓存的峰值不是按平均长度算的,是按每个请求的最大长度预留的。如果按模型支持的最大上下文给每个请求留位置,实际平均只用一小半,剩下的都浪费。分页管理、按需分配、以及限制单请求最大长度,都是在解决这个浪费。

如果模型用 GQA,键值头数从三十二降到八,缓存直接变成四分之一。同样十六 K 八并发,从六十四 GiB 降到十六 GiB,差别足以决定一张卡能不能跑。这也是为什么选模型时,不能只看参数量,还要看注意力结构和最大上下文。

批处理:吞吐上去了,显存也上去了

decode 阶段每一步都要把权重读一遍。批大小为一时,读一遍权重只服务一个请求,带宽浪费得厉害。把八个请求凑成一批,同一次权重读取服务八个请求,吞吐自然上去。这就是批处理最直接的收益。

但批处理不是免费的。每个请求都有自己的 KV cache,批大小乘几,缓存就乘几;prefill 混进批次时,激活和临时缓冲也会上去。更麻烦的是长度不齐:静态批处理要补齐到最长的那条,短请求被补齐拉长,算力花在无用的位置上。补齐的部分不产生有用输出,却照样占显存和计算。

连续批处理解决了这个问题。它不按固定批次等所有请求,而是每生成一步,检查有没有新请求可以加入、有没有请求已经结束可以退出。批次是动态的,短请求结束就腾出位置,新请求立刻补上,不用等一整批跑完。吞吐和平均延迟都会改善。

分页注意力解决的是缓存碎片。每个请求的缓存按块分配,不要求连续的一大段显存,块可以分散在显存里。这样长请求不会因为找不到连续空间而失败,短请求也不会占着大块不放。它不减少缓存总字节数,但能显著减少「明明有空间却分配失败」的情况。

批大小也不是越大越好。批次越大,单步耗时越长,单请求的首 token延迟和 token 间隔都可能变差;显存压力也越大。吞吐和延迟是一对矛盾,要按业务定指标,不能只看每秒总 token 数。

首 token 延迟由什么组成

用户感知的首 token 延迟,不等于 prefill 的计算时间。它至少包含五块:请求在队列里等待的时间、分词和模板拼接的时间、prefill 的计算时间、第一个 token 的 decode 时间、以及网络往返和调度开销。哪一块占大头,优化方向完全不同。

如果平均延迟不高但长尾很高,通常是排队。并发超过服务能力,请求在队列里等,先到的先算,后到的等着。这时候加副本、限流、或者把长请求单独排队,比优化模型更有效。

如果所有请求都慢,而且提示越长越慢,问题在 prefill。可以缩短系统提示、裁剪历史、把公共前缀缓存起来。前缀缓存的意思是,把固定开头的键值缓存存下来,后续请求命中就直接复用,不用重算;代价是缓存要占显存,而且前缀必须完全一致,改一个字符就失效。

如果首 token不慢,但输出阶段每个 token 间隔长,问题在 decode 的带宽或批大小。可以量化权重、用更快的卡、调大批次、启用连续批处理。注意长上下文会拖慢 decode,因为每步要读更长的缓存。

跨地域访问时,网络往返可能有几百毫秒。把服务部署到离用户近的地方,比换 GPU 便宜得多;压测时容易忽略,因为压测机就在机房旁边。

整机显存账:权重、缓存、激活、碎片

OOM 的时候,日志往往只告诉你「分配失败」,不告诉你是哪一项超了。把显存拆成四块,逐块估,才能定位。

权重:参数量乘精度字节数。七 B 半精度约十三 GiB;量化到四比特,理论上是四分之一左右,但还有缩放因子和未量化层。
KV cache:上一节算过,随序列长度和并发线性增长,是并发场景下最容易爆的一项。
激活与临时缓冲:单条推理时不大,但 prefill 长提示、批处理、注意力分数矩阵会形成峰值;用分块注意力可以避免一次性展开整个分数矩阵。
框架与碎片:显卡运行时上下文、通信缓冲、内存池预留、分配器碎片。它们不写在模型配置里,但经常吃掉一到几个 GiB,长跑之后还会涨。

误判常是「权重放得下就能跑」。七 B 模型在二十四 GB 卡上,权重占十三 GB,看似还剩十一 GB,但按十六 K 上下文预留缓存,单条八 GB,两条就爆。能开多少并发,要用剩余显存除以单请求峰值缓存,再留出激活和碎片的余量。

另一种误判是「显存监控里还有很多空闲」。监控看到的「预留」和「实际分配」是两回事,分配器预留了但没用的块,既不能给别的进程,也不代表能分配出连续的大块。碎片严重时,总量够但分不出来,表现还是 OOM。分页管理能缓解,但不能凭空创造显存。

排查顺序建议固定:先算权重,再按最大上下文乘并发算缓存,再加上激活峰值和框架开销,最后看碎片。算出来就超了,先降并发或降最大长度;算出来没超却仍然 OOM,再查碎片、泄漏和多进程共用卡。

出了问题先看哪里

现象真实原因第一步查什么
首 token 要等好几秒,后面很快prefill 要一次算完整段提示,计算量集中记录首 token 延迟与提示长度,看是否随长度上升
所有请求都慢,GPU 利用率却不高decode 受显存带宽限制,算力用不满看每步耗时、带宽占用和批大小
并发一高就 OOMKV cache 随并发线性增长按公式算缓存总量,再对比卡的剩余显存
长上下文显存暴涨缓存按最大长度预留,注意力峰值也变大看最大上下文设置、是否用 GQA、是否分页
加了批处理,单请求反而变慢批次变大拉长单步时间,调度不公平分开看吞吐和 P99(最慢的那百分之一)延迟,调小批或做请求分级
延迟抖动很大,平均值正常排队、抢占或显存碎片看队列长度、P99、分配失败次数
短请求吞吐上不去静态批处理补齐浪费,批次利用率低换连续批处理,统计补齐比例
量化后显存降了但效果变差权重或缓存精度损失用同一套验收集对比量化前后的输出质量

边界与代价

推理优化没有单一最优解,只有针对目标的取舍。吞吐、首 token延迟、单 token间隔、成本,四个指标互相拉扯。把批大小拉满,吞吐好看,延迟变差;把上下文拉长,功能好看,显存和成本上去;把量化压到四比特,显存省了,质量可能掉。任何优化都要在同一套验收集上对比,不能只看一个数字。

长上下文也不是免费的午餐。缓存随长度线性增长,decode 每步读得更多,首 token 的 prefill 还带平方项。所谓「支持多少万上下文」,通常是在特定硬件、特定批大小、特定精度下测出来的上限,不等于你的业务能按这个长度跑满并发。容量规划要按自己的平均长度和峰值长度算。

多租户还要考虑隔离。一个超长请求可能占满缓存,把其他请求挤出去;调度器没有公平策略,短请求会被长请求拖死。生产环境通常要做请求分级、长度上限和租户配额。

最后提醒:文中的公式和数字都是粗估,真实 GPU 上的延迟、吞吐、显存占用未在本机实测。不同卡、框架、算子实现差别很大,拿这些公式做容量规划起点,再用压测校正。

当天能验证的练习

  1. 把脚本里的头数改成八,模拟分组查询注意力,重算十六 K 八并发的缓存,写出倍数关系。
  2. 把序列长度改成三万二,算单条和四路并发的缓存,再对比一张二十四 GB 卡上七 B 权重的剩余空间。
  3. 记录一次真实请求的首 token延迟和输出速度,把延迟拆成排队、prefill、网络三块,标出最大的一块。
  4. 用四条长度不同的请求模拟静态批处理,算补齐浪费的 token 比例,再说明连续批处理能省在哪。
  5. 列出一张卡的显存组成:权重、缓存、激活、框架开销,各写一个估算值,指出最该先优化的一项。

这五个练习里,前两个和第四个只用标准库就能算,后三个需要你手上有服务或日志。做完之后,再看 OOM 日志,你应该能直接说出大概是哪一块超了。

下一篇:量化

推理的显存账里,权重和缓存都是大头。把权重从十六位压到八位、四位,缓存也跟着压,能在同一张卡上塞下更大的模型或更多并发。但精度掉下去,模型哪些能力先坏、哪些还能撑住,是另一本账。下一篇讲量化:INT8 和 INT4 到底掉的是精度还是能力,怎么用一套验收集判断能不能接受。下一篇的标题是《量化:INT8/INT4 掉的是精度还是能力》。