跳至主要內容

KV Cache：大模型推理的性能瓶颈与优化艺术

agicy2026/3/6大约 12 分钟技术LLMInferenceKV CacheOptimizationTransformer-Insider

KV Cache：大模型推理的性能瓶颈与优化艺术

在与 DeepSeek、Qwen 或 Doubao-Seed 等前沿大模型交互时，一个显著的现象是：生成的响应速度往往远低于输入的处理速度。这一现象背后的核心技术瓶颈，在于大模型推理过程中必不可少的 KV Cache 机制。

KV Cache 是一种经典的空间换时间（Space-Time Trade-off）策略，它极大地加速了自回归（Auto-Regressive）生成的解码过程。然而，随着模型规模和上下文长度的增长，它逐渐演变为显存占用和系统吞吐量的主要制约因素。

本文将深入解析 KV Cache 的工作原理、其带来的显存墙（Memory Wall）挑战，以及 PagedAttention、MQA/GQA 等前沿优化技术如何试图突破这一瓶颈。

核心概念

KV Cache 的本质是以显存空间换取计算时间。它避免了在每一步生成时重复计算历史 Token 的 Key 和 Value 向量，从而将自回归生成的复杂度从 O(t2)\mathcal{O}(t^2) 降低到 O(t)\mathcal{O}(t)。

自回归生成的计算冗余

在 Transformer 的解码阶段，生成过程是逐 token 进行的。

假设已生成序列 x1,x2,…,xt\mathbf{x}_1, \mathbf{x}_2, \dots, \mathbf{x}_t，当前目标是预测 xt+1\mathbf{x}_{t+1}。这一预测过程主要由 Self-Attention 层和 Feed-Forward Network (FFN) 层交替堆叠而成。

  • FFN 层：主要进行特征变换，其计算复杂度为 O(d2)\mathcal{O}(d^2)（dd 为隐藏层维度），与序列长度无关。
  • Attention 层：负责捕捉上下文依赖，其计算复杂度随着序列长度 tt 的增加而增长。

Attention 层的核心计算公式为：

Attention(qt,K≤t,V≤t)=Softmax(qtK≤t⊤d)V≤t\text{Attention}(\mathbf{q}_t, \mathbf{K}_{\le t}, \mathbf{V}_{\le t}) = \text{Softmax}\left(\frac{\mathbf{q}_t \mathbf{K}_{\le t}^\top}{\sqrt{d}}\right) \mathbf{V}_{\le t}

其中，K≤t\mathbf{K}_{\le t} 和 V≤t\mathbf{V}_{\le t} 表示截止当前时刻 tt 的所有历史 Key 和 Value 向量的集合：

K≤t=[k1,k2,…,kt],V≤t=[v1,v2,…,vt]\mathbf{K}_{\le t} = [\mathbf{k}_1, \mathbf{k}_2, \dots, \mathbf{k}_t], \quad \mathbf{V}_{\le t} = [\mathbf{v}_1, \mathbf{v}_2, \dots, \mathbf{v}_t]

计算冗余的根源：
让我们对比连续两个生成步骤中，Attention 层所需的 Key 向量集合：

  1. 生成 xt\mathbf{x}_t 时（当前时刻 t−1t-1）：
    需要计算前 t−1t-1 个 token 的 Key 向量：

    K≤t−1=[k1,k2,…,kt−1]\mathbf{K}_{\le t-1} = [{\color{red}\mathbf{k}_1, \mathbf{k}_2, \dots, \mathbf{k}_{t-1}}]

  2. 生成 xt+1\mathbf{x}_{t+1} 时（当前时刻 tt）：
    需要计算前 tt 个 token 的 Key 向量：

    K≤t=[k1,k2,…,kt−1,kt]\mathbf{K}_{\le t} = [{\color{red}\mathbf{k}_1, \mathbf{k}_2, \dots, \mathbf{k}_{t-1}}, \mathbf{k}_t]

其中，标红的序列 k1,…,kt−1\color{red}{\mathbf{k}_1, \dots, \mathbf{k}_{t-1}} 在上一步生成 xt\mathbf{x}_t 时已经计算过一次。

