外观
概念定义 · 什么是 KV Cache 与 PagedAttention?
自回归大模型是一个字一个字往外蹦的。如果不做缓存,吐到第 1000 个字时,前面 999 个字的键(K)和值(V)向量还得从头重算一遍,慢到无法使用。KV Cache 就是把历史词算过的 K、V 暂存在显存里,后续每步只算新来的这一个词,把单步推理从
但传统做法要提前给每个请求划一整块连续显存,导致大量碎片浪费;PagedAttention(vLLM 核心技术) 借鉴操作系统的虚拟内存分页,把 KV Cache 拆成固定小块按需分配、动态拼接,把并发吞吐直接拉高数倍。
01 问题从何而来:为什么算力还空着,回复却卡成 PPT?
很多人第一次部署 70B 大模型都会大吃一惊:买了一整台顶级 GPU,理论算力高达每秒近千次万亿运算,可实际跑在线对话时,并发稍微一高就显存爆掉(OOM),单人提问时 GPU 利用率更是低得可怜。
罪魁祸首不是模型“算不过来”,而是两个被初学者忽略的现实:第一,自回归解码 每吐一个新词,都要回头看前面所有词的 自注意力,为了不每次把整篇前文重算一遍,我们把历史词的 Key 和 Value 存进了显存,这就是 KV Cache;第二,存下笔记之后,新的灾难接踵而至——显存被海量碎片吃光,而且每生成一个字都要把上百 GB 的权重和缓存重新搬运一遍,算力全在傻等搬运工!
类比 · 撕白纸的图书室
早期的推理引擎(静态预分配)就像一个死板的图书室管理员:只要来一位读者(一个用户请求),哪怕他可能只问一句“你好”就走,管理员也因为不知道他要写多长,直接提前给他划出一整排能放 4096 页的连续书架。结果 80% 的书架长期空着却不许别人用,新读者只能堵在门外干等——这就是高达 60%–80% 的显存碎片浪费。
更麻烦的是,处理用户输入(Prefill)和逐字吐回复(Decode)脾气完全相反:前者像大锅炒菜,算力吃满;后者像单点清汤,全耗在端盘子(显存带宽)上。把它们硬凑在同一批里(Static Batching),快写完的用户必须干等最慢那个写完才能离席,吞吐量惨不忍睹。
核心设问
怎么既能把显存碎片压到几乎为零、让不同请求还能共享公共前缀,又能把 Prefill 和 Decode 合理排班,把昂贵的 GPU 带宽和算力榨干?
02 核心直觉与生活类比
2022 到 2024 年间,LLM 推理系统爆发了一场精彩绝伦的“系统架构大改造”。核心招式其实全都能在日常生活中找到一模一样的影子。
类比 · 活页夹与目录页:PagedAttention 的顿悟
vLLM 提出的 PagedAttention(arXiv:2309.06180 ↗),直接把操作系统里成熟了半个世纪的“虚拟内存分页”搬进了 GPU 显存:
别再给每个读者提前留一整排连续书架了!把所有显存切成大小一致的活页纸(Physical Block),每张纸正好存 16 个词的 KV。读者写满一页再领一张新页,哪怕第 1 页放在 3 号柜、第 2 页放在 7 号柜也完全没关系,只要在自己手里的目录页(Block Table) 上记好“逻辑第 0 页 → 物理 3 号,逻辑第 1 页 → 物理 7 号”就行。
更妙的是写时复制(Copy-on-Write):如果 10 个用户都带着同一段 3000 字的系统提示词,大家直接在目录页里指向同一批物理活页纸,显存一份顶十份;只有写到各自问题分叉的最后一页时,才各自复印那一小页分开写。
而 SGLang 的 RadixAttention(arXiv:2312.07104 ↗)在此基础上更进一步:读者走后别急着把笔记烧掉,把用过的活页纸挂进一棵前缀树(Radix Tree) 里先留着,按“最近最少使用(LRU)”慢慢淘汰。下一位问类似开头或继续多轮对话的读者一来,直接顺着树干命中现成缓存,连 Prefill 都能省掉。
类比 · 餐厅翻台与“搭顺风车”:Continuous Batching 到 PD 分离
- Continuous Batching(Orca,OSDI 2022 ↗):以前是“一桌 8 个人全吃完才能一起翻台”,现在改成“每吃完一道菜(每个解码步)检查一次,谁先离席立刻补上新客人”,翻台率瞬间翻几倍。
- Chunked Prefill(Sarathi-Serve,arXiv:2403.02310 ↗):如果突然来个点 100 道菜的大单(超长 Prompt),直接把整桌塞进厨房会让所有正在等加菜的老客人卡死好几秒。于是厨房把大单切成每份 512 Token 的小份,顺手捎带上老客人的 Decode 小菜一起出锅,既不卡顿又填满了算力空窗。
- PD 分离(DistServe arXiv:2401.09670 ↗ / Mooncake arXiv:2407.00079 ↗):干脆把“备菜厨房(Prefill 机器)”和“出餐窗口(Decode 机器)”物理拆成两拨集群,算完的 KV Cache 通过高速网络直传过去,彼此彻底井水不犯河水。
把一次真实请求放进 vLLM / SGLang 引擎里走一遍,你能清楚看到整套机器怎么咬合:
- 请求抵达:用户发来
System Prompt (2000 词) + 问题 (100 词)。引擎先查基数树 / 前缀哈希表,发现前 2000 词的物理块已经躺在显存池里,直接把这些物理块 ID 登记到该请求的目录页(Block Table)里并把引用计数+1,瞬间省掉 95% 的首字计算! - 分块预填充(Prefill):只针对新增的 100 个问题词跑前向,按每 16 个词切一页申请空闲物理块写入 K/V,吐出第 1 个回复词。
- 迭代步连续解码(Decode):接下来的每一步,它和池子里其他几十条正在生成的请求一起打包前向;每写满当前物理块的 16 个槽位,就动态向空闲链表再领 1 块新页;一旦吐出
`<eos>`,立刻把独占物理块归还池子(公共前缀块留在缓存树中留待复用)。
03 把关键公式读成人话
规划推理集群显存,心里必须随时能手算这条 KV Cache 体积公式:
把公式读成直觉:- 最前面的 2 代表要同时存 Key 和 Value 两份笔记。
是并发请求数, 是序列长度——只要上下文翻倍或并发翻倍,显存就老老实实线性翻倍。 是模型结构决定的“单字笔记厚度”:层数越多、KV 头数越多,每个字越占地方。这也是为什么现代模型拼命用 GQA 和 MLA 把 砍小甚至低秩压缩。 是每个数字占的字节数(BF16 是 2 字节,FP8 是 1 字节)。拿 Llama-3-70B 算一笔账:单个词就要约 320 KB,32 个人同时聊 8K 长度,光笔记就要吃掉整整 80 GB 显存!
再看揭示 Decode 为什么慢的 Roofline 算术强度:
把公式读成直觉:- 分子
- 当只有 1 个用户(
)时,每搬运 1 字节数据连 1 次计算都做不到;可像 H100 这样的显卡,每搬 1 字节能算近 300 次!换句话说,99% 以上的算力都在发呆等显存带宽。 - 公式右边那个大大的
揭晓了提升吞吐的终极密码:在显存装得下的前提下,拼命把并发 Batch Size 堆大——而这正是 PagedAttention 消除碎片后带来的最大红利。
04 它在模型里怎么工作 & 与上下游的关系
KV Cache 与分页调度是整个在线推理引擎的“大动脉”:
- 上游决定“笔记有多厚”:因果自注意力 的下三角掩码保证了历史词永远看不到未来,所以算过的 K/V 一劳永逸不用改;架构层的 MQA / GQA / MLA 直接给笔记瘦身,而 旋转位置编码 RoPE 旋转后的 Key 会被直接定格写进缓存。
- 横向配合算子与压缩:分页块内的注意力计算往往与 FlashAttention / FlashDecoding 深度融合;给 KV Cache 施加 FP8 / INT8 量化 能直接把显存容量和带宽吞吐同时翻倍。
- 下游托起长文本与并行加速:没有分页显存与前缀树复用,十万字级的 长上下文服务 与高频复用的 RAG 检索增强 成本将高到不可承受;在 投机解码 中,猜错的草稿分支也需要依靠分页块表瞬间回滚释放。
05 演化对比与避坑备忘
| 架构方案 | 显存利用率 | 首字延迟 TTFT | 吐字流畅度 TPOT | 前缀复用能力 |
|---|---|---|---|---|
| 静态批处理 + 连续预分配 | 仅 20%–40% | 中 | 差(尾延迟拖累整批) | 无 |
| Continuous Batching | 中 | 中 | 中(易被长 Prefill 打断) | 无 |
| PagedAttention (vLLM) | > 95% | 中 | 优 | 块级哈希自动前缀缓存 |
| Chunked Prefill + RadixAttention | > 95% | 极优(高命中) | 极优(无毛刺卡顿) | 基数树 + LRU 自动复用 |
| PD 分离 (DistServe / Mooncake) | 高(双池独立) | 极优(独占算力) | 极优(零干扰) | 跨机分布式 KV 缓存池 |
上线推理服务时,这三条避坑指南价值千金:
- 千万别把时间戳放在 System Prompt 最开头:前缀缓存是从第 1 个 Token 开始按块哈希匹配的。只要你在提示词开头塞了一句
当前时间:12:01:05,哪怕后面几千字的系统指令一字未改,整条前缀缓存也会 100% 击穿失效!一切动态信息必须挪到提示词末尾。 - 警惕并发过高触发“抢占风暴”:当显存池被塞满,引擎不得不把部分进行中的请求踢出(丢弃 KV 以后重算,或者换出到 CPU 内存)。如果限流阈值设得太激进,系统会陷入“刚算完就被踢、踢完又重算”的死循环,有效吞吐直接腰斩。
- 吞吐和体验要分开看两张表:老板常盯总吞吐,但用户真正在意的是 TTFT(等多久蹦出第一个字) 和 TPOT(后面每个字蹦得流不流畅)。一味拉大并发会让 TPOT 超过 50ms/词,人眼就会明显感到卡顿,必须配合 Chunked Prefill 和合理的最大批大小守住延迟底线。
- 物理页大小(Block Size)不是越小越好:把一页设成 1 个词固然零内部碎片,但目录页(Block Table)暴涨、CUDA 内核寻址查表开销翻倍;设成 128 个词又会让短对话浪费半页且前缀缓存很难对齐命中。工业界长期实测的黄金平衡点通常是 16 或 32 Tokens/Block。
需要查阅完整 Roofline 推导、PD 分离细节与可运行的
PagedKVCacheManager分页显存池 PyTorch 代码?按快捷键M或点击顶部技术 Wiki即可随时切换。
大语言模型推理在表面上只是不断重复的 自回归解码 前向传播,但在生产级在线服务(LLM Serving)中,系统真正的瓶颈往往不是算力本身,而是由 KV Cache(键值缓存) 引发的显存容量墙与显存带宽墙。从基础的键值缓存到迭代级连续批处理(Continuous Batching)、分块预填充(Chunked Prefill)、PD 分离,再到借鉴操作系统虚拟内存思想的 PagedAttention(arXiv:2309.06180 ↗)与 RadixAttention(arXiv:2312.07104 ↗),现代推理引擎经历了一场围绕显存调度与算力利用率的架构革命。
直观理解
如果每次生成新词都重新阅读整篇前文并做笔记,开销会随长度平方级爆炸;KV Cache 就像把读过段落的读书笔记存进笔记本,后续只需翻阅笔记。但传统引擎要求为每个读者提前撕下几百页连续空白纸(静态预分配),导致大量纸张浪费;PagedAttention 就像改用活页夹配目录页(Block Table),纸页可以散落存放、随写随加,不同读者读到相同的公共开篇时还能直接共享同一批活页纸(Prefix Caching)。
问题动机与演进背景
在自回归推理中,模型生成第
然而,KV Cache 带来了三大工程难题:
- 显存容量爆炸与碎片化:长上下文与高并发下,KV Cache 体积极易超过模型权重本身。早期系统(如 FasterTransformer)按
max_seq_len预分配连续显存,导致内部碎片(预留未用)和外部碎片(不连续空洞)合计浪费高达 60% 至 80%。 - Prefill 与 Decode 物理特性割裂:首次处理输入提示词(Prefill)是高度并行的矩阵乘(计算受限),而逐词生成(Decode)每次只推进 1 个 Token(显存带宽受限)。静态批处理(Static Batching)必须等待同批最慢请求结束才能接纳新请求,严重拉低吞吐。
- 多轮对话与系统提示词重复计算:智能体、RAG 与多轮对话中大量请求共享数千 Token 的公共前缀,若每次都重新 Prefill 会白白耗费算力。
核心原理与数学推导
1. KV Cache 数学不变性与显存精确公式
在 因果自注意力(Causal Self-Attention) 中,第
由于下三角因果掩码屏蔽了未来信息,历史位置的隐状态
设批量大小为
以 Llama-3-70B(
2. Roofline 模型:Prefill(计算受限)vs Decode(带宽受限)
根据 Roofline 模型,硬件性能受限于峰值算力
考虑参数量为
- Prefill 阶段:同时处理
个 Token,每个权重被所有输入 Token 复用,算术强度为:
因此 Prefill 处于 Compute-Bound(计算受限) 区,GPU 算力接近打满。
- Decode 阶段:每步仅输入
个新 Token,但仍须将完整的 字节权重以及 字节缓存全部从 HBM 搬运至片上 SRAM,算术强度骤降至:
当
3. 调度演进:Continuous Batching、Chunked Prefill 与 PD 分离
- Continuous Batching(Orca 迭代级调度):放弃以整个请求序列为单位的静态组批,改为在每一个解码步(Iteration) 重新调度。一旦某条请求生成
<eos>立即释放槽位并插入新到达的请求,将整体吞吐量提升数倍至十倍以上。 - Chunked Prefill(分块预填充,Sarathi-Serve):当一个长达 16K Token 的 Prefill 请求与若干 Decode 请求混批时,漫长的 Prefill 会阻塞所有在线用户的生成,造成严重的步间延迟(ITL / TPOT)毛刺。Chunked Prefill 将长 Prompt 切分为固定大小的块(如每次 512 Token),与当前所有 Decode Token 打包进同一个前向微批中执行(Decode 搭 Prefill 顺风车,Piggybacking),既平滑了延迟又利用 Prefill 算力填满了 Decode 的算力空窗。
- PD 分离(Prefill-Decode Disaggregation,DistServe / Splitwise / Mooncake):将集群节点解耦为专门处理首字延迟(TTFT)的 Prefill 实例 与专门优化生成吞吐与步间延迟(TPOT)的 Decode 实例。Prefill 节点计算完成后,通过 NVLink 或高带宽 RDMA(如 InfiniBand)将生成的 KV Cache 直接传输至 Decode 节点,双方可独立配置最优并行策略与批大小,彻底消除相互干扰。
4. PagedAttention 与 RadixAttention
PagedAttention(vLLM) 将操作系统的虚拟内存分页机制引入 KV Cache 管理:
- 将每条请求的 KV 序列按固定长度(如每块
个 Token)切分为逻辑块(Logical Blocks); - 在 GPU 显存中预先划分出一片由等大物理块(Physical Blocks) 组成的全局 KV 显存池;
- 为每个请求维护一张轻量的 块映射表(Block Table),记录逻辑块到物理块 ID 的映射,物理块无需在显存中连续存放;
- 写时复制(Copy-on-Write, CoW):在 Beam Search 或并行多次采样(Parallel Sampling)中,多条分支共享相同的前缀物理块并维护引用计数(Reference Count),仅当某分支需要向最后一个未满物理块写入新 Token 时,才触发物理块拷贝并递增偏移,极大节省显存。
RadixAttention(SGLang) 在分页块之上进一步维护一棵基数树(Radix Tree,压缩前缀树)。即使某条请求已经结束,其 KV 物理块不会立即销毁,而是作为缓存节点保留在基数树中并采用 LRU(最近最少使用)策略淘汰。新请求到达时,系统通过树前缀匹配直接命中已缓存的系统提示词、多轮对话历史或 RAG 文档块,实现近乎零开销的 自动前缀缓存(Automatic Prefix Caching)。
算法架构与数据流图
以下架构图展示了 PagedAttention 的虚拟分页映射机制,以及在 Radix Tree 辅助下实现跨请求共享前缀物理块的工作流:
图表加载中...
复杂度与横向对比表
下表对主流推理调度与 KV Cache 内存管理架构进行系统对比:
| 维度 / 机制 | 显存利用率 | TTFT(首字延迟) | TPOT(步间延迟) | 跨请求前缀复用 | 实现复杂度 |
|---|---|---|---|---|---|
| Static Batching + 连续显存 | 极低(约 20%-40%) | 中 | 差(尾延迟拖累) | 无 | 低 |
| Continuous Batching (Orca) | 低至中 | 中(易受插队影响) | 中(易被 Prefill 打断) | 无 | 中 |
| PagedAttention (vLLM) | 极高(高于 95%) | 中 | 优 | 支持(APC 块级哈希) | 中高 |
| Chunked Prefill (Sarathi) | 极高 | 略增(分块引入微开销) | 极优(无卡顿毛刺) | 支持 | 中高 |
| RadixAttention (SGLang) | 极高 | 极优(高命中率下骤降) | 优 | 极强(基数树+LRU 缓存) | 高 |
| PD 分离 (DistServe / Mooncake) | 高(双池独立配比) | 极优(独占算力) | 极优(无 Prefill 干扰) | 支持(分布式 KV 池) | 极高(依赖高速网络) |
核心 PyTorch 参考实现
下面的 PyTorch 代码实现了一个清晰可运行的简化版 PagedAttention 显存管理器与分页注意力算子,展示了物理块池、块映射表、前缀共享引用计数以及按页 Gather 计算的完整逻辑:
python
import math
import torch
import torch.nn.functional as F
from typing import Dict, List
class PagedKVCacheManager:
"""简化版 PagedAttention 显存池与块映射表管理器(单层演示)。"""
def __init__(
self,
num_blocks: int,
block_size: int,
num_kv_heads: int,
head_dim: int,
device: str = "cpu",
):
self.block_size = block_size
self.num_kv_heads = num_kv_heads
self.head_dim = head_dim
# 物理 KV 显存池: (num_blocks, num_kv_heads, block_size, head_dim)
self.k_pool = torch.zeros(
num_blocks, num_kv_heads, block_size, head_dim, device=device
)
self.v_pool = torch.zeros_like(self.k_pool)
self.free_blocks: List[int] = list(range(num_blocks))
self.ref_counts: Dict[int, int] = {}
self.block_tables: Dict[int, List[int]] = {} # req_id -> [phys_block_ids]
self.seq_lens: Dict[int, int] = {} # req_id -> current length
def _alloc_block(self) -> int:
if not self.free_blocks:
raise RuntimeError("KV Cache 物理显存池已满,需触发抢占(Preemption)!")
bid = self.free_blocks.pop(0)
self.ref_counts[bid] = 1
return bid
def fork_prefix(self, src_req_id: int, new_req_id: int) -> None:
"""零拷贝共享前缀物理块(Copy-on-Write 基础)。"""
shared_blocks = list(self.block_tables[src_req_id])
for bid in shared_blocks:
self.ref_counts[bid] += 1
self.block_tables[new_req_id] = shared_blocks
self.seq_lens[new_req_id] = self.seq_lens[src_req_id]
def append_token(
self, req_id: int, k_new: torch.Tensor, v_new: torch.Tensor
) -> None:
"""追加单个新 Token 的 K/V,形状均为 (num_kv_heads, head_dim)。"""
if req_id not in self.block_tables:
self.block_tables[req_id] = []
self.seq_lens[req_id] = 0
pos = self.seq_lens[req_id]
block_idx = pos // self.block_size
slot_offset = pos % self.block_size
if block_idx == len(self.block_tables[req_id]):
# 跨页,分配新物理块
new_bid = self._alloc_block()
self.block_tables[req_id].append(new_bid)
else:
# 写时复制 (CoW):若当前尾块被多请求共享,则先拷贝再写入
cur_bid = self.block_tables[req_id][block_idx]
if self.ref_counts[cur_bid] > 1:
new_bid = self._alloc_block()
self.k_pool[new_bid].copy_(self.k_pool[cur_bid])
self.v_pool[new_bid].copy_(self.v_pool[cur_bid])
self.ref_counts[cur_bid] -= 1
self.block_tables[req_id][block_idx] = new_bid
target_bid = self.block_tables[req_id][block_idx]
self.k_pool[target_bid, :, slot_offset, :] = k_new
self.v_pool[target_bid, :, slot_offset, :] = v_new
self.seq_lens[req_id] += 1
def paged_decode_attention(self, req_id: int, q: torch.Tensor) -> torch.Tensor:
"""
对单个请求执行分页注意力计算(真实 CUDA Kernel 会在片上直接按页融合累加)。
q: (num_kv_heads, 1, head_dim) -> 返回: (num_kv_heads, 1, head_dim)
"""
seq_len = self.seq_lens[req_id]
blocks = self.block_tables[req_id]
# 按块映射表索引物理页并拼接有效长度: (H, num_pages * B, D)
k_pages = self.k_pool[blocks].permute(1, 0, 2, 3).reshape(
self.num_kv_heads, -1, self.head_dim
)[:, :seq_len, :]
v_pages = self.v_pool[blocks].permute(1, 0, 2, 3).reshape(
self.num_kv_heads, -1, self.head_dim
)[:, :seq_len, :]
scores = torch.matmul(q, k_pages.transpose(-1, -2)) / math.sqrt(self.head_dim)
attn = F.softmax(scores, dim=-1) # (H, 1, seq_len)
return torch.matmul(attn, v_pages) # (H, 1, D)
if __name__ == "__main__":
H, D, B_SIZE = 4, 16, 4
mgr = PagedKVCacheManager(num_blocks=16, block_size=B_SIZE, num_kv_heads=H, head_dim=D)
# 请求 0 写入 5 个公共前缀 Token(占满 Block 0 并写入 Block 1 的第 0 槽)
for _ in range(5):
mgr.append_token(0, torch.randn(H, D), torch.randn(H, D))
# 请求 1 零拷贝复刻请求 0 的前缀,随后写入各自独立的新 Token(自动触发尾块 CoW)
mgr.fork_prefix(src_req_id=0, new_req_id=1)
mgr.append_token(1, torch.randn(H, D), torch.randn(H, D))
print("Req 0 block table:", mgr.block_tables[0], "len:", mgr.seq_lens[0])
print("Req 1 block table:", mgr.block_tables[1], "len:", mgr.seq_lens[1])
q_cur = torch.randn(H, 1, D)
out = mgr.paged_decode_attention(1, q_cur)
print("Paged decode output shape:", tuple(out.shape))工程实践与常见陷阱
工程实践
- Block Size 的权衡选择:物理页大小(典型取值为 16 或 32 Token)需要在碎片与内核访存效率之间折中。块太小会导致 Block Table 查表与 CUDA 线程块寻址开销偏大;块太大则会增加每条请求最后一个未满块的内部碎片并降低前缀缓存的命中粒度。
- KV Cache 量化(FP8 / INT8):因为 Decode 阶段严重受限于显存带宽,通过 模型量化 将 KV Cache 压缩至 FP8(E4M3)不仅使可并发序列数翻倍,还能直接减半 HBM 访存字节数,几乎线性地提升 长上下文 Decode 吞吐,且在合理校准下精度损失微乎其微。
- 结合 MLA 与 GQA 架构级瘦身:如 DeepSeek 系列的 MLA(Multi-head Latent Attention)与 GQA 将 KV 投影至低维潜空间缓存,配合 PagedAttention 与 FlashAttention 可将单 Token 缓存压至标准 MHA 的 5% 至 10% 以下,同时也能与 投机解码 的树验证与回滚无缝协同。
常见陷阱
- 显存耗尽时的抢占风暴(Preemption Thrashing):在线流量突发时,若所有活跃请求都在增长直至物理块池耗尽,引擎必须抢占部分低优先级请求,选择 Recompute(丢弃其 KV 待空闲重算) 或 Swap(换出至 CPU 内存)。若并发上限设置过高,会频繁触发换入换出,导致系统有效吞吐断崖式下跌。
- 过度追求高吞吐而忽视 SLA 延迟指标:生产服务必须同时监控 TTFT(Time To First Token) 与 TPOT / ITL(Time Per Output Token)。单纯拉大 Batch Size 会让 TPOT 超过人类阅读舒适阈值(如大于 50 ms/token),应结合 Chunked Prefill 预算与动态批大小上限做精细限流。
- Prefix Caching 的块边界对齐问题:基于固定块哈希的前缀缓存要求公共前缀精确对齐到 Block Size 的整数倍边界;若提示词开头轻微插入动态时间戳(如
Current time: 12:01:05),会彻底击穿整条序列的前缀缓存命中率!动态信息务必放在提示词末尾。
延伸阅读与参考论文
- Yu, G. I., Jeong, J. S., Kim, G. W., Kim, S., & Chun, B. G. (2022). Orca: A Distributed Serving System for Transformer-Based Generative Models. OSDI 2022 ↗(提出迭代级连续批处理 Continuous Batching)
- Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J., Zhang, H., & Stoica, I. (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention. SOSP 2023. arXiv:2309.06180 ↗(vLLM 奠基论文,提出 PagedAttention)
- Agrawal, A., et al. (2024). Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi-Serve. OSDI 2024. arXiv:2403.02310 ↗(提出 Chunked Prefill 与 Stall-Free Batching)
- Zhong, Y., et al. (2024). DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving. OSDI 2024. arXiv:2401.09670 ↗(系统提出 PD 分离架构与 Goodput 优化)
- Zheng, L., et al. (2024). SGLang: Efficient Execution of Structured Language Model Programs. NeurIPS 2024. arXiv:2312.07104 ↗(提出 RadixAttention 自动前缀树缓存)
- Qin, R., et al. (2024). Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving. FAST 2025. arXiv:2407.00079 ↗(以分布式 KV Cache 池为中心的超大规模 PD 分离服务架构)