KV Cache 概念与 DeepInfer 机制

KV Cache 概念与 DeepInfer 机制

面向:第一次接触 LLM 推理内部机制的工程师。
前置知识:知道 Transformer 有 attention 即可,不要求读过 vLLM 源码。
目标:读完后能说清 KV Cache 是什么、为什么占显存、block 是什么、前缀缓存为什么能复用、SWA(滑动窗口注意力)和 state(SWA 窗口、压缩累加器等非 KV 状态)为什么特殊。


目录


核心概念速览

  1. KV Cache 是模型生成 token 时留下的 K/V 中间结果,用来避免对历史 token 重复计算。
  2. 它按 block 管理。block 是分配、复用、传输的最小单位。
  3. 前缀能复用,是因为 causal attention 下,前缀的 K/V 只由前缀本身决定,与后面的 token 无关。

后续内容都围绕这三个判断展开。文中会反复出现 P、D、CE、Store、TE 和 HBM 这几个名字:P 是 Prefill 实例,D 是 Decode 实例,CE 是 D 的另一种叫法;Store 是跨实例共享的 KV 对象池,TE 是负责搬运 KV 和 state 的传输引擎,HBM 指 GPU 上的高带宽显存。先建立这个印象,后文用到时会再解释。


从 Attention 到 KV Cache

Attention 的计算过程

Transformer 的每一层都会把输入投影成三个张量:

  • Q(Query):当前 token 想“查询”什么。
  • K(Key):每个历史 token 的“索引”。
  • V(Value):每个历史 token 的“内容”。

注意力计算可以粗略写成:

1
Attention(Q, K, V) = softmax(Q × Kᵀ / sqrt(d)) × V

对第 t 个 token 来说,它用自己的 Q 去和所有历史 token 的 K 做点积,得到权重,再用权重加权所有历史 token 的 V。

因为模型是 causal 的,第 t 个 token 只能看到位置 <= t 的 token,看不到未来。这个限制决定了 KV Cache 的两个关键性质:

  • 历史 token 的 K/V 一旦算出来,后续 token 不会改变它们。
  • 同一段前缀,如果后面接的内容不同,前缀本身的 K/V 是一样的。

Causal Attention 的可见性约束

Causal attention(因果注意力)是自注意力的一种掩码(mask)方式:第 i 个 token 只能看位置 <= i 的 token,不能看后面的 token。

假设有 4 个 token:我 爱 吃 苹果。每个 token 作为 Query 时,能看到的内容是:

Query 我 爱 吃 苹果
我 可见 不可见 不可见 不可见
爱 可见 可见 不可见 不可见
吃 可见 可见 可见 不可见
苹果 可见 可见 可见 可见

这张表的可见区域呈下三角形状。实现时,把未来位置的 attention score 设成 -inf,softmax 后权重就是 0:

1
2
score[i][j] = Q_i · K_j / sqrt(d)   if j <= i
score[i][j] = -inf if j > i

之所以叫“causal”,是因为因果关系里现在不能影响过去,过去也不能被未来影响。放在语言模型里,第 i 个 token 的表示只能由它和它之前的 token 决定,不能依赖还没生成的 token。这种掩码方式带来三个直接结果。

  1. 训练和推理保持一致。训练时用掩码模拟“只能看左边”,推理时自然就是从左到右生成。
  2. 前缀的 K/V 保持稳定。同一段前缀,不管后面接什么问题,前缀里每个 token 的 K/V 都不变。这是前缀缓存和 KV Cache 复用的前提。
  3. Prefill 可以并行。虽然逻辑上是顺序的,但有了掩码,可以把整段 prompt 一次算完,不用真的一个 token 一个 token 算。

下面补充几个容易混淆的地方。

  • Causal attention 不是“每个 token 只能看自己”,而是“能看到自己和所有左边的 token”。
  • 它不是一种独立的 attention 层,而是自注意力(self-attention)上的一种掩码。
  • 它和 padding 掩码(padding mask)不是一回事:causal 掩码管“未来不可见”,padding 掩码管“补齐的无效 token 不可见”。实际实现里两者经常叠加。
  • 它不是“只在训练时用”。Prefill 阶段同样要使用 causal 掩码;Decode 阶段只有一个新 token,天然满足“不看未来”。