若不采用缓存机制，在生成 xt+1\mathbf{x}_{t+1} 时，这些向量需要通过投影矩阵 WK\mathbf{W}_K 重新计算。这意味着 k1\mathbf{k}_1 会被重复计算 tt 次，k2\mathbf{k}_2 会被重复计算 t−1t-1 次……这种 O(t2)\mathcal{O}(t^2) 的冗余计算构成了巨大的算力浪费。

位置编码的不变性

对于大多数位置编码方案，对于固定的历史输入 xi\mathbf{x}_i 及其位置 ii，其 Key 向量 ki\mathbf{k}_i 的变换都是确定的，不随当前生成时刻 tt 的变化而改变。这保证了 Cache 的有效性。

KV Cache 的工作原理

KV Cache 的核心思想非常直观：缓存历史计算结果，实现增量计算。

标准推理流程被划分为两个阶段：

  1. Prefill 阶段（首字生成）：
    并行计算 Prompt 中所有 token 的 K\mathbf{K} 和 V\mathbf{V}，并将它们存入显存中的 Cache 结构。此时计算是计算密集型（Compute Bound）的。
  2. Decode 阶段（逐字生成）：
    • 仅计算当前新生成 token xt\mathbf{x}_t 的 qt,kt,vt\mathbf{q}_t, \mathbf{k}_t, \mathbf{v}_t。
    • 从显存中读取历史缓存 K1:t−1,V1:t−1\mathbf{K}_{1:t-1}, \mathbf{V}_{1:t-1}。
    • 将 kt,vt\mathbf{k}_t, \mathbf{v}_t 拼接到缓存末尾，形成完整的 K1:t,V1:t\mathbf{K}_{1:t}, \mathbf{V}_{1:t}。
    • 执行 Attention 计算，生成 xt+1\mathbf{x}_{t+1}。

通过引入 KV Cache，Decode 阶段每步的计算复杂度从 O(t2)\mathcal{O}(t^2) 降低为 O(t)\mathcal{O}(t)，使得生成长序列成为可能。

KV Cache 机制演示

思考：为什么没有 Q-Cache？

既然我们缓存了 K\mathbf{K} 和 V\mathbf{V}，一个自然的疑问是：为什么不需要缓存 Q\mathbf{Q}？

这涉及到 Attention 机制中 Q\mathbf{Q} 和 K\mathbf{K} / V\mathbf{V} 的不同角色：

  • K\mathbf{K} 和 V\mathbf{V} 是被查询的对象：它们代表了历史信息。对于已经生成的 token（例如 x1,…,xt−1\mathbf{x}_1, \dots, \mathbf{x}_{t-1}），它们的语义和位置在后续的生成步骤中是固定不变的。因此，它们的投影向量 k\mathbf{k} 和 v\mathbf{v} 计算一次后就可以永久存储，供后续所有步骤复用。
  • Q\mathbf{Q} 是查询者：它代表了当前时刻 xt\mathbf{x}_t 的注意力焦点。
    • 在生成 xt+1\mathbf{x}_{t+1} 时，我们用 qt\mathbf{q}_t 去查询 K≤t\mathbf{K}_{\le t}。
    • 在生成 xt+2\mathbf{x}_{t+2} 时，我们用 qt+1\mathbf{q}_{t+1} 去查询 K≤t+1\mathbf{K}_{\le t+1}。

关键点在于：qt\mathbf{q}_t 只在生成 xt+1\mathbf{x}_{t+1} 的那一刻被用到一次。一旦 xt+1\mathbf{x}_{t+1} 生成完毕，qt\mathbf{q}_t 的使命就完成了，它不会参与后续 xt+2,xt+3\mathbf{x}_{t+2}, \mathbf{x}_{t+3} 的计算。后续步骤需要的是新的 qt+1,qt+2\mathbf{q}_{t+1}, \mathbf{q}_{t+2}。

因此，qt\mathbf{q}_t 向量具有瞬时性，用完即弃，不需要像 kt,vt\mathbf{k}_t, \mathbf{v}_t 那样进行持久化缓存。

为什么有些模型需要 Q-Cache？

