KV Cache 前缀复用的命中条件:为什么你的长系统提示没省下钱

举报
yd_232401777 发表于 2026/11/22 07:25:46 2026/11/22
【摘要】 很多团队把长系统提示、工具定义、few-shot 示例一起塞进请求头部,指望"前缀缓存"把重复 prefill 的成本摊掉,结果账单没怎么变。问题通常不在缓存有没有开,而在前缀在 token 级别上已经不连续了——中间插了一个时间戳、工具描述顺序变了、序列化缩进变了,后面全部作废。本文拆开 prefill 与 decode 的成本形状,说明前缀复用的真实命中条件(从第 0 个

前言

有段时间我盯着一份推理账单,觉得有个数字不对劲:输入 token 的量远大于用户实际输入的内容。

排查下去发现,每次请求前面都挂着一段固定的东西——系统提示、七八个工具的定义、三段 few-shot。用户真正打的字可能只有几十个 token,前面那两千多个 token 是每次都送的。这些内容逻辑上是"常量",但账单上它们是每次都重新计费的输入。

当时我的判断很朴素:这部分内容完全一样,服务端应该有前缀缓存,命中了就不用重算。既然服务端支持,那我这边什么都不用改。

事实是账单几乎没动。后来才明白,前缀缓存不是"内容相似就能命中",而是"token 序列从第一个开始逐位一致才能命中"。 差一个 token,从差异点往后全部重算。而我的系统提示第一行就写着当前日期和用户所在时区。

这篇文章想把这层机制说清楚,因为它决定了很多工程细节:提示词该怎么排、工具定义该怎么序列化、多轮对话该怎么追加。

一、先搞清 prefill 和 decode 是两种成本

1.1 一次生成被切成两段

自回归生成分两个阶段:

  • prefill:把输入的整个 token 序列一次性过一遍模型,算出每层的 K/V,并产生第一个输出 token。这一步是高度并行的矩阵运算,主要吃算力。
  • decode:之后每生成一个 token,都要把它接上去再前向一次。这一步是串行的,每步只处理一个 token,但要把全部历史 K/V 读一遍,主要吃显存带宽。

所以成本结构是:输入越长,prefill 越贵;输出越长,decode 越贵。而 decode 的每一步都要读取整个 KV Cache,上下文越长,单个输出 token 也越贵。

这就解释了前缀复用的价值点:它省的是 prefill,而且是"同一段前缀被反复 prefill"这件事。

1.2 复用的对象是 KV 张量,不是文本

缓存里存的不是那段文字,而是这段文字在每一层算出来的 K 和 V。形状大致是 [层数, 头数, 序列长度, head_dim]。命中意味着这些张量可以直接拿过来用,不需要重新做前向。

这也是为什么"语义相同"没有意义:两段话意思一样但 token 不同,算出来的张量就是不同的,不能混用。缓存只认 token 序列。

顺带一个容易忽略的点:位置信息是烘焙进这些张量里的。同一段前缀出现在不同位置(比如前面多了一段别的上下文),它的 K/V 就不再相同。所以复用只发生在"从序列开头开始的同一段前缀",中间位置的重复内容不享受这个待遇。

二、命中条件:从第 0 个 token 开始的连续一致

2.1 一个前缀树的心智模型

把服务端的缓存想成一棵按 token 展开的树,根节点是序列开头。每个请求进来,从根往下走,走到第一个分叉就停——走多深,就能复用多深。分叉点之后的部分必须重新算。

这个模型能直接推出几条结论:

做法结果
稳定内容放最前面复用深度最大
稳定内容中间插一段动态内容动态内容之后全部作废
只在末尾追加新内容(多轮对话)前面的历史全部可复用
改写历史中的某一条消息从改写点之后全部作废

第 4 条是多轮场景里最容易踩的:有人为了"压缩上下文",每轮都把历史消息重新摘要一遍再拼进去,结果每次请求的前缀都和上一次不同,缓存命中率归零,还额外付了摘要的调用费。

2.2 分块粒度带来的对齐问题

底层为了管理显存,KV Cache 通常按固定大小的块(block)分配,比如每块装若干个 token。前缀匹配的复用深度一般要对齐到块边界,也就是说即使你复用了 1000 个 token,实际能利用的可能是 992 个——尾部那几个不够一块的 token 仍然要重算。

这个损耗在小前缀上不明显,但当你的"稳定前缀"长度不是块大小的整数倍、且请求量很大时,会固定地浪费一小截。做法上不必刻意对齐(你也没法精确控制 tokenizer 的分块),但要知道"命中率 100%"在工程上并不存在,能到九十几就算好。

2.3 缓存是有寿命的

缓存占的是显存,显存是稀缺资源。所以缓存一定会被淘汰:常见策略是 LRU 加 TTL,块被新请求挤掉或者超时就被回收。

这带来一个反直觉的结论:低频调用的长前缀,命中率天然低。 一个每天只跑几次的任务,即使前缀完全稳定,中间隔了几小时,缓存早被别的流量冲掉了。给这种任务做前缀优化,收益接近于零。

反过来,高 QPS 的在线服务,同一段系统提示被几千个请求共享,缓存几乎总是热的,这时的优化收益最大。

三、四类最常见的"破坏命中"写法

3.1 在头部注入动态信息

# 反例:第一行就是动态内容,后面 2000 token 全部陪葬
system = f"当前时间:{now:%Y-%m-%d %H:%M:%S}\n用户所在时区:{tz}\n\n" + BASE_SYSTEM

时间戳精确到秒,意味着每个请求的前缀都不同,复用深度为 0。这类代码往往是"为了让模型知道现在几点"而写的,但绝大多数场景并不需要秒级时间,甚至不需要时间。

修法是把动态信息挪到最末尾的用户消息里,或者把时间粒度降到天并接受它每天变化一次:

# 正例:稳定部分在前,动态部分在末尾
messages = [
    {"role": "system", "content": BASE_SYSTEM},          # 完全静态
    {"role": "user", "content": f"[参考时间 {today}] {question}"},
]

3.2 工具定义的序列化不稳定

工具列表如果是从一个字典或集合里遍历生成的,顺序可能每次不同——尤其在有并发初始化、或者用了无序容器的语言里。工具定义的顺序一变,前端 token 序列就变,缓存全废。

这类 bug 特别隐蔽,因为功能完全正常,只是账单偏高。判定方法很土但有效:把两次请求的完整 payload 落盘,做一次字符串 diff。 如果只有该变的地方在变,说明没问题;如果工具段顺序在抖,那就是它。

3.3 JSON 序列化细节不一致

同一个对象,json.dumps 加不加空格、key 是否排序、中文是否转义,产出的字符串不一样,token 序列就不一样。如果系统提示是拼 JSON 生成的,务必固定参数:

payload_text = json.dumps(spec, ensure_ascii=False, sort_keys=True, separators=(",", ":"))

三个参数里 sort_keys 最重要,它把"字典插入顺序"这个不确定性消掉了。

3.4 多轮对话里"重排"历史

有些实现为了把最重要的内容放前面,每轮都按相关度重排历史消息。这在人类阅读上合理,在缓存上是灾难:重排意味着从第一个被移动的位置开始,前缀就分叉了。

如果确实需要重排,可行的做法是把它做成两段:一段永不变化的历史(原始顺序,只追加),一段每轮重算的"精选上下文"放在最后。让变化的只发生在尾部。

四、值不值得做:一笔粗糙的成本账

前缀复用不是免费的午餐,它换来的收益要看 decode 与 prefill 的比例。

省下的成本 ≈ 命中前缀 token 数 × prefill 单价 × 请求量
总成本     ≈ (输入 token × prefill 单价) + (输出 token × decode 单价)

两个推论:

  1. 输入占比高、输出短的任务(分类、抽取、判定、意图识别),收益最大。这类任务常常是长提示 + 十几个 token 的输出。
  2. 输出很长的任务(长文生成、长链推理),prefill 只占总成本一小块,优化前缀的绝对收益有限。这时该优化的是输出长度和停止条件,不是前缀。

还有一个隐性成本:为了命中缓存,你把提示词结构固化了,改动的自由度下降。每次改系统提示都会让旧缓存失效一轮——这在发版时是正常的,但如果你的提示词是按用户维度动态拼的(比如每人一份个性化画像),那基本不可能命中,别在这条路上花时间。

五、一个能自检命中深度的最小实现

不用等服务端给指标,本地就能算"这次请求和上次共享多长的前缀"。做法是把 token 序列缓存起来,逐位比较:

import hashlib

class PrefixTracker:
    """记录最近一次请求的 token 序列,算出公共前缀长度。"""

    def __init__(self, block_size: int = 16):
        self.block_size = block_size
        self.last_ids: list[int] = []

    def check(self, ids: list[int]) -> dict:
        n = min(len(self.last_ids), len(ids))
        depth = 0
        for i in range(n):
            if self.last_ids[i] != ids[i]:
                break
            depth += 1
        self.last_ids = ids
        # 实际可用深度按块对齐向下取整
        usable = (depth // self.block_size) * self.block_size
        return {
            "common_tokens": depth,
            "usable_tokens": usable,
            "total_tokens": len(ids),
            "usable_ratio": round(usable / max(len(ids), 1), 4),
        }

# 用法:每次请求前算一次,采样打点到日志
tracker = PrefixTracker(block_size=16)
stat = tracker.check(token_ids)
log.info("prefix_hit", extra=stat)

把这个比值按小时聚合,就能看出两件事:稳态下的命中深度是多少(应该接近"静态前缀的长度"),以及有没有周期性掉到 0(说明某个环节在注入动态内容)。

如果命中深度长期只有个位数,那不用怀疑别处,一定是开头几个 token 在变。这时候打印前 20 个 token 的文本,基本一眼能看出来。

做了什么

这篇没有跑大规模的吞吐对比,我没有那种能把 GPU 利用率打到饱和的压测环境,所以文中不给"命中后省了百分之多少"的具体数字,只给成本结构的推导。

实际做过的是三件事:一是用上面的 PrefixTracker 在本地把同一套提示词的多次请求做逐位比对,确认了"头部注入时间戳 → 复用深度归零"这个结论;二是用 json.dumps 的 sort_keys 前后对比,验证工具定义段确实会因为字典顺序产生不同字符串;三是把一份长提示按"静态 / 半静态 / 动态"拆成三段,观察改动各段时前缀分叉发生在什么位置。这三件都是纯本地的字符串与 token 层面的观察,不依赖服务端指标。

一些体会

  1. 前缀缓存是"结构性"优化,不是"开关"式优化。 打开它不等于获得收益,收益取决于你的提示词结构。结构对了,什么都不用做就一直在命中;结构不对,开了也白开。
  1. 排提示词的顺序应该按"变化频率"排,而不是按"重要性"排。 稳定内容在前(系统提示、工具定义、few-shot),半稳定的在中(用户画像、会话级设定),每轮变化的在最后(当前问题、检索结果)。这个顺序同时满足缓存和可读性。
  1. 排查"账单为什么高"要先看输入输出比例。 输入占大头就去查前缀;输出占大头就去查停止条件和最大 token 设置。方向搞反了会白改一轮。
  1. 动态信息放末尾有个副作用值得注意: 模型对末尾内容的注意力更强,"当前时间"这类信息放在最后反而更准。所以这个改动通常是两头都赚,不是纯妥协。
  1. 低频任务别做前缀优化。 缓存会被淘汰,一天跑几次的任务命不中。这类任务该考虑的是能不能攒批、能不能缩短输入,而不是命中率。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。