和它相对的是 bidirectional attention(双向注意力),例如 BERT 的 encoder,每个 token 可以看左右两边。双向注意力下,在开头加一段新内容会改变后面所有 token 的表示,所以不能直接做前缀缓存。另一类变体叫 sliding window causal attention(滑动窗口因果注意力,后文简称 SWA):仍然是 causal,但每个 token 只看最近 W 个 token,不看更远的历史。这就是后面 SWA 和 state 的来源。

因此,causal attention 可以概括为“只能看左边”的掩码;它让前缀的 K/V 不随后缀变化,KV Cache 才能复用。

这里的“稳定”有适用条件:讨论对象通常是 decoder-only 模型,前缀 token、位置编码、模型权重、量化方式和 attention 配置都必须一致。多模态输入还需要保证图像等额外信息一致,否则即使文本 token 相同,也不能直接复用。

Prefill 与 Decode 的差异

LLM 推理通常分为 Prefill 和 Decode 两个阶段,二者在输入形式、并行度和 KV Cache 使用方式上都有差异。

阶段 输入 并行度 计算内容 KV Cache 操作
Prefill prompt 的全部 token 高,一次算很多 token 所有 token 的 Q/K/V 和 attention 把每一层、每个 token 的 K/V 写入缓存
Decode 上一步新生成的 1 个 token 低,一次 1 个 token 当前 token 的 Q/K/V,和全部历史 K/V 做 attention 读历史 K/V,追加当前 token 的 K/V

Prefill 像“一次性读完一整段文章”,Decode 像“每写一个字都回看一遍笔记”。如果没有 KV Cache,Decode 每生成一个 token 都要把整段 prompt 重新算一遍,成本会随着上下文长度线性增长。

Prefill 的并行计算

很多人第一次看到 causal attention 会以为:既然 token i 只能看左边的 token,那是不是必须从左到右一个一个算?不是。causal attention 限制的是“每个位置能看到谁”,不是“必须按什么顺序执行”。

下面以一层 transformer 为例,说明这些步骤为什么可以并行。

  1. 输入 X 是整段 prompt 的 embedding,形状 [L, d],所有位置已知。
  2. 用大张量乘法分别算出所有位置的 Q、K、V:
1
2
3
Q = X × W_Q    [L, d]
K = X × W_K [L, d]
V = X × W_V [L, d]
  1. 一次大张量乘法算出所有 attention score:
1
S = Q × Kᵀ / sqrt(d)    [L, L]
  1. 把 S 的上三角(j > i)设成 -inf,做逐行 softmax:
1
S_masked[i][j] = -inf   if j > i
  1. 一次大张量乘法算出输出:
1
O = softmax(S_masked) × V    [L, d]

第 3 步到第 5 步都是大张量运算,GPU 可以并行完成;掩码只是加在 score 表上的一个逐元素操作,不引入顺序依赖。关键区别在于,transformer 的 causal attention 没有 RNN 那种递推关系。

  • RNN:h_t = f(h_{t-1}, x_t),h_t 依赖 h_{t-1},必须按时间顺序算。
  • Transformer:h_i^(l) 依赖的是上一层所有位置 j <= i 的 h_j^(l-1),不依赖同一层的 h_{i-1}^(l)。上一层的所有 h^(l-1) 已经算好了,所以同一层的所有位置可以一起算。

这里说的是同一层内的位置并行,层与层之间仍然有依赖,实际执行时按层顺序算,或者用流水线并行把不同 microbatch 的层重叠起来。“逻辑上顺序”指的是位置 i 的可见范围是 0..i,这是一个偏序关系;“计算上并行”指的是所有位置的输入都已知,大张量乘法可以一次完成。

Decode 不能这样并行,因为第 t+1 个 token 还没生成。你必须先采样出第 t 个 token,才能把它作为第 t+1 步的输入,这是真正的顺序依赖。Prefill 的情况不同:prompt 的每个 token 都是用户已经给定的,不需要等模型生成,所以可以一次算完。Prefill 一次算完所有位置,但只有最后一个位置用于采样首 token;所有位置的 K/V 都会写入缓存,供后续 Decode 使用。训练阶段也是同一个道理:整段 ground truth 已经给定,用 causal 掩码防止看到未来,所有位置并行算 loss。