在某些长上下文优化场景（如 Infinite-LLM 或 StreamingLLM 的部分实现）中，可能会缓存部分 Q\mathbf{Q} 以进行重计算或注意力修正。

但在标准的自回归推理流程中，Q\mathbf{Q} 确实是用完即弃的。

显存杀手：Memory Wall 挑战

虽然 KV Cache 解决了计算量（FLOPs）问题，但它却引发了严重的显存容量（Capacity）和显存带宽（Bandwidth）瓶颈。

计算强度分析

在 Decode 阶段，核心操作是矩阵-向量乘法（GEMV）。对于一个 Batch 的请求，GPU 需要从显存中搬运庞大的 KV Cache 矩阵，却仅与极小的 qt\mathbf{q}_t 向量进行运算。这导致计算强度（Arithmetic Intensity）极低，即每字节数据传输所对应的浮点运算次数很少。因此，大模型推理通常受限于显存带宽（Memory Bandwidth Bound），而非计算核心速度。

显存占用估算：
以 Qwen-72B 模型为例（n_layers=80, d_model=8192），在使用 FP16精度（2 bytes）和 2048 上下文长度时：
单次请求的 KV Cache 大小为：

2×layers×seq_len×d_model×2 bytes=5 GiB2 \times \text{layers} \times \text{seq\_len} \times \text{d\_model} \times 2 \text{ bytes} = 5 \text{ GiB}

若 Batch Size 增加到 32，仅 KV Cache 就需占用 160 GiB 显存，这已远超单张 A100 (80GiB) 的物理上限。显存容量直接限制了系统能够支持的最大并发数（Batch Size），进而限制了吞吐量。

精度说明

上述计算基于 FP16/BF16 (2 bytes)。如果采用 INT8 量化，显存占用减半；采用 INT4 量化，显存占用降至 1/4。这是目前缓解显存压力的重要手段之一。

优化之道：从 MQA 到 PagedAttention

为了缓解 KV Cache 带来的压力，学术界和工业界提出了一系列优化方案。

算法层面的优化：MQA 与 GQA

这两种方法通过改变模型结构，直接减少需要缓存的参数量。

  • MHA (Multi-Head Attention): 标准 Transformer 结构，每个 Head 拥有独立的 K,V\mathbf{K}, \mathbf{V} 投影。Cache 占用最大。
  • MQA (Multi-Query Attention): 所有 Head 共享同一组 K,V\mathbf{K}, \mathbf{V} 投影，仅 Q\mathbf{Q} 保持多头。Cache 大小骤降为原来的 1h\frac{1}{h}（hh 为 Head 数）。
    • 优势：显存占用极低，推理速度显著提升。
    • 代价：模型表达能力受损，可能导致生成质量下降。
  • GQA (Grouped-Query Attention): LLaMA-2/3 采用的折中方案。将 Head 分组，组内共享 K,V\mathbf{K}, \mathbf{V}。
    • 平衡点：在保持接近 MHA 效果的同时，获得接近 MQA 的速度和显存优势。

为什么 LLaMA-3 选择 GQA？

实验表明，GQA 在大规模模型上能够在几乎不损失精度的情况下，将显存带宽需求降低数倍，是目前性价比最高的 Attention 变体。

系统层面的优化：PagedAttention

伯克利团队（vLLM）提出的 PagedAttention 解决了显存碎片化问题。

灵感来源：操作系统虚拟内存
传统的 KV Cache 内存管理通常预分配连续的显存块（基于最大序列长度），这导致了严重的内部碎片（Internal Fragmentation）。
PagedAttention 借鉴了操作系统中分页（Paging）的思想：

  • 将 KV Cache 切分为固定大小的块（Block）。
  • 物理显存块可以是不连续的。
  • 维护一个页表（Block Table）来映射逻辑 token 序列与物理显存块。

核心优势：

  1. 零浪费：按需动态分配显存，消除了预分配带来的浪费。
  2. 高效共享：对于并发请求中的公共前缀（如 System Prompt），可以通过映射到相同的物理块实现写时复制（Copy-on-Write），极大降低了显存开销。
  3. 吞吐量提升：更高的显存利用率允许系统处理更大的 Batch Size，从而显著提升整体吞吐量。

