以下模型配置与数字均为教学假设,不构成对任何真实模型、供应商或生产系统的承诺。
上一节说 decode 阶段的主要瓶颈是内存带宽,因为每生成一个 token 都要读一遍 KV Cache。这一节算另一笔账:KV Cache 本身要占多少显存,它如何决定一个推理服务能同时服务多少用户。
结论先给:上下文长度和并发数不是独立变量。序列长度翻倍,每个序列的 KV Cache 翻倍,能同时容纳的 batch 就减半。很多“支持 128K 上下文”的模型在真实服务里并发很低,原因不是算力不够,而是显存被 KV Cache 吃掉了。
KV Cache 是什么
自回归生成时,第 $t$ 步的注意力需要前面所有 token 的键和值。如果每步都重新计算,复杂度会随生成长度快速增长。KV Cache 把已经算过的键和值存下来,decode 时直接读取,避免重复计算。
代价是显存。对每个序列、每一层、每个 KV 头、每个 token,需要存一份 K 和一份 V。公式为:
$$
\text{Bytes} = 2 \times L \times H_{kv} \times d \times S \times B \times \text{bytes_per_element}
$$
其中 $L$ 是层数,$H_{kv}$ 是 KV 头数,$d$ 是每个头的维度,$S$ 是序列长度,$B$ 是 batch 大小,系数 2 表示 K 和 V 各一份。
MHA、GQA 与 MQA
KV 头数 $H_{kv}$ 是公式里最容易被优化的变量:
| 方案 | KV 头数 | 显存 | 说明 |
|---|---|---|---|
| MHA | 等于 query 头数 | 最大 | 每个 query 头有自己的 K/V |
| GQA | 少于 query 头数,多个 query 头共享一组 K/V | 中等 | 常见折中,Ainslie et al. 2023 |
| MQA | 1 组 K/V | 最小 | Shazeer 2019,显存最省但可能损失质量 |
GQA 的思想是:query 头仍然各自计算,但多个 query 头共享同一组 K/V。这样既保留了多头查询的表达力,又把 KV Cache 按共享比例缩小。实验里的配置是 32 个 query 头、8 个 KV 头,比例 4:1,KV Cache 正好是 MHA 的四分之一。
最小实验:显存与并发上限
下面的实验用 32 层、32 个 query 头、head_dim 128、fp16 的教学配置,计算 MHA 和 GQA 在不同序列长度下的单序列显存,以及 24 GiB 预算下能容纳的 batch。
# file: agp_lab/kv_cache.py | write
# tier: 2
# verify: python3 -m unittest tests.test_kv_cache
"""KV Cache 的显存公式、批处理与并发上限。"""
from __future__ import annotations
GIB = 1024 ** 3
def kv_bytes(
layers: int,
heads: int,
head_dim: int,
seq_len: int,
batch: int = 1,
bytes_per_element: int = 2,
kv_heads: int | None = None,
) -> int:
"""K 和 V 各一份;kv_heads 小于 heads 时表示 GQA/MQA。"""
if min(layers, heads, head_dim, seq_len, batch, bytes_per_element) <= 0:
raise ValueError("参数必须为正")
shared = heads if kv_heads is None else kv_heads
if not 0 < shared <= heads:
raise ValueError("kv_heads 必须在 (0, heads] 内")
return 2 * layers * shared * head_dim * seq_len * batch * bytes_per_element
def max_batch(
budget_bytes: int,
layers: int,
heads: int,
head_dim: int,
seq_len: int,
bytes_per_element: int = 2,
kv_heads: int | None = None,
) -> int:
per_sequence = kv_bytes(
layers, heads, head_dim, seq_len,
bytes_per_element=bytes_per_element, kv_heads=kv_heads,
)
return budget_bytes // per_sequence
if __name__ == "__main__":
budget = 24 * GIB
print("mode seq per_seq_GiB max_batch")
for mode, kv_heads in (("MHA", 32), ("GQA", 8)):
for seq_len in (4096, 8192, 32768):
size = kv_bytes(32, 32, 128, seq_len, kv_heads=kv_heads)
batch = max_batch(budget, 32, 32, 128, seq_len, kv_heads=kv_heads)
print(f"{mode:<5} {seq_len:<7} {size / GIB:>11.2f} {batch:>9}")
运行:
cd private/labs/agp-lab
python3 -m agp_lab.kv_cache
输出:
mode seq per_seq_GiB max_batch
MHA 4096 2.00 12
MHA 8192 4.00 6
MHA 32768 16.00 1
GQA 4096 0.50 48
GQA 8192 1.00 24
GQA 32768 4.00 6
三组对比很清楚:
- 同样是 MHA,序列从 4K 增到 32K,单序列显存从 2 GiB 增到 16 GiB,batch 从 12 降到 1。
- 同样 8K 序列,GQA 把单序列显存从 4 GiB 降到 1 GiB,batch 从 6 提到 24。
- 32K 序列的 GQA 仍然能放 6 个并发,而 MHA 只能放 1 个。
这些数字只算 KV Cache,不包括模型权重、激活、临时缓冲和碎片。真实服务的可用显存更少,实际并发会更低。实验想说明的是比例关系:序列长度翻倍,并发减半;KV 头数减半,显存减半。这两条关系比具体数字更稳定。
PagedAttention 与前缀缓存
公式假设显存是连续分配的,现实里不是。不同请求的序列长度不同,如果每个请求都预分配最大长度,会造成大量碎片和浪费。PagedAttention(Kwon et al. 2023)把 KV Cache 切成固定大小的块,按需分配,用页表把逻辑位置映射到物理块;它不改变公式里的总字节数,但显著减少碎片和预留浪费。
前缀缓存是另一条路:多个请求共享相同前缀(系统提示、工具定义、固定文档)时,可以复用同一份 KV。它减少的是重复计算和重复存储,不是单个序列的公式值。对 Agent 来说,前缀缓存很有价值,因为系统提示和工具 schema 通常很长且稳定;但它的前提是前缀逐 token 一致,任何前面的变化都会让缓存失效。
边界
四个常见误解:
| 误解 | 实际 | 架构后果 |
|---|---|---|
| 公式算出的就是可用并发 | 公式不含权重、激活、碎片和预留 | 实际并发更低,需要留余量 |
| 上下文越长只是慢一点 | 显存线性增长,并发线性下降 | 长上下文是容量问题,不只是延迟问题 |
| GQA 没有代价 | KV 头减少可能损失质量 | 需要在自己的任务上评测 |
| 前缀缓存总是有效 | 前缀必须逐 token 一致 | 时间戳、随机 ID 会让缓存失效 |
第一条对容量规划最重要。实验里的 24 GiB 是“全部给 KV Cache”的理想值;真实服务要先扣掉模型权重(可能几十 GiB)、激活和临时缓冲,剩下的才能给 KV。把实验数字直接当并发上限,会严重高估容量。
架构含义
KV Cache 对 Agent 架构有四个直接约束:
- 并发上限要按显存算,不是按 QPS 算。 先算单序列 KV 显存,再用可用显存除以它;QPS 是结果,不是输入。
- 上下文长度是容量杠杆。 缩短上下文、限制检索文档数、压缩历史,都能直接提高并发。
- 前缀要稳定。 系统提示、工具定义、固定文档放在前面且不随意改动;变化内容放后面。
- GQA/MQA 要评测质量。 省显存是收益,质量损失是成本;选型要在自己的任务上对比。
第 1 条经常被倒过来做:团队先定 QPS 目标,再发现显存不够。正确的顺序是先算“每个并发序列要多少显存”,再算“预算能支持多少并发”,最后看这个并发能否满足 QPS。
架构判据
| 判据 | 合格的样子 | 不合格的样子 |
|---|---|---|
| 容量有公式 | 单序列 KV 显存与并发上限可计算 | 凭经验拍并发数 |
| 余量有预留 | 权重、激活、碎片后仍有 20% 余量 | 按理论值跑满 |
| 长度有策略 | 上下文上限、压缩、淘汰规则明确 | 无限拼接历史 |
| 前缀有约束 | 稳定前缀,变化内容后置 | 系统提示含时间戳/随机 ID |
| 方案有评测 | GQA/MQA 在目标任务上对比 | 只看显存数字 |
这些判据里,“余量有预留”最容易被跳过。KV Cache 是动态分配的,碎片和峰值会让实际占用高于公式值;没有余量,服务会在高并发时突然 OOM,而不是平滑降级。
一个容量规划的算例
假设 24 GiB 显存预算,模型权重占 14 GiB,激活与临时缓冲占 2 GiB,剩 8 GiB 给 KV Cache。用实验里的 GQA 配置:
| 序列长度 | 单序列 KV | 可用并发 |
|---|---|---|
| 4096 | 0.5 GiB | 16 |
| 8192 | 1 GiB | 8 |
| 32768 | 4 GiB | 2 |
这只是理想值。加上碎片和预留,实际并发通常还要打八折。容量规划应该用“可用并发 × 0.8”作为设计值,并把超出部分交给排队或降级。
PagedAttention 的碎片账
连续分配 KV Cache 时,每个请求要预留最大长度,短请求会浪费大量空间。PagedAttention 把缓存切成固定大小的块,按需分配,用页表映射逻辑位置。它带来两个好处:
- 减少内部碎片:短请求不必占满最大长度;
- 支持共享:相同前缀可以指向同一组物理块。
它不减少公式里的总字节数,也不消除外部碎片;容量规划仍然要按峰值算。
前缀缓存的命中条件
前缀缓存不是“相同系统提示就命中”。常见条件包括:
| 条件 | 说明 |
|---|---|
| 逐 token 一致 | 前缀任何一个 token 变化都会失效 |
| 位置一致 | 相同内容在不同位置不能直接复用 |
| 模型版本一致 | 权重或分词器变化后缓存失效 |
| 会话隔离 | 不同租户的缓存不能混用 |
最后一条是安全边界:前缀缓存必须按租户隔离,否则可能把 A 用户的上下文泄露给 B 用户。
GQA 的质量代价
GQA 用更少的 KV 头换显存,但多个 query 头共享同一组 K/V,可能损失一些表达力。质量影响取决于任务:
- 短上下文、事实问答:影响通常较小;
- 长上下文、多跳推理:共享 KV 可能让不同头难以区分细粒度信息;
- 代码与结构化输出:影响取决于模型训练方式,不能一概而论。
选型时不能只看“省了多少显存”,还要在目标任务上对比 GQA 与 MHA 的成功率、引用准确率和长上下文召回。
KV Cache 的生命周期
KV Cache 从 prefill 写入开始,到请求结束释放。生命周期里有三个关键决策:
| 决策 | 选项 | 影响 |
|---|---|---|
| 何时复用 | 不复用 / 前缀复用 / 跨请求复用 | 命中率与隔离风险 |
| 何时淘汰 | 请求结束 / LRU / TTL | 显存占用与冷启动 |
| 如何隔离 | 按会话 / 按租户 / 按模型 | 安全与共享效率 |
复用越激进,命中率越高,隔离和一致性风险也越大。Agent 场景里,系统提示和工具定义适合复用,用户上下文和工具结果不适合跨会话复用。
小结
- KV Cache 用显存换计算:decode 时不再重算历史键值,但每个并发序列都要保留一份。
- 显存公式是
2 × 层数 × KV 头数 × head_dim × 序列长度 × batch × 字节数;序列长度和 batch 都是线性因子。 - GQA/MQA 通过减少 KV 头数降低显存;GQA 是保留多头查询、共享 KV 的折中。
- PagedAttention 减少碎片和预留浪费,前缀缓存复用相同前缀;两者都不改变单序列公式值。
- 公式不含权重、激活和碎片,实际并发更低;容量规划要留余量。
- 上下文长度是容量杠杆,不只是延迟杠杆;长上下文会直接压低并发上限。
阅读导航:上一节:4.1 Prefill/Decode:TTFT 与 TPOT 的来源 · 下一节:4.3 上下文长度、注意力复杂度与成本曲线 。
常见错误与边界
- 按 QPS 定并发。 并发上限由显存决定;先算单序列 KV 显存,再算容量。
- 把公式值当可用显存。 权重、激活、碎片和预留都会占用显存;需要留 20% 以上余量。
- 忽略上下文对并发的影响。 序列长度翻倍,单序列显存翻倍,并发减半;长上下文是容量问题。
- 前缀里放变化内容。 时间戳、随机 ID、用户特定信息放在系统提示开头,会让前缀缓存失效。
- 只看 GQA 省显存。 KV 头减少可能损失质量;选型要在目标任务上评测。
- 把 PagedAttention 当万能。 它减少碎片,不减少总字节数;容量规划仍要按公式算。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。