还有一个容易忽略的情况:长 prompt 放不下时,Prefill 会被切成多个 chunk。chunk 之间仍然有顺序,后一个 chunk 要读前一个 chunk 的 KV;但每个 chunk 内部仍然可以并行。这种顺序来自分块和 KV 依赖,不是 causal attention 本身要求的。

只缓存 K/V 的原因

Q 是“当前 token 的提问”,只对当前这一步有用。第 t 个 token 算完 attention 后,它的 Q 不再被后面的 token 使用;K 和 V 不同,第 t 个 token 的 K/V 会被第 t+1、t+2、……、最后一个 token 反复使用。因此,Q 用完就可以丢弃,K/V 要留给未来。


KV Cache 的显存开销

下面用一个 Llama 风格的模型估算 KV Cache 的大小。

  • 32 层
  • 32 个 query head
  • 8 个 KV head(GQA,Grouped Query Attention)
  • 每个 head 128 维
  • FP16,每个元素 2 字节

每个 token、每一层的 K 和 V 大小:

1
2
3
K:8 × 128 × 2 字节 = 2048 字节
V:8 × 128 × 2 字节 = 2048 字节
合计:4096 字节 = 4 KiB

把每层的 4 KiB 乘以 32 层,就得到每 token 的缓存大小。

1
4 KiB × 32 = 128 KiB / token

按照上述示例估算,不同上下文长度对应的单请求 KV Cache 大小如下。

上下文长度 KV Cache 大小
1K token 128 MiB
8K token 1 GiB
32K token 4 GiB
128K token 16 GiB

如果同时跑 32 个 8K 请求,仅 KV Cache 就需要 32 GiB。这还没算模型权重、激活值和通信缓冲。实际部署里,KV Cache 往往比模型权重更早成为并发瓶颈。

实际数值会因模型结构和数据类型而变化,主要受以下因素影响。

  • GQA 越激进,KV head 越少,缓存越小。
  • FP8/FP4 量化会把每元素字节数降下来。
  • DeepSeek 的 MLA(Multi-head Latent Attention)把 K/V 压成 latent(隐向量),缓存的是压缩后的表示,不是完整的 K/V。
  • DeepSeek V4 一类模型还有 SWA、压缩累加器等 state,缓存对象不只是 K/V。

但无论怎么优化,缓存大小仍然随上下文长度增长,所以需要分块、复用和跨实例共享。


KV Cache 的显存布局

连续内存分配的问题

最朴素的做法是给每个请求分配一块连续显存,按需增长:

1
2
请求 A:[token 0 ... token 1023][空闲空间]
请求 B:[token 0 ... token 511][空闲空间]

这种做法的具体问题如下。

  • 请求长度不可预测,预留多了浪费,预留少了要扩容拷贝。
  • 请求结束后留下不同大小的空洞,显存碎片化。
  • 两个请求共享同一段前缀时,无法让它们指向同一份物理内存。

分页管理与 block table

PagedAttention(分页注意力)借用了操作系统的分页思想:把 KV Cache 切成固定大小的 block。

1
2
3
4
5
6
7
8
9
10
11
12
逻辑序列:
block 0 block 1 block 2 block 3
[0..127] [128..255] [256..383] [384..511]

block table(每个请求一份):
逻辑 block 0 -> 物理 block 7
逻辑 block 1 -> 物理 block 2
逻辑 block 2 -> 物理 block 9
逻辑 block 3 -> 物理 block 4

物理 block 池:
block 2, 4, 7, 9 已被占用,其余空闲

采用 block 管理后,可以获得以下好处。

  • 不需要连续分配,显存碎片少。
  • block 可以按需分配,不用提前猜请求长度。
  • 两个请求可以指向同一个物理 block,实现前缀共享。
  • 传输和写回可以按 block 进行,粒度固定。

DeepInfer 的 KV Cache 布局

DeepInfer 的 CacheEngine 里有两块主要的 GPU 缓冲区:

1
2
gpu_blocks: 每块包含所有参与 KV 的层的一段连续字节
gpu_states: [num_state_seqs, bytes_of_state_per_seqs]

普通 GQA 模型的 block 形状

对普通 GQA 模型,一个 block 的逻辑形状可以写成:

1
[num_layers, block_size, 2, num_kv_heads, head_dim]

这五个维度按“层 → token → K/V → head → head 维度”的顺序排列,分别表示:

维度 含义 说明
num_layers 参与 KV Cache 的层数 一个 block 包含所有参与 KV 的层的 K/V;带 attn_module_list 的模型可能不等于 num_hidden_layers
block_size 一个 block 容纳的 token 数 例如 128
2 K 和 V 两份张量 不是 batch size,也不是每个元素的 2 字节
num_kv_heads KV head 数 GQA 下通常小于 query head 数;MHA 时等于 query head 数,MQA 时为 1
head_dim 每个 head 的维度 例如 128

GQA 让多个 query head 共享一个 KV head;MHA(Multi-Head Attention)每个 query head 有独立的 KV head;MQA(Multi-Query Attention)所有 query head 共享一个 KV head。

这五个维度相乘,得到一个 block 里的标量元素个数:

1
元素数 = num_layers × block_size × 2 × num_kv_heads × head_dim

再乘以每个元素的字节数,并加上 padding 和对齐,就得到 block_bytes:

1
block_bytes ≈ 元素数 × element_size + padding

其中 element_size 是每个元素的字节数,FP16 为 2,FP8 为 1;padding 包括层内 32B pad、块尾 padding 和注册对齐。以前面的 Llama 风格模型为例:32 层、block_size=128、8 个 KV head、head_dim=128、FP16。一个 block 的元素数是:

1
32 × 128 × 2 × 8 × 128 = 8,388,608 个元素

按 FP16 每元素 2 字节计算:

1
8,388,608 × 2 B = 16 MiB

这和上一节的估算一致:每 token 128 KiB,128 个 token 正好是 16 MiB。GQA 的作用也可以直接从公式看出来:如果 KV head 从 8 增加到 32(MHA),块大小会变成 64 MiB;如果减少到 1(MQA),块大小会变成 2 MiB。在 KV 传输的示例配置里,block_bytes 可能是 2 MiB,这对应另一套模型规模、block_size 和量化配置,不要把 16 MiB 当成固定值。

这里要区分 query head 和 KV head。GQA 中多个 query head 共享一个 KV head,所以 num_kv_heads 通常小于 num_query_heads,缓存大小也按 num_kv_heads 计算,而不是按 query head 数计算。

上面的公式只适用于普通 GQA 模型。DeepSeek 这类带 MLA、SWA、压缩注意力的模型,块内布局由 GPUCacheInterface._kvcache_layout 决定,不能直接套用。对外真正使用的是两个值:

1
2
gpu_blocks: [num_gpu_blocks, block_bytes]
gpu_states: [num_state_seqs, state_bytes]

KV Cache 容量与布局字段

实际实现主要通过以下字段描述 KV Cache 的容量和布局。

字段 含义
block_size 一个 block 放多少个 token,例如 128
block_bytes 一个 block 的字节数,包含所有参与 KV 的层、padding、对齐
num_gpu_blocks 显存能放下多少个 block
bytes_of_state_per_seqs 每个 state slot 的字节数
num_state_seqs 同时能容纳多少个 state slot

一个 block 包含所有参与 KV Cache 的层的 K/V。这一点很重要:池化时一个对象就是一块 block_bytes,不需要按层拆成多个对象;P/D 传输时一个 block 也是一段连续字节。

block 的生命周期

一个 block 从分配到释放,大致经历以下状态。

1
free  ->  allocated  ->  written  ->  readable  ->  pinned  ->  freed
  • free:在空闲链表里,可以被分配。
  • allocated:已经分配给某个请求,但可能还没写完。
  • written:模型 forward 已经把 K/V 写进 HBM,但写入可能还在计算流上,尚未对其他线程可见。
  • readable:写完成事件或流同步之后,block 可以被后续消费者安全读取。这里的消费者有三类:本地 attention、池化 Put 线程、P/D 传输。
  • pinned:引用计数大于 0,暂时不能被复用。
  • freed:引用计数归零,回到空闲链表。

