KV Cache 概念与 DeepInfer 机制
KV Cache 概念与 DeepInfer 机制
面向:第一次接触 LLM 推理内部机制的工程师。
前置知识:知道 Transformer 有 attention 即可,不要求读过 vLLM 源码。
目标:读完后能说清 KV Cache 是什么、为什么占显存、block 是什么、前缀缓存为什么能复用、SWA(滑动窗口注意力)和 state(SWA 窗口、压缩累加器等非 KV 状态)为什么特殊。
目录
- 核心概念速览
- 从 Attention 到 KV Cache
- KV Cache 的显存开销
- KV Cache 的显存布局
- 前缀缓存
- SWA 与 state
- 量化、压缩与布局
- 引用计数与资源释放
- 常见误解
- 自测
- 术语表
核心概念速览
- KV Cache 是模型生成 token 时留下的 K/V 中间结果,用来避免对历史 token 重复计算。
- 它按 block 管理。block 是分配、复用、传输的最小单位。
- 前缀能复用,是因为 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 | |
对第 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 | |
之所以叫“causal”,是因为因果关系里现在不能影响过去,过去也不能被未来影响。放在语言模型里,第 i 个 token 的表示只能由它和它之前的 token 决定,不能依赖还没生成的 token。这种掩码方式带来三个直接结果。
- 训练和推理保持一致。训练时用掩码模拟“只能看左边”,推理时自然就是从左到右生成。
- 前缀的 K/V 保持稳定。同一段前缀,不管后面接什么问题,前缀里每个 token 的 K/V 都不变。这是前缀缓存和 KV Cache 复用的前提。
- 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 为例,说明这些步骤为什么可以并行。
- 输入
X是整段 prompt 的 embedding,形状[L, d],所有位置已知。 - 用大张量乘法分别算出所有位置的 Q、K、V:
1 | |
- 一次大张量乘法算出所有 attention score:
1 | |
- 把
S的上三角(j > i)设成-inf,做逐行 softmax:
1 | |
- 一次大张量乘法算出输出:
1 | |
第 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 | |
把每层的 4 KiB 乘以 32 层,就得到每 token 的缓存大小。
1 | |
按照上述示例估算,不同上下文长度对应的单请求 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 | |
这种做法的具体问题如下。
- 请求长度不可预测,预留多了浪费,预留少了要扩容拷贝。
- 请求结束后留下不同大小的空洞,显存碎片化。
- 两个请求共享同一段前缀时,无法让它们指向同一份物理内存。
分页管理与 block table
PagedAttention(分页注意力)借用了操作系统的分页思想:把 KV Cache 切成固定大小的 block。
1 | |
采用 block 管理后,可以获得以下好处。
- 不需要连续分配,显存碎片少。
- block 可以按需分配,不用提前猜请求长度。
- 两个请求可以指向同一个物理 block,实现前缀共享。
- 传输和写回可以按 block 进行,粒度固定。
DeepInfer 的 KV Cache 布局
DeepInfer 的 CacheEngine 里有两块主要的 GPU 缓冲区:
1 | |
普通 GQA 模型的 block 形状
对普通 GQA 模型,一个 block 的逻辑形状可以写成:
1 | |
这五个维度按“层 → 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 | |
再乘以每个元素的字节数,并加上 padding 和对齐,就得到 block_bytes:
1 | |
其中 element_size 是每个元素的字节数,FP16 为 2,FP8 为 1;padding 包括层内 32B pad、块尾 padding 和注册对齐。以前面的 Llama 风格模型为例:32 层、block_size=128、8 个 KV head、head_dim=128、FP16。一个 block 的元素数是:
1 | |
按 FP16 每元素 2 字节计算:
1 | |
这和上一节的估算一致:每 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 | |
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:模型 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 | |
一个 block 可能同时被多个“持有者”引用:
- 请求本身持有引用,直到请求结束。
- 异步 Put 任务持有引用,直到写 Store 完成。
- P/D 传输持有引用,直到 CE 读完并发出通知。
所以释放 block 不是“请求结束就立刻 free”,而是“所有引用都释放后才 free”。这是后面理解 pin/unpin 的基础。
前缀缓存
前缀复用的原理
假设两个请求共享同一段系统提示。
1 | |
系统提示的 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 | |
“喜欢 苹果”这段 token 相同,但前面的主语不同,K/V 不同。所以 hash 必须把前一块的 hash 也带进来:
1 | |
- 第一块用约定的
NONE_HASH作为前驱。 extras放图片标识、LoRA(低秩适配)标识、cache salt(请求级缓存隔离盐)等额外信息。- 这样任何一个 block 的 hash 都唯一对应“从开头到这里的完整前缀”。
PoolKey 与完整缓存 key
只有内容 hash 还不够。不同模型、不同并行分片、不同缓存角色的对象不能混在一起。vllm-ascend 用 PoolKey 把这些信息拼成一个字符串:
1 | |
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 | |
池化指把 KV 放进 Store,供多个实例共享。实现上可以先只缓存 KV block,不缓存 SWA 等 state;需要进一步提升命中率时,再引入 SWA 快照、copy_state(state 快照缓冲区)和多租户(block 与 SWA 使用独立租户和 TTL,即对象存活时间)。
只缓存 KV block 时,可以用下面的公式计算 max_hit、H 和 S。
1 | |
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 | |
| 范围 | 处理方式 |
|---|---|
| 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 | |
当写到第 W 个 token 后,新 token 会覆盖最老的 slot。ring buffer 的物理顺序和逻辑顺序不再一致:
1 | |
所以判断 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 物理布局版本,传输双方必须一致 |