架构层面的优化：PD 分离 (Prefill-Decode Disaggregation)

除了算法和内存管理的优化，PD 分离（Prefill-Decode Separation） 是一种架构层面的优化策略，旨在解决推理过程中 Prefill 和 Decode 阶段计算特性不一致的问题。

核心矛盾：计算特性的不对称

在标准推理流程中，两个阶段对硬件资源的需求截然不同：

  • Prefill 阶段（Throughput-Bound）：一次性处理 Prompt 中的大量 Token，是典型的计算密集型（Compute Bound）任务。它渴望强大的矩阵运算能力（TFLOPS），以便快速生成首个 Token（TTFT, Time To First Token）。
  • Decode 阶段（Latency-Bound）：逐个生成 Token，每次计算的数据搬运量大而计算量小，是典型的访存密集型（Memory Bound）任务。它受限于显存带宽（Bandwidth），决定了生成的流畅度（TPOT, Time Per Output Token）。

在传统的同构部署（Homogeneous Serving）中，Prefill 和 Decode 请求混合在同一个 GPU 上处理。这导致了严重的资源争抢：

  • Head-of-Line Blocking：当一个长 Prompt（例如 100k tokens）的 Prefill 请求到来时，它会瞬间占满计算单元。此时，其他正在进行的 Decode 请求被迫挂起，导致正在生成回复的用户感受到明显的卡顿。
  • 资源错配：为了满足 Decode 的显存需求，我们可能会选择大显存 GPU，但这对于 Prefill 阶段的算力需求来说可能并不划算，反之亦然。

解决方案：异构流水线

PD 分离将推理集群划分为两类专用的实例节点：

  1. Prefill 实例：专注于处理 Prompt 输入，快速计算并生成初始 KV Cache。这些节点可以配备高算力 GPU（如 H100）。
  2. Decode 实例：专注于接收 KV Cache 并执行后续的逐字生成。这些节点可以配备大显存 GPU（如 A100-80G 或甚至更廉价的推理卡）。

工作流程：

  1. 分发：全局调度器接收请求，将 Prompt 发送给 Prefill 实例。
  2. 计算与传输：Prefill 实例计算完 KV Cache 后，不进行后续生成，而是通过高速互联网络（如 NVLink、RDMA 或 PCIe）将 Cache 迁移（Migrate） 到 Decode 实例。
  3. 生成：Decode 实例接收 Cache，接力完成后续的 Token 生成，并将结果流式返回给用户。

挑战与优势

优势：

  • 消除干扰：Decode 请求不再受 Prefill 请求的阻塞影响，延迟（Inter-token Latency）更加稳定，P99 延迟显著降低。
  • 独立扩缩容：可以根据实际流量特征（Prompt 长度 vs 生成长度），独立调整 Prefill 和 Decode 节点的数量。
  • 极致吞吐：实现了流水线并行，让 GPU 始终运行在最擅长的负载下，显著提高了整个集群的吞吐量。

挑战：

  • 传输开销：KV Cache 的体积巨大（如前文计算，动辄数 GB）。如果在 Prefill 和 Decode 节点间传输 Cache 的时间超过了 Decode 单步生成的时间，就会得不偿失。因此，PD 分离通常依赖于高速网络基础设施（如 InfiniBand 或 NVLink Switch）。
  • 调度复杂性：需要复杂的全局调度算法来平衡负载，管理 KV Cache 的生命周期和传输。

网络带宽是新的瓶颈

在 PD 分离架构中，GPU 间的互联带宽（Inter-GPU Bandwidth）成为了新的性能瓶颈。如果网络不够快，Cache 传输反而会拖慢整体速度。

这一架构目前已成为 DeepSeek、Moonshot 等长文本大模型服务背后的主流技术方案。

总结

KV Cache 是大模型推理中双刃剑般的存在：它是实现实时生成的加速器，同时也是吞噬显存资源的巨兽。
从 MQA/GQA 的模型结构精简，到 PagedAttention 的显存管理革新，再到 PD 分离的架构演进，这一领域的变革折射出 AI 系统设计的一个重要趋势：算法、系统与架构的深度协同（Co-design）。

参考文献

此处应有页脚。
Copyright © 2026 agicy