readable 是概念状态,代码里不一定有同名字段;实际靠写完成事件、pin 和 ref_count 保证读取安全。三类消费者的区别如下。

消费者 属于哪条路径 读什么 写到哪里
本地 attention 实例内计算 本地 HBM 中的历史 K/V 不写,只参与当前 token 的 attention
池化 Put 线程 池化 本地 HBM 中的完整 block Store 对象
P/D 传输 P/D 直传 P 的 HBM 中的 block/state D 的 HBM

BlockManager 用引用计数管理 block:

1
2
ref_count = 0  -> 在 free list 里
ref_count > 0 -> 正在被使用,不能分配给别的请求

一个 block 可能同时被多个“持有者”引用:

  • 请求本身持有引用,直到请求结束。
  • 异步 Put 任务持有引用,直到写 Store 完成。
  • P/D 传输持有引用,直到 CE 读完并发出通知。

所以释放 block 不是“请求结束就立刻 free”,而是“所有引用都释放后才 free”。这是后面理解 pin/unpin 的基础。


前缀缓存

前缀复用的原理

假设两个请求共享同一段系统提示。

1
2
请求 A:[系统提示 2000 token][用户问题 A]
请求 B:[系统提示 2000 token][用户问题 B]

系统提示的 K/V 只由系统提示本身决定,因此请求 A 和请求 B 在这 2000 个 token 上的 K/V 完全一样。B 可以直接复用 A 算好的结果,只需要计算用户问题部分,这就是前缀缓存(prefix caching)的核心。需要注意的是,它只能复用从第一个 token 开始的连续前缀;如果两个请求只有中间一段相同、开头不同,那一段不能直接复用,因为 K/V 依赖它前面的上下文。

链式 block hash

为了判断“这段前缀算过没有”,系统要给每个 block 生成一个内容 hash。

不能只 hash 当前 block 的 token,因为同样的 token 出现在不同上下文里,K/V 不一样。例如:

1
2
句子一:小明 喜欢 苹果
句子二:小红 喜欢 苹果

“喜欢 苹果”这段 token 相同,但前面的主语不同,K/V 不同。所以 hash 必须把前一块的 hash 也带进来:

1
2
3
4
h0 = hash(NONE_HASH, tokens[0:128], extras)
h1 = hash(h0, tokens[128:256], extras)
h2 = hash(h1, tokens[256:384], extras)
...
  • 第一块用约定的 NONE_HASH 作为前驱。
  • extras 放图片标识、LoRA(低秩适配)标识、cache salt(请求级缓存隔离盐)等额外信息。
  • 这样任何一个 block 的 hash 都唯一对应“从开头到这里的完整前缀”。

PoolKey 与完整缓存 key

只有内容 hash 还不够。不同模型、不同并行分片、不同缓存角色的对象不能混在一起。vllm-ascend 用 PoolKey 把这些信息拼成一个字符串:

1
<model>@dcp:<cp>@head_or_tp_rank:<tp>@pp_rank:<pp>@group:0@cache_role:kv@cache_family:default@<block_hash_hex>

PoolKey 中各字段的含义如下。

字段 含义
<model> 模型标识;共享 Store 时通常拼上 layout_version,形成 model_id@layout_version
dcp:<cp> CP(上下文并行)rank
head_or_tp_rank:<tp> TP(张量并行)rank
pp_rank:<pp> PP(流水线并行)rank
group:0 兼容 vllm-ascend 的固定占位
cache_role:kv 缓存角色,表示全局 KV block(可在实例间共享的 KV block)
cache_family:default 兼容 vllm-ascend 的固定占位
<block_hash_hex> 链式 block hash 的十六进制字符串

同一个逻辑 block,在不同 TP/CP/PP rank 上对应不同的物理分片,所以每个 rank 的 key 不同。查询时必须把所有必要分片都查到,少一个都不算命中。

命中长度 H 与恢复位置 S

前缀匹配的输出通常包含两个长度,含义如下。

