《AI Agent 技术原理与架构·模型、推理与能力边界》4.2 KV Cache:显存、批处理与并发上限

上下文不是免费的:每个并发序列都要在显存里保留一份 KV Cache。本节用 KV 显存公式和 MHA/GQA 对比,说明层数、头数、序列长度与 batch 如何共同决定并发上限,以及为什么 PagedAttention、前缀缓存和 GQA 都是在同一笔显存账上做文章。

以下模型配置与数字均为教学假设,不构成对任何真实模型、供应商或生产系统的承诺。

上一节说 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
MQA1 组 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 架构有四个直接约束:

  1. 并发上限要按显存算,不是按 QPS 算。 先算单序列 KV 显存,再用可用显存除以它;QPS 是结果,不是输入。
  2. 上下文长度是容量杠杆。 缩短上下文、限制检索文档数、压缩历史,都能直接提高并发。
  3. 前缀要稳定。 系统提示、工具定义、固定文档放在前面且不随意改动;变化内容放后面。
  4. 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可用并发
40960.5 GiB16
81921 GiB8
327684 GiB2

这只是理想值。加上碎片和预留,实际并发通常还要打八折。容量规划应该用“可用并发 × 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 上下文长度、注意力复杂度与成本曲线 。

常见错误与边界

  1. 按 QPS 定并发。 并发上限由显存决定;先算单序列 KV 显存,再算容量。
  2. 把公式值当可用显存。 权重、激活、碎片和预留都会占用显存;需要留 20% 以上余量。
  3. 忽略上下文对并发的影响。 序列长度翻倍,单序列显存翻倍,并发减半;长上下文是容量问题。
  4. 前缀里放变化内容。 时间戳、随机 ID、用户特定信息放在系统提示开头,会让前缀缓存失效。
  5. 只看 GQA 省显存。 KV 头减少可能损失质量;选型要在目标任务上评测。
  6. 把 PagedAttention 当万能。 它减少碎片,不减少总字节数;容量规划仍要按公式算。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图