多级缓存、分布式缓存等话题在传统计算机领域里讨论已久,对于 LLM Serving 有诸多可借鉴的地方。多级缓存通过下层存储增加容量、延长 KV 的驻留时间,代价是层间的数据传输。一次命中能否带来加速,取决于恢复 KV 的实际延迟是否低于重算这段前缀的耗时。
本文把 GPU HBM、host memory 和外部存储分别记为 L1、L2、L3。越往下容量越大,但带宽通常越低,访问路径也更长。L1 和 L2 属于单个推理实例。L3 可以使用本地存储,也可以使用多个实例共享的后端,让一个实例写入的 KV 供其他实例复用。
store(写入)将 KV 写向下层,load(加载)将命中的 KV 搬回 L1,evict(淘汰)则释放空间。下层保存的 KV 必须先回到 GPU,才能参与 Attention。
下文沿两个请求展开:请求 A 首次计算一段长前缀,它的 KV 从 L1 写入 L2、L3。之后 L1 淘汰了这些 KV,请求 B 带着相同前缀到来,需要把它们搬回 GPU。先分析 A 的 store 和 B 的 load,再看在途内存如何安全回收,最后比较搬运与重算的成本,并以 SGLang、vLLM 和 RTP-LLM 的实现作对照。
store 路径:KV 从 GPU 写到下层
请求 A 的 Prefill 逐层计算 Attention,每层都把本层的 K、V 写进 L1。想把这些 KV 写到下层,要依次回答三个问题:
- 什么时候 store,保存哪些 KV?
- 拷贝怎样执行,才不阻塞调度和计算?
- store 期间,后续请求能看到哪些数据?
store 时机与策略
安排 store 时,需要考虑以下三点:
- 请求解耦:应尽量避免让请求等待 store 完成。当前请求应继续计算,后续请求应只复用已就绪的缓存,以简化请求调度与 store 之间的依赖。
- 数据完整性:缓存按固定数量 token 组成的 page 管理(vLLM 和 RTP-LLM 称为 block)。只有 page 内填满规定数量的 token,且每个 token 的所有层 KV 都已计算完成,page 才算就绪,才能提交整页 store。
- 提交时机:本文讨论的框架通常在 forward 结束后批量提交 store,以减少小拷贝的提交次数和 forward 内的同步开销。
各框架登记或规划 store、实际提交拷贝的时机如下(vLLM 指 CPU offload):
| 框架 | 登记或规划时机 | store 安排 |
|---|---|---|
| SGLang HiCache | Prefill 每完成一段就登记就绪的 page,请求结束时再登记生成部分 | write-through 在结果处理后或调度检查时合并提交 |
| vLLM CPU offload | 每个 step 为本轮将写满的一组 block 规划 store,默认只保存 prompt | 下一个 step 开始时提交拷贝 |
| RTP-LLM | 请求结束时,将 block 挂到前缀树上 | L1 使用率超过高水位后后台降级;开启远端存储时,请求结束也会触发远端 store |
vLLM 推迟提交,是为了让 offload 排在采样相关的传输之后,避免拖慢 token 生成。
store 策略
提前 store 能让副本更早就绪,代价是可能把带宽和容量花在不再复用的数据上。store 策略通过不同的触发条件控制这笔开销:
| 策略 | 触发条件 | 收益 | 代价 |
|---|---|---|---|
| write-through | KV 进入前缀缓存 | 保留所有潜在复用 | 写放大最大,低复用数据挤占下一层 |
| write-through-selective | 复用计数达到阈值 | 过滤一次性前缀 | 达到阈值前可能需要重算 |
| write-back | 上层淘汰 | 写流量最小 | 容量紧张时与 load 争用带宽,回收 L1 空间需等待 store 完成 |
大量请求共享同一个 system prompt 时,一次 D2H 可以换来多次复用。对于长尾对话历史,如果大多数前缀只复用一两次,过低的 store 阈值会让 L2 塞满低复用的 KV,并持续消耗 D2H 带宽。
保留副本的 write-through 在 L2 容量足够且 store 完成时可形成 L1 ⊆ L2,L1 里的完整 page 都有 L2 副本,淘汰时无需再次 store。采用互斥布局的 write-back 在迁移后释放源副本:从 L1 降级到 L2 后释放 L1 block,从 L2 load 回 L1 后也释放 L2 副本。这样,同一段 KV 只在一层提供服务,各层容量可以叠加,代价是 L1 再次淘汰时需要重新向 L2 store。
write-back 如果等 L1 空间不足时才提交 store,源 page 必须等 D2H 完成才能释放,新请求的分配就会等待。
框架实现: SGLang 默认采用 write-through,selective 在前缀登记计数达到 2 时触发 store。同一请求在 Prefill 和自回归 Decode 过程中可能多次更新前缀树,因此同一节点对该请求只计数一次。SGLang 的 write-back 采用上述回收方式。vLLM 的 L1→L2 store 采用 write-through,完成后立即向所有 L3 后端提交 store。
RTP-LLM 的本地 L2、L3 采用 write-back 和互斥布局,通过后台提前降级分散 store,为后续分配留出余量。每次插入新数据或完成拷贝后,它检查 L1 使用率,超过高水位(默认 90%)就异步降级较冷的 block,直到使用率低于低水位(默认 82%)。
逐层 store
Transformer 逐层产生 KV,store 也可以采用 layer-wise 方式:对于准备保存的一段 token,当前层的 KV 完整后就先写出,后续层继续计算。这样,当前层的 store 可以与后续层的计算重叠1。对于前缀缓存,这有机会让副本更早就绪,供后来的请求复用;对于 PD 分离,前面各层的 KV 在 Prefill 期间就发往 Decode 实例,可以减少 Prefill 结束后剩余的传输时间。
代价是每层都要提交任务、建立计算与拷贝的依赖,单次数据量变小后,固定开销也更难摊薄。计算和传输还会争用带宽或 SM。如果多层共用一个中转 buffer,复用前要等上一层传输完成,forward 结束后也要处理最后一层的传输收尾。
源码对照: vLLM 的 save_kv_layer 回调位于每层 Attention 调用之后,为后端提供逐层提交 KV 的入口。各层可以先后写出,后续请求复用完整前缀时,再检查所需各层是否齐备。LMCache 的前缀查询要求全部层在同一存储位置命中。除了写入下层缓存,逐层传输也用于 PD 分离:vLLM 的 MoRIIO WRITE 后端将 KV 从 Prefill 实例逐层发往 Decode 实例,等全部发送完成后才通知 Decode 端,并允许释放源 block。
异步传输与完成确认
L1→L2:拷贝与完成确认
L1→L2 的 D2H 一般放在独立的拷贝 stream 上,通过 event 或 stream 依赖排在产生 KV 的计算之后。调度线程提交后继续工作。确认完成时,可以在后续调度轮次中查询完成 event,也可以让传输线程等待拷贝 stream 后回报。后一种等待只阻塞传输线程。
多卡共同维护缓存索引时,各 rank 的拷贝进度可能不同,需要同步完成状态,只确认所有 rank 都完成的任务。
框架实现: SGLang 在各 rank 上保持相同的任务队列顺序。调度线程用 all_reduce(MIN) 对各队列从队头连续完成的任务数逐项取最小值,再更新缓存状态。vLLM 由 worker 每个 step 查询 event,调度器收齐各 rank 的完成报告后确认任务。RTP-LLM 则由传输线程同步拷贝 stream,随后在锁内更新缓存状态。
源码对照: 在 SGLang 保留 host 副本的 write-through 路径中,UnifiedRadixCache 负责登记 store 与确认完成,cache_controller 通过其 L2TransferEngine 提交 D2H。inc_lock_ref 获取源码中称为设备锁的引用保护,使 KV 在拷贝期间保持有效。
# UnifiedRadixCache: queue a write-through backup (simplified).
def queue_backup(node_id):
device_indices, _ = tree_core.build_backup_spec(node_id)
host_indices = cache_controller.write(
device_indices, node_id=node_id, flush=False
)
if host_indices is None:
return
tree_core.commit_backup(node_id, host_indices, {})
lock_params = inc_lock_ref(node_id).to_dec_params()
_track_write_through_node(
node_id, lock_params, publish_node_ids=[node_id]
)
# Scheduler.process_batch_result: flush after processing the whole batch.
tree_cache.flush_pending_backups() # Merge queued backups and submit D2H.
# cache_controller / L2TransferEngine: enqueue dependencies, not a CPU wait.
write_stream.wait_stream(forward_stream)
start_event.record()
with torch.cuda.stream(write_stream):
start_event.wait(write_stream)
host_pool.backup_from_device_all_layer_physical(...)
finish_event.record()
# Subsequent scheduling rounds: poll and agree on completed operations.
write_done, load_done, *_ = tree_cache._sync_hicache_ready_counts()
tree_cache.writing_check(finish_count=write_done)
# Each write ack marks the host copy ready, releases the device lock,
# then queues L3 backup when storage is enabled.
提交本批 store 时,下一批 forward 可能已经开始。实际 D2H 要等计算 stream 上已提交的工作完成,随后才能与更晚的 batch 计算重叠。
L2→L3:存储 I/O
L2→L3 的 store 从 host memory 读取数据,所以要等 L1→L2 拷贝完成才能开始。存储 I/O 的延迟更高、波动更大,通常交给后台线程,调度线程只投递任务、读取完成队列。
后台线程可以执行同步 I/O,也可以用 io_uring、RDMA 等异步接口处理更多并发任务,代价是取消、重试和状态管理更复杂。常见的 L3 后端按访问方式分为四类:
| 形态 | 例子 | 访问方式 |
|---|---|---|
| 本地文件 | SGLang file、vLLM fs、RTP-LLM DISK | 后台线程中的同步读写 |
| 远端内存池 | Mooncake Store | RDMA,直接读写注册过的 host page |
| 分布式文件系统 | 3FS | RDMA,专用的用户态 I/O 接口 |
| 对象存储 | S3 兼容存储(经 NIXL 访问) | 网络请求 |
store 完成前的可见性
store 成功后,下层副本才能供请求复用。各框架的可见性如下:
| 框架 | 可见性 |
|---|---|
| SGLang HiCache | 查找仍命中 L1。D2H 完成并淘汰 L1 副本后,才使用 L2 副本 |
| vLLM CPU offload | store 中的目标 block 未就绪 |
| RTP-LLM | 目标 block 在 store 完成前对查找不可见(降级期间,L1 源 block 也不可命中) |
SGLang 和 vLLM 的 L3 文件后端先写 tmp 文件,写完后通过 rename 原子重命名,使其对查询可见。
load 路径:KV 从下层回到 GPU
请求 B 到来时,A 的 KV 已经从 L1 淘汰,只留在 L2、L3。load 先查找可复用的前缀及其所在层级,再安排传输,计算读取 KV 前必须确认数据就绪。无法与 B 自身计算重叠的 load 时间会计入首 token 延迟(TTFT)。
查找与预取
本地查找先匹配请求的 token,找到可复用的连续前缀及其 KV 位置。已经在 L1 中的部分直接复用,只在 L2 中的部分则需要 load。这一步只读元数据,可以在调度线程中同步完成,索引可以采用前缀树或 block 哈希。L3 则需要向存储后端确认 page 是否存在,可以用链式计算的前缀哈希作为查询 key。
与 L3 store 一样,L3 查询和读取也可以交给后台执行。请求进入等待队列时就可以发起预取:本地匹配完成后,先异步查询 L3 的连续命中范围,再为命中的 KV 分配 host page、提交读取。这样,请求排队的时间就能与 L3 预取重叠。
预取策略决定愿意用多少排队时间换取更长的可复用前缀。轮到 B 调度时,如果预取尚未结束,可以直接采用已完成的前缀、等全部完成,或只等待给定的时间预算。B 留在队列期间,调度器继续处理其他请求。
预取结果以已经完成的连续前缀为复用范围,剩余部分交给重算。预取完成或按策略停止后,将这段前缀及其 host 位置登记到本地索引,后续沿 L2 命中路径执行 load。多卡执行时,各 rank 必须采用共同完成的 page 范围。
框架实现: 三种框架的本地匹配都在调度阶段完成。SGLang 提供上述三种预取策略,其中限时等待的预算随预取长度增长,从首次因预取未完成而推迟调度时开始计时2。后台线程查询 L3、对齐各 rank 的预取进度,调度线程负责 host page 分配和结果登记,I/O 线程执行读取。预取的 page 留在 L2,供后续请求复用。
vLLM CPU offload 同样经 L2 中转3。后台线程探测到 L3 命中后,调度器预留 L2 空间,在本 step 结束时提交 L3→L2 的读取。数据就绪之前,请求留在等待队列里,每个 step 重新查找一次。
RTP-LLM 读取本地盘时,用临时的页锁定内存作中转,数据进入 L1 后释放中转空间。
load 与计算的重叠
load 前先保护源数据,为待恢复的 KV 分配 L1 page,空间不足时尝试淘汰其他缓存。分配完成后登记源和目标位置,形成 load 任务。
按请求等待时,调度器确认 B 的全部 KV 已到达 GPU,再启动它的 forward。load 可以与其他请求的计算重叠,B 自身的 TTFT 包含完整的 load 时间和完成后的调度检查。
按层等待时,load 与前文的逐层 store 一样按层提交。Attention 后端在每层读取 KV 前,让计算 stream 等待该层拷贝的完成 event,调度线程继续工作。后续层的 load 可以与 B 当前层的计算重叠。
框架实现: SGLang 采用逐层等待,vLLM CPU offload 和 RTP-LLM 采用按请求等待。
源码对照: vLLM CPU offload 把 H2D 的提交放在本 step 的 forward 发起之后,将提交拷贝的 CPU 开销移出关键路径。拷贝 stream 要等待计算 stream 上已提交的工作,因此 H2D 只能与之后 step 的计算重叠。
SGLang 的 UnifiedRadixCache 负责本地索引、预取结果登记和load 准备,cache_controller 通过其 L2TransferEngine 逐层提交 H2D。init_load_back 准备 load 任务,ready_to_load_host_cache 才触发批量传输。
# Request arrival: UnifiedRadixCache (simplified).
handle = req.cache_request_handle
m = tree_cache.match_prefix(MatchPrefixParams(key=req_key, req=req))
tree_cache.prefetch_from_storage(
handle, m.last_host_node, rest_tokens,
last_hash=tree_cache.get_last_hash_value(m.last_host_node),
extra_key=req.extra_key, cache_salt=req.cache_salt,
)
# Admission: remain queued if the prefetch policy requires more waiting.
if not tree_cache.check_prefetch_progress(handle):
continue
m = tree_cache.match_prefix(MatchPrefixParams(key=req_key, req=req))
tree_cache.init_load_back(InitLoadBackParams(
best_match_node=m.best_match_node,
host_hit_length=m.host_hit_length, req=req,
))
batch.hicache_consumer_index = tree_cache.ready_to_load_host_cache()
# Forward: the compute stream waits before each layer reads its KV.
layer_done_counter.wait_until(layer_id)
# Subsequent scheduling rounds: confirm and release transfer-owned locks.
write_done, load_done, *_ = tree_cache._sync_hicache_ready_counts()
tree_cache.loading_check(finish_count=load_done)
# loading_check releases both the device-lock and host-lock receipts.
在途内存的保护与回收
请求结束时,已提交的异步拷贝可能还在执行。设想 A 的 D2H 还没执行,A 已经释放了 L1 page,调度器把它们分给请求 C,C 的 Prefill 写入了新的 KV。D2H 随后从原地址拷走 C 的 KV,却登记在 A 的前缀下。拷贝本身可以正常完成,B 命中这段前缀后却会基于错误的 KV 继续生成。H2D 也有同样的风险:源 host page 若提前归还并让预取任务覆写,load 到 GPU 的数据也会出错。
拷贝期间要保持源和目标内存有效,防止其他任务覆写。常见做法有两类:持有引用直到拷贝完成,或提前归还空闲池,在复用前等待拷贝完成。
持有引用直到完成
淘汰只选择没有请求使用、也没有传输占用的缓存。请求计算、store 和 load 都会使 block 处于忙碌状态,由引用计数或在途标记保护。请求结束只释放自己的引用,所有引用归零后,内存才能回到空闲池。
引用交接遵循先接管、后释放:新持有者先取得引用,原持有者再撤销引用,保证内存不会在交接中途变成可回收状态。请求取消只结束请求对结果的使用,在途 I/O 仍可能访问原地址,目标内存要保留到 I/O 返回。
框架实现: SGLang 的设备锁保护 GPU page,覆盖请求复用的前缀、write-through store 的源 page,以及 load 时已有的 GPU 前缀和新分配的目标 page。host 锁保护 host page,覆盖 load 的源 page、L3 store 的源 page,以及 L3 预取依赖的前缀起点。
一次 H2D 同时持有这两类锁。各 rank 确认传输完成后,调度线程释放传输持有的锁,请求持有的设备锁继续保护正在使用的 GPU page。
预取预算耗尽后,SGLang 将不再采用的目标 page 保留到在途 I/O 返回,再将其放入释放队列。
vLLM CPU offload 只淘汰 store 已完成、没有读取者持有引用的 CPU block。load 途中取消请求时,目标 GPU block 仍保留到传输完成。
源码对照: RTP-LLM 在请求和 block 两个层面管理引用。异步处理 forward 输出的 worker 还会访问请求及其 KV,所以 engine 交出输出前先增加请求计数,worker 完成后再减一。请求结束时若仍有 worker 持有引用,就由最后退出的 worker 负责释放。层间拷贝则使用 block 引用,源码按持有者区分以下引用类型:
| 引用 | 持有者 | 加在哪些 block 上 |
|---|---|---|
| 请求引用 | 请求 | L1 block |
| CACHE | 前缀树 | 当前提供服务的一层 |
| LOAD | load 任务 | 源和目标 |
| EVICTION | 降级任务 | 目标 |
| STORE | store 任务(关闭 L1 缓存时) | 源和目标 |
RTP-LLM 把空闲条件落实为:block 仅有 CACHE 引用,且不在传输中。降级中的 L1 源 block 沿用 CACHE 引用,在途状态表明它仍然忙碌,因此不能成为淘汰候选。
请求或传输结束时,先让前缀树接管可复用的 KV,再释放原持有者的引用。一次降级把缓存的所有权从 L1 转到 L2:先给 L2 目标加 CACHE,再撤销它的 EVICTION,最后撤销 L1 源的 CACHE。请求取消时,尚未完成的 load 仍由 LOAD 引用保护,完成后把数据交给缓存。
归还空闲池,复用前等待
提前归还空闲池允许新请求先取得 block,真正覆写则要等相关 store 完成。请求结束时,系统归还 GPU block,同时保留其未完成 store 的记录,让新请求在 forward 前据此等待。
vLLM 的 CPU offload 对 D2H 的 GPU 源 block 采用了这种方式,抢占请求时也会先完成该请求的全部 store。
源码对照: vLLM CPU offload 由 OffloadingConnector 接入调度器和模型执行器,调度侧记录每个 block 尚未完成的 store。wait_for_save 登记本轮 store,推迟到下一 step 提交。源 block 即将复用时,handle_preemptions 在 forward 前完成 jobs_to_flush 指定的 store 任务。代码中的 chunk 对应前文的一组 block。
# Scheduler.schedule()(vLLM OffloadingConnector,简化)
n, load_async = connector.get_num_new_matched_tokens(req, num_computed) # 查 L2。L3 命中时预留 L2 空间并发起读取,未就绪则本 step 跳过
blocks = kv_cache_manager.allocate_slots(req, ...)
connector.update_state_after_alloc(req, blocks, n) # 锁定 L2 中的源数据,生成 load 任务
req.status = WAITING_FOR_REMOTE_KVS # load_async 为真:本 step 不计算该请求
meta = connector.build_connector_meta(sched_output) # 为本 step 将写满的 chunk 规划 store
# GPUModelRunner.execute_model()
connector.handle_preemptions(meta) # 提交上一 step 推迟的 store,block 将被复用时先等 store 完成
model.forward(...) # wait_for_layer_load、save_kv_layer 均为空操作
connector.start_load_kv(...) # forward 发起之后提交 load
connector.wait_for_save() # 只登记本 step 的 store,推迟到下一 step 提交
connector.get_finished(...) # 查询 event,报告已完成的 load
# Scheduler.update_from_output():记录 load 完成。下一次 schedule() 把请求恢复为 WAITING,可以立即调度
搬运的成本与收益
load 的延迟既取决于搬运本身的耗时,也取决于能与计算重叠的部分。一次 load 可能依次经过存储、网络、host memory、PCIe 和 GPU memory。
KV 分片与副本
KV Cache 可能按 head 或序列分片,也可能在多个 ranks 上保存完整副本。
对于逐层独立存放 K、V 的模型,设它有 个 decoder layers、 个 KV heads,每个 head 宽度为 ,KV 元素占 bytes。用 表示单个 rank 实际保存的 KV heads 数。恢复一段包含 个 token 的前缀时,单个 rank 需要搬运:
KV 完全按 TP 切分时,各 rank 保存的 KV heads 合计为 ,整个节点只有一份完整 KV。GQA 的 超过 后,框架通常会让每个 rank 至少保存一个 KV head。这样,各 rank 保存的 KV heads 合计会超过 ,同一个 KV head 也会出现在多个 ranks 上。
按序列分片存放 KV 时,每个 rank 只 store 和 load 自己的分片,整个 CP group 合计保留一份完整 Cache。
D2H/H2D 要按各 ranks 实际保存的副本计算。 个完整副本会让节点搬运 份相同数据,序列分片只需搬运一份。
以 Qwen3-235B-A22B4 为例,、、、KV Cache 使用 BF16。 时,常见实现会让每个 rank 至少持有 1 个 KV head,于是每个 KV head 在 8 个 ranks 中有两份副本。对于 32K prefix,单个 rank 需要搬运 1.47 GiB,整个节点合计 11.75 GiB,其中不重复的 Cache 只有 5.88 GiB。
传输链路与带宽
从 L2 load KV,数据通常要经过 host DRAM → PCIe → GPU HBM。从 L3 load 时,前面还会增加存储或网络传输。单个 rank 受本地链路限制,多个 ranks 并发时还会共同争用 host memory、PCIe switch、CPU 互连或 NIC。因此,带宽估算既要使用对应方向和拓扑下的有效值,也要区分单卡上限与节点聚合上限。
下表给出各链路的带宽量级:
| 位置或链路 | 带宽口径 |
|---|---|
| H200 HBM3e | 4.8 TB/s/GPU |
| GPU 间 NVLink | H200 900 GB/s/GPU,B300 1.8 TB/s/GPU |
| PCIe Gen5 x16 | 单向理论约 64 GB/s,有效 H2D 可先按 50 GB/s 估算 |
| NVMe SSD(PCIe Gen5 x4) | 单向理论约 16 GB/s/盘 |
| InfiniBand NDR | 单向理论约 50 GB/s/端口 |
| 400 GbE 上的 RoCE | 单向理论约 50 GB/s/端口 |
单块 NVMe 的理论带宽只有 PCIe Gen5 x16 的四分之一,用本地盘做 L3 时,需要多块盘并行读写,才能避免存储成为整条路径的瓶颈。远端存储可以通过 InfiniBand 或 RoCE 网络使用 RDMA。GPUDirect RDMA 进一步允许网卡直接访问 GPU memory,省去 host memory 中转5。
host memory、GPU、网卡或 NVMe 位于不同 CPU socket 或 PCIe 分支时,传输可能多经过一段 CPU 互连,整条路径的带宽受最慢环节限制。nvidia-smi topo -m、topo -cpu 和 lspci -t 可以检查这些连接关系6。
KV 传输加速
host 内存池通常使用页锁定内存(pinned memory),支持异步 H2D/D2H。GPU kernel 也能直接访问映射后的 host memory7,每次访问都经过 PCIe 或 NVLink C2C。相比 HBM,这种访问延迟更高、带宽更低,适合只读一次且连续访问的数据。供 Attention 反复读取的 L1 Cache 保留在 HBM 中。
| 方式 | 主要执行资源 | 更适合的形状 | 主要代价 |
|---|---|---|---|
cudaMemcpyAsync | 通常使用 copy engine | 少量大块、连续的数据 | 多次小拷贝会累积 API 和调度开销 |
cudaMemcpyBatchAsync | 由 CUDA runtime 选择 copy engine 或 SM | 多段独立拷贝8 | 需要准备地址与大小数组 |
| CUDA copy kernel | SM | 离散 pages、gather/scatter、layout 转换 | 与计算争用 SM 和显存带宽 |
cudaMemcpy* 使用的硬件资源由 CUDA runtime 选择9。copy engine 的数量或带宽成为限制时,由 SM 执行的 copy kernel 可能更快。
GPU 按层读取 KV,L3 按 page 存取,host memory 的布局需要兼顾这两种访问方式。同一层的数据连续排列,便于逐层 H2D;一个 page 的各层数据放在一起,便于整页 store 到 L3。按 page 聚合后,恢复到 GPU 仍可能需要逐 token、逐层的小拷贝。如果在 page 内再按层连续排列,就能按 page 和层合并搬运。
多个 stream 上的拷贝共享有限数量的 copy engine,copy kernel 则与 Attention 和 GEMM 争用 SM 和显存带宽10。
vLLM CPU offload 为减少对计算的干扰,只在 CPU→GPU 的小 page 拷贝中使用 Triton kernel,并且最多占用 12 个 SM。
源码对照: SGLang 的批量拷贝路径通过 cudaMemcpyBatchAsync 一次提交多段拷贝,摊薄 API 调用开销;copy kernel 实现则由 GPU threads 按索引搬运离散 KV。
load 与重算
请求实际感知的 load 延迟可估算为:
求和项是数据依次经过各段链路的传输时间, 和 分别是第 段链路的实际传输量和有效带宽。 是预取或 load 任务的排队时间, 包含描述符准备、API 调用和 kernel launch 等固定开销, 是确认完成、对齐各 rank 状态的开销。
是与请求 B 自身计算重叠的 load 时间:逐层 load 时受同一次 forward 的计算量限制,按请求等待时则接近 0。传输分段太小会放大固定开销,合并得太大又可能推迟第一批 KV 到达 GPU,减少重叠机会。因此,选择拷贝粒度时要同时考虑 与 。
只比较数据传输与重算时,沿用 Roofline model,将重算 FLOPs 与待恢复 Cache 字节数之比作为计算强度,再与 GPU 算力和缓存路径带宽的比值比较11。记重算量为 ,待恢复的数据量为 ,GPU 算力和缓存路径带宽分别为 、:
当 时,数据传输的理论耗时低于重算。简化估算使用 GPU 峰值算力和缓存路径的带宽估值,实测时换成实际值。L3 的 取整条 L3→L2→L1 路径的端到端带宽。
MLA、DSA 等架构会压缩 ,也可能通过稀疏计算降低 。数据量的缩减比例更大时,load 更有优势。计算量的缩减比例更大时,重算更有优势。
以 Qwen3-235B-A22B、、8×H200 为例。记激活参数量为 ,Q heads 数为 ,重算 32K prefix 的 Prefill 计算量约为:
平均到每个 rank, PFLOPs, GiB,因此 FLOPs/byte。按单张 H200 的 BF16 dense 峰值 989 TFLOPS、pinned-memory H2D 有效带宽 50 GB/s 计算, FLOPs/byte。前者高于硬件临界值,所以 load 的理论耗时更低,约为 31 ms,而重算约为 390 ms。
31 ms 是 load 独占 PCIe 时的传输时间,其中一部分可以与本轮计算重叠。设 batch 中只有请求 B,它在 32K 前缀之后追加 个 token,这次 forward 的计算量约为:
第二项是新 token 对前缀和自身的 Attention。按峰值算力估算, 时单个 rank 约需 19 ms,逐层 load 后仍有约 13 ms 的 load 时间无法与计算重叠;按请求等待时两段串行,合计约 50 ms。 增加到 4K 时,计算约需 78 ms,load 几乎能全部与计算重叠。实际算力低于峰值时,计算耗时更长,也会增加重叠机会。追加内容越短,load 中需要单独等待的部分就越多,长对话历史后面跟一条短消息正是这种情况。
store 与 load 的调度
并发服务中,load 与后台 store 共享 PCIe、host memory 带宽和 GPU 拷贝引擎。资源争用可能增加 I/O 排队时间,降低吞吐并推高 P99 TTFT。调度应优先派发 load,减少请求等待 KV 的时间;用于降级的 store 也要持续执行,才能及时回收 L1 空间。
RTP-LLM 的 BlockTreeTaskPool 为 load 预留队列容量,避免后台任务填满队列后 load 无法入队。派发时优先选择 load。两类任务同时排队时,连续派发最多 4 个 load 任务后,就派发 1 个后台任务,防止持续到来的 load 让降级任务一直等待。
实例:CP 下的容量与 load 去重
PR #26691 的实验基线中,SGLang 各 rank 向 L2 store 的都是相同的完整序列 KV。在 、attn_cp_size=8、attn_tp_size=1 的配置下,L1 和 HiCache L2 都保存了 8 份重复的缓存。
去重的两步收益
让各 rank 只保存和 load 自己的序列分片,需要 Cache 布局与 Attention 后端一起改造。受限于改造成本,可以在不同层级实现去重,减少重复的缓存占用和数据搬运。
表示保存完整 Cache 的 rank 数,D2H、H2D 表示每个逻辑 Cache page 搬运的份数:
| 方案 | 定位 | host 数据 | D2H | H2D | GPU 间数据传输 | 主要问题 |
|---|---|---|---|---|---|---|
每 rank 独立缓存 | 实验基线 | 无 | L2 容量与 PCIe 流量都重复 | |||
共享 host 副本,各 rank 完整 load | L2 去重 | 无 | H2D 重复,多个 ranks 读取同一段 host DRAM | |||
固定 source rank + broadcast | 临时方案 | 一次 broadcast | source rank 与 broadcast 压力集中 | |||
按序列分片 load | 理想方案 | 分布式 Attention 通信 | 需要 Cache 布局与 Attention 后端配合 |
PR #26691 在近似相同的节点 host memory 预算下比较了前三种方案:实验基线为每个 rank 40 GB,8 个 ranks 合计 320 GB。
| 配置 | 不重复 Cache 容量 | cache hit rate | 平均 TTFT | 请求总耗时 |
|---|---|---|---|---|
实验基线:每 rank 独立缓存 | 40 GB | 33.2% | 15.3 s | 706 s |
共享 host 副本,各 rank 完整 load | 300 GB | 74.0% | 10.2 s | 499 s |
固定 source rank + broadcast | 300 GB | 73.9% | 6.7 s | 291 s |
实验基线与两种去重方案的对比体现了容量增加对命中率的收益。后两种方案的容量和命中率基本相同,性能差异主要来自 load。 共享 host 副本后,8 个 ranks 各自完整 load 同一份数据,仍有 8 次 H2D,争用 host memory 和 PCIe 带宽。
固定 source rank load 后再 broadcast,数据只经过一次 host memory 和 PCIe,其余 GPU 通过更快的 NVLink 获取副本。即使 H2D 与 broadcast 串行执行,减少重复 H2D 也可能带来收益。表中该方案的平均 TTFT 和请求总耗时更低。这套方案也适用于 DPA 这种多个 Attention replicas load 同一个共享 prefix 的场景。
Source rank 的带宽压力
固定 source rank 会把 host 传输和 broadcast 都集中到一张 GPU。H2D 占用它的 PCIe 带宽和 copy engine,broadcast 还要从它的 HBM 读取数据,再通过 NVLink/NVSwitch 发送给其他 GPU。所有 ranks 都要等待 broadcast 完成,source rank 的排队会直接拖慢整体。
可以为每个 block 生成在所有 ranks 上一致的随机 ID,再对 rank 数 取模:source_rank = block_id % g。block ID 均匀分布时,各 ranks 承担的 block 数也会接近,从而分散单卡热点,但 PCIe 和 GPU 互连的总通信量不变。
也可以让各 rank 分片执行 H2D,再通过 AllGather 恢复完整 KV,以分散 host 传输。
Collective 顺序与死锁排查
新增的 KV broadcast 要与 forward 中的 collective 保持一致的跨 rank 顺序。不要把这类额外处理直接放到 default stream,应显式指定专用 stream,并建立与 forward 的依赖。PR #26691 的早期实现里,H2D 在 load stream 上执行,broadcast 却落到 default stream,与 forward collective 之间缺少先后约束。
如果碰到请求卡住,先确认各 rank 最后进入的 collective,再检查它们使用的 NCCL 通信组和 CUDA stream。NCCL_DEBUG=TRACE 配合 NCCL_DEBUG_SUBSYS=CALL 可以记录调用顺序,Nsight Systems 可以还原 H2D、broadcast 和 forward 的 stream 时间线。将各 ranks 的日志与时间线对齐,找出第一个 collective 顺序分叉的位置:
| rank 0 | rank 1 |
|---|---|
2026-09-03 10:18:42.481 [Rank 0] ncclBroadcast(comm=cache, stream=default) ENQUEUE2026-09-03 10:18:42.484 [Rank 0] ncclAllReduce(comm=tp, stream=forward) ENQUEUE | 2026-09-03 10:18:42.482 [Rank 1] ncclAllReduce(comm=tp, stream=forward) ENQUEUE2026-09-03 10:18:42.485 [Rank 1] ncclBroadcast(comm=cache, stream=default) ENQUEUE |
rank 0 在 cache broadcast 中等待 rank 1,rank 1 却在 forward AllReduce 中等待 rank 0,两边形成环形等待。
修复后,H2D 与 broadcast 都在专用的 load stream 上执行,forward 显式等待该 stream 完成。
进一步减少 L1 副本
source rank + broadcast 消除了 L2 副本和 H2D 的重复,GPU 端仍是每个 rank 一份完整 Cache。进一步减少 L1 占用,需要让 Cache 布局与 Attention 后端共同支持序列分片。
总结
判断多级缓存是否带来收益,需要控制变量并比较各种方案的端到端 TTFT 与吞吐,再逐层定位收益与瓶颈:
| 层级 | 核心问题 | 观测指标 |
|---|---|---|
| 复用 | 增加的容量是否换来了更多 KV 复用 | L1、L2、L3 命中的 token 数 |
| 单请求 | load 是否真的比重算更快 | 、、实际传输量、端到端有效带宽、传输与计算的重叠时间 |
| 服务整体 | I/O 是否引入共享瓶颈或单卡热点 | 吞吐、平均与 P99 TTFT、I/O 排队时间、因在途 store 而同步等待的次数和时长、各 rank 的传输字节数和耗时、各链路的带宽利用率、collective 延迟 |