1
2
H:全局 KV 可复用的 token 数
S:本地真正开始执行的位置

池化指把 KV 放进 Store,供多个实例共享。实现上可以先只缓存 KV block,不缓存 SWA 等 state;需要进一步提升命中率时,再引入 SWA 快照、copy_state(state 快照缓冲区)和多租户(block 与 SWA 使用独立租户和 TTL,即对象存活时间)。

只缓存 KV block 时,可以用下面的公式计算 max_hit、H 和 S。

1
2
3
max_hit = max(0, ((request_token_count - lookahead_tokens) // block_size) * block_size)
H = 连续命中的完整 block 数 × block_size
S = max(0, H - block_size)

max_hit 是本次查询的候选上限;lookahead_tokens 是池化预留的 token 数,用来避免命中到 prompt 末尾、导致本步没有 token 可算。

如果没有 SWA 快照,命中边界需要回退一个 block。这种设计在工程上常称为 Rollback / Recompute Last Block:把恢复位置从 H 回退到 H - block_size,重新计算最后一个命中 block。

这样做的原因是模型可能使用 SWA(滑动窗口注意力)。最后一个命中 block 的 SWA 窗口可能跨越 block 边界,如果直接从这个 block 之后续算,窗口可能不完整;回退一个 block 重算,可以把窗口补齐。它回退的是执行起点,不是丢弃缓存:前 H - block_size 个 token 仍然复用,只有最后一个命中 block 被重算。如果 SWA 快照也能命中,就可以做到 S = H,不再回退。

即使模型没有 SWA,部分实现也会保留这个安全边界,用来处理最后一个 block 未写完整、状态不一致或额外 token 的情况;是否回退取决于具体的缓存策略。

举个例子,block_size=128,命中了 4 个 block:

1
2
H = 4 × 128 = 512
S = 512 - 128 = 384
范围 处理方式
token 0..383(block 0..2) 直接复用 Store 中的 KV
token 384..511(block 3) Rollback 重算
token 512 以后 正常 Prefill 计算

代价是多算一个 block 的 token;收益是避免 SWA 窗口错位和 block 边界错误。

前缀命中的判定条件

算命中需要同时满足以下条件。

  • 同一个模型、同一份 KV 布局、同一个并行分片。
  • 从第一个 token 开始的连续完整 block。
  • 一个 block 的所有必要分片都存在。

以下情况都不能视为命中。

  • 只匹配到中间一段,开头不同。
  • 某个 block 少一个 rank 的分片。
  • 模型不同、量化不同、layout_version 不同。
  • block 没写完整,或者 Store 里只有半成品。
  • 请求太短,连一个 block 都不够。

查询时遇到第一个缺失或未确认的 block,就会截断整个前缀。后面即使还有命中的 block,也不能用,因为前缀断了。


SWA 与 state

滑动窗口注意力

标准 attention 让每个 token 看所有历史 token。SWA(Sliding Window Attention)只让每个 token 看最近 W 个 token。

这样 KV Cache 不需要保存全部历史,只需要保存最近 W 个 token 的 K/V。实现上通常用一个长度为 W 的 ring buffer(环形缓冲区):

1
2
3
物理 ring:  [slot 0][slot 1][slot 2] ... [slot W-1]
↑
写指针循环覆盖

当写到第 W 个 token 后,新 token 会覆盖最老的 slot。ring buffer 的物理顺序和逻辑顺序不再一致:

1
2
逻辑窗口:token 200, 201, ..., 327
物理位置:可能从 slot 72 开始,绕一圈回到 slot 71

所以判断 SWA 是否可复用,不能只看 ring buffer 的原始字节,还要知道:

  • 当前有效窗口从哪个 token 开始(swa_valid_start)。
  • 窗口在 ring 里的相位。
  • 哪些层有 SWA,哪些层没有。
  • 压缩累加器的状态。

state 的组成

DeepInfer 的 gpu_states 不只有 SWA ring,还可能包含:

  • 压缩注意力需要的累加器。
  • 某些层的滑动窗口状态。
  • 量化/反量化需要的中间状态。

这些 state 和 KV block 一样,是请求继续 Decode 所必需的。P/D 传输时如果只传 KV block、不传 state,D 的 Decode 结果就会错。

copy_state 的作用

copy_state 是一块额外的 GPU 缓冲区,用来在特定时刻给 state 拍快照。之所以需要快照,是因为 ring buffer 会被后续 token 覆盖:如果请求结束时才去读当前 state,可能已经错过了某个 block 边界对应的窗口。copy_state 在跨一个 block 的 token 边界(示例中是 128 个 token)时把 state 复制出来,请求结束时用这份快照写 Store。

DeepInfer 现有代码里已经有这套机制的雏形,相关入口如下。

  • LLMEngine.copy_state:快照缓冲区。
  • do_copy_state():把 gpu_states[state_id] 复制到 copy_state[state_id]。
  • should_copy_state():判断某个序列是否需要在当前 step 拍快照。
  • copy_state_event:保证拷贝完成后再消费。

这套机制还需要补齐分配、注册、跨 block 边界维护和请求结束落盘。

P/D 传输 state 的必要性

在 P/D(Prefill/Decode)分离部署中,P 是 Prefill 实例,D 是 Decode 实例,也叫 CE(Completion Engine)。P 做完 Prefill 后,D 要接着 Decode。D 需要的不只是 KV block,还包括:

  • SWA 窗口的当前位置。
  • 压缩累加器。
  • 其他影响后续 attention 的 state。

raw_slot 模式要求两端的 state 布局完全一致,整槽逐字节拷贝。这里的 raw_slot 指直接复制整个 state 槽位,不做字段重排或格式转换。只要有一项不一致(层集合、偏移、顺序、压缩率、环境变量),就必须拒绝传输,不能降级为“只传 KV block”。

KV block 决定 D 能看到什么,state 决定 D 怎么继续算。


量化、压缩与布局

KV Cache 的物理布局不是“几个浮点数拼在一起”这么简单。它会受这些因素影响:

  • 数据类型:FP16、BF16、FP8、FP4。
  • 量化粒度:per-tensor(按张量)、per-channel(按通道)、per-block(按块)。
  • 模型结构:GQA、MLA、SWA、压缩注意力。
  • 并行切分:TP/CP/PP 把 KV 切到不同 rank。
  • 对齐和 padding:层内 32B pad、块尾 padding、2 MiB 注册对齐。

这些因素综合起来,用一个 layout_version 描述。两个实例只有 layout_version 一致,才能做逐字节的 KV 传输。

这也是为什么“同一个模型”不等于“KV 可以互相复用”:

  • 一个用 FP16,一个用 FP8,字节数不同。
  • 一个 TP=8,一个 TP=4,分片方式不同。
  • 一个开了 SWA,一个没开,state 布局不同。
  • 一个开了压缩,一个没开,block 内容不同。

引用计数与资源释放

把前面几节串起来,一个 KV block 的生命周期可以用下面的状态图表示。

stateDiagram-v2
    [*] --> Free
    Free --> Allocated: 请求分配,ref_count = 1
    Allocated --> Written: forward 写入 K/V
    Written --> Readable: 写完成或流同步
    Readable --> Pinned: Put/传输 pin,ref_count += 1
    Pinned --> Readable: I/O 完成且请求未结束,ref_count -= 1
    Readable --> Free: 请求结束且 ref_count = 0
    Pinned --> Free: 请求结束且 I/O 完成,ref_count = 0
    Readable --> Readable: attention 读取历史 K/V

Free 是 block 在空闲链表中的状态,也是生命周期的起点和终点。block 释放后还会被下一次请求重新分配,所以不单独画一个终态。Pinned 表示存在额外引用,例如 Put 或 P/D 传输;此时即使请求结束,也不能立即复用。只有所有引用都释放、ref_count 归零,block 才回到 Free。分配失败、请求取消等异常路径也会释放引用回到 Free,图中省略了这些分支。

生命周期里有三个容易出错的地方。

  • 请求结束了,但 Put 还没完成:不能 free,因为 Put 线程还在读 HBM。
  • D 还在 Pull,P 就 free 了:D 可能读到已经被复用的 block,结果错误。
  • Notify 丢了,P 一直 pin:显存泄漏。需要超时、隔离和断链回收。

这就是工程上反复强调 pin/unpin、ref_count 和 QUARANTINED(通知超时后的隔离态)的原因。


常见误解

误解 实际情况
KV Cache 是模型权重的一部分 不是。模型权重是训练出来的参数;KV Cache 是推理时产生的中间结果,请求结束就失效。
前缀缓存命中就不用算任何东西 不是。命中只覆盖前缀,用户问题部分还要算。没有 SWA 快照时,还会回退一个 block 重算,补齐 SWA。
Store 里存的是指针 不是。Store 里存的是一块 block 的字节,一个对象对应一块 block_bytes 连续内存。
P/D 传输一定经过 Store 不是。P/D 直传是 D 通过 TE 直接读 P 的 HBM,不经过 Store。只有池化才会把 block 写进 Store。
P 返回首 token 后就可以释放 KV 不是。D 还没拉取,P 必须 pin 到收到 Notify 或超时。
block hash 只由当前 block 的 token 决定 不是。hash 是链式的,带前一块 hash 和 extras,否则相同 token 在不同上下文会误命中。
所有 rank 的 KV 都一样 不是。TP/CP/PP 会把 KV 切到不同 rank,每个 rank 的 key 和物理地址都不同。
block_size 越大越好 不是。block 大,元数据少、传输批量大;但内部碎片多,短请求浪费,前缀匹配粒度也变粗。

自测

问题 答案
为什么只缓存 K/V,不缓存 Q? Q 只对当前 token 有用,历史 token 的 Q 不再参与后续 attention;K/V 会被后续所有 token 反复使用。
为什么前缀缓存只能复用从开头开始的连续前缀? K/V 依赖它前面的全部上下文。中间一段相同、开头不同,K/V 就不一样。
为什么 block hash 要带前一块的 hash? 为了表达完整前缀。只 hash 当前块,会把不同上下文中的相同 token 误判为同一份 KV。
H 和 S 有什么区别? H 是全局可复用的 token 数,用于统计和计划;S 是本地真正开始执行的位置,装载时使用 S 对应的 block 数。只缓存 KV block 时,S = H - block_size。
为什么没有 SWA 快照时要回退一个 block? 为了补齐最后一个命中 block 的 SWA 窗口。回退一块重算,比直接续算安全。
为什么 P/D 不能只传 KV block? D 还需要 SWA 窗口位置、压缩累加器等 state,否则 Decode 结果会错。
为什么 Read 提交后不能立刻 unpin? Read 是异步的,提交只代表请求发出,不代表数据已经读完。必须等 Read 完成、流同步、Notify 发出后才能释放。
为什么不同 TP rank 的 key 不同? 每个 rank 只持有 KV 的一个分片,物理布局和内容都不同;key 必须带 rank 信息,否则会读到错误分片。

术语表

术语 一句话解释
KV Cache 历史 token 的 K/V 缓存,避免 Decode 重复计算
Prefill 一次算完 prompt 的所有 token,产出首 token 和 KV
Decode 每次生成一个 token,读历史 KV
block KV Cache 的固定大小分配单位,含多个 token、所有参与 KV 的层
block table 逻辑 block 到物理 block 的映射表
block hash 链式内容 hash,标识一段前缀
PoolKey 带模型、并行 rank、角色信息的完整缓存 key
prefix caching 复用相同前缀的 KV,跳过重复 Prefill
H / S 全局命中长度 / 本地恢复执行位置
Rollback / Recompute Last Block 命中边界回退一个 block,重新计算最后一个命中 block
SWA 滑动窗口注意力,只保留最近 W 个 token
state SWA ring、压缩累加器等非 KV 张量
copy_state state 的快照缓冲区
pin 增加引用,防止 block 被复用
ref_count 引用计数,归零才回 free list
layout_version KV 物理布局版本,传输双方必须一致

KV Cache 概念与 DeepInfer 机制
https://orion-wyc.github.io/2026/11/16/2026-11-16-KV-Cache概念与DeepInfer机制/
作者
Yuchen
发布于
2026年11月16日
许可协议