🏠 总目录📚 本教程 连续批处理 ← →

AI基础设施 · 17

请求补位和 KV 分块,分别解决了哪种浪费?

连续批处理填补调度空槽,PagedAttention 管理缓存块。两者可以协作,但一个块表并不等于 CPU 的整套虚拟内存机制。

读完能判断:把调度空槽与缓存映射分开,再权衡吞吐和尾延迟。

📑 本页目录(点开跳转)

17 · 连续批处理与 PagedAttention

⏱ 38 分钟 | ⭐ 手算请求补位与 KV 显存


🎯 一句话

一条聊天请求结束了,另一条还在生成,新来的请求却进不了这批。就算有了空位,新请求也要有地方放 KV。第 15 章拆过推理的两个阶段,第 16 章解释了为何要缓存旧 token 的 K 和 V。本章接着回答两个问题:下一轮该让谁上,以及它的缓存应该放在哪儿。

静态批处理短请求完工后,槽位不能补人灰格 = 无有效输出的槽位连续批处理有预算时,新请求可以补位橙色 = 中途插进来的新请求同样的 4 条槽位,比较有效输出横轴是时间步,每一格是一次前向⭐ 生成结束位置不固定,长短混跑时静态批更容易出现空槽连续批处理按迭代重新组批,收益还取决于负载与每轮耗时
看左图的灰格和右图的橙格:短请求完工后,静态批的槽位不能接新请求;连续批可以在迭代边界补位。空槽表示没有有效输出,实际会不会做填充计算取决于实现。

🐌 一、问题一:静态批处理在浪费什么

假设一张卡有两个调度槽位,每个槽位每轮最多为一个请求生成 1 个 token。长请求 A 需要 4 轮,短请求 B 只要 1 轮。第 1 轮结束时 B 已经完成,可以把结果交给用户;如果采用静态批处理(Static Batching),调度器要等 A 也完成,才能安排下一批。B 留下的空位在这期间接不了新请求。

示意中的 4 轮和 1 轮是为了算账提前写好的结果。实际请求常在遇到结束标记或达到输出上限才停止,入队时通常不知道准确输出长度。


⭐ 二、连续批处理(Continuous Batching)

如果下一轮能让新请求使用 B 的槽位,就可以一边继续 A,一边服务新请求。连续批处理(Continuous Batching)把组批的时机移到迭代边界。调度器更新完成状态与 KV 块引用,再按序列数、计算和可用 KV 空间等约束选择本轮要运行的请求。传统单 token 解码中,每个被选中的请求这一轮推进一步。Orca 论文 §3:迭代级调度

接着算 A 和 B。短请求 C 需要 2 轮,在第 2 轮前已具备解码条件。这个对照只统计 Decode,不计 Prefill,假定两种方案的每轮时长相同、KV 空间足够。

两个槽位,每格列出这一轮产生有效输出的请求
方案第 1 轮第 2 轮第 3 轮第 4 轮第 5 轮第 6 轮
静态批A、BA、空A、空A、空C、空C、空
连续批A、BA、CA、CA、空已完成
  1. 先数有效工作。A、B、C 一共输出 4+1+2=7 个 token,两种方案完成的是同一份工作。
  2. 再数可用槽位。静态批占用 6 轮,每轮 2 槽,有效槽位比例为 7÷(6×2)≈58.3%。连续批用 4 轮,有效槽位比例为 7÷(4×2)=87.5%。这里数的是调度槽位。
  3. 最后看 C 等多久。静态批到第 5 轮才让 C 解码,C 等了第 2、3、4 共 3 轮。连续批在第 2 轮就开始。这个等待从 C 可解码时算起,与从请求到达起算的首 token 延迟不同。

在上述等时假设下,每轮产出的有效 token 数从 7÷6 提到 7÷4,比例是 (7÷4)÷(7÷6)=1.5。真实系统每轮成本会随请求长度、Prefill、显存读写和调度改变,槽位比例无法直接当成 GPU 利用率或提速比。

⚠️ Prefill 和 Decode 混在一起的麻烦

结果对照

⚠️ 新请求进来要做 Prefill(算力密集、耗时长)
而在跑的请求在做 Decode(一步很快)
如果把一个 4000 token 的 Prefill 插进来,
这一步会变得很慢→所有正在 decode 的请求【都卡了一下】
TPOT 出现毛刺 💀
✅ 三种解法:
① 【分块 Prefill】(chunked prefill)⭐
把长 Prefill 切成小块,分散到多个迭代里
② 【Prefill/Decode 分离】(P/D disaggregation)⭐
用不同的 GPU 池分别做 Prefill 和 Decode
③ 限制每步的 Prefill token 预算

首 token 延迟(Time to First Token,TTFT)从请求到达到第一个输出 token,包含排队与 Prefill 等环节。每输出 token 耗时(Time per Output Token,TPOT)这里指首 token 之后的平均生成间隔。一轮长 Prefill 与 Decode 同跑时,会先拉长当轮的 token 间隔;频繁发生时也会推高 TPOT。把 Prefill 分成小块能限制一轮内的工作量;分到不同 GPU 池则把两阶段的干扰换成传输和独立排队的开销。DistServe 论文

💸 P/D 分离的那笔账:KV 要跨机搬

上面那句"分开部署"听起来是免费的午餐,它不是。

因果链

⚠️ 分开之后多了一件原本不存在的事:
Prefill 节点算完整个输入的 KV Cache
这堆 KV 必须【搬到】Decode 节点去
因为 Decode 那一步要读它

搬多少?用第 16 章的算法估算。取 Llama 3 70B 的 80 层、8 个 KV 头、每头 128 个分量,假设缓存为 BF16(每个分量 2 字节),整个逻辑 KV 都需传输,未压缩、未命中缓存。

先算数据量,再算链路时间

每 token 每层:K 和 V 各一份,2 × 8 × 128 × 2 字节=4,096 字节。

80 层共 4,096 × 80=327,680 字节/token(320 KiB/token)。4,000 个输入 token 共 327,680 × 4,000=1,310,720,000 字节≈1.31 GB。这里 1 GB=10⁹ 字节。

若跨机有效单向带宽为 25 GB/s,只计传输的时间约为 1.31 GB÷25 GB/s=0.0524 s≈52 ms;50 GB/s 时约 26 ms。真实链路还可能有排队、协议开销和计算重叠。

这里把带宽作为算账输入;不同设备和拓扑的带宽量级见附录 A。这笔时间落在哪个指标上,取决于首 token 何时发给客户端。若先完成 KV 交接才发首 token,关键路径上的传输计入 TTFT。若 Prefill 节点已先发出首 token,传输等待可能表现为首、第二个 token 之间的间隔。DistServe 论文 §2–3

所以它什么时候划算、什么时候不划算:

情况 判断 为什么
输入长、输出也长 优先评估 交接成本可能被较长的后续生成摊薄,但仍要看首 token 和首个生成间隔
超大规模、Prefill 和 Decode 各自要几十上百张卡 优先评估 两边能各自选卡型和并行度,评估省下的资源是否大于传输与调度开销
输入短(几百 token) 比较合并部署 先量固定交接开销与原来两阶段的干扰
输出短(比如只出几十个 token) 比较合并部署 后续生成少,交接开销更难摊薄
低并发 / 单机就够 先验证分块 Prefill 如果分块后已经达到服务目标,交接可能只增加成本
只有以太网 按实际带宽估算 例如有效带宽 5 GB/s 时,上例约 1.31÷5=0.262 s;快链路与传输重叠时需重算

可以先测分块 Prefill能否满足现有目标,再用同一负载比较 P/D 分离的延迟与成本。不同 GPU 或并行度是评估分离的一个理由。

💡 业界有专门做这层 KV 传输的组件(Mooncake、LMCache 这类), 核心思路都是把 KV 当成一份可以跨节点存取和复用的缓存: 传输和计算重叠(一层算完就开始传这一层)、复用已有前缀(不用重传)、 必要时经 CPU 内存中转。估算时要分别量需要发送的字节数、可用的有效带宽,以及多少传输能和计算重叠。


📄 三、PagedAttention:把虚拟内存搬过来

借的是“映射”,不是整套 OS:请求按 token 顺序看 KV,块表把逻辑块对应到可分散放置的缓存块;这样不必为整条请求找到一大段连续空间。CPU 虚拟地址、保护机制与页面置换不能由这张应用块表代替。先记住这个区别,再看原图即可。

先看一个块表。回到 A 和 B 开始解码前。假设请求 A 已缓存 7 个 token,请求 B 已缓存 3 个;每个块能放 4 个 token 的 KV。A 的块表是 [7, 3],其中两个数都是池中的物理块编号。A 的 token 位置从 0 起算,位置 6 除以 4,商是 1、余数是 2。查块表下标 1 得到物理块 3,再到这个块的偏移 2 读 K 和 V。这样查询的是原顺序里的 token,注意力仍访问所有需要的位置。

开始解码前,A 和 B 的 KV 槽位账本(假设无共享)
请求逻辑位置 → 物理块占用的槽位尾部空槽
A0–3 → 7;4–6 → 32 块 × 4 槽=8 槽8-7=1 槽
B0–2 → 21 块 × 4 槽=4 槽4-3=1 槽

一般地,L 是序列已缓存的 token 数,b 是每块的 token 槽位数。所需块数是 L÷b 向上取整,因为余下的 token 也要占一块。请求 A 是 7÷4=1.75,向上取整得到 2 块;请求 B 是 3÷4=0.75,向上取整得到 1 块。合计 3 块、12 槽,10 槽装有 KV,2 个尾部空槽仍归各自请求。

再把槽位换成字节。沿用上节的 327,680 字节/token,一个 4 槽块占 4×327,680=1,310,720 字节,3 块共 3,932,160 字节。其中有效 KV 占 10×327,680=3,276,800 字节,尾槽暂时空着 2×327,680=655,360 字节。这里只计两条序列当前占用的 KV 块空间,不含池里尚可分配的块、权重、激活和元数据。实际每张卡的字节还要按模型和切分方式计算。

把刚才的三步写成一段可运行的 Python:用 divmod 同时求商和余数来定位物理块,再逐条把长度向上取整,最后换算字节。向上取整先加块大小减 1 再做整数除法,因此已经整除的长度不会多算一块。

block_size = 4
bytes_per_token = 327_680
lengths = [7, 3]
a_block_table = [7, 3]

logical_block, offset = divmod(6, block_size)
print(a_block_table[logical_block], offset)

blocks = sum((length + block_size - 1) // block_size for length in lengths)
slots = blocks * block_size
print(blocks, slots - sum(lengths), slots * bytes_per_token)

第一行输出 3 2(物理块号、块内偏移);第二行输出 3 2 3932160(分配块数、空槽数、占用字节数)。可以把 A 的长度从 7 改到 8,观察空槽变少而总分配字节数不变。

两个彼此不相邻的 4 槽空块共 8 槽,连续分配无法给 6 个 token 找到一整段;分块分配可以拿两块,最后一块还空 2 槽。这就是外部碎片与内部碎片的差别:前者是可用空间的排列问题,后者是已分配块内部的空位。PagedAttention 论文 §3–4

深入:块映射与两种碎片(可跳过)
  1. 映射小例:教学设块大小 B=4 token,某请求已有 7 token,块表为 [7,3]。编号从 0 开始,token 6 位于逻辑块 1、块内偏移 2,因此读取缓存块 3 的对应位置。这里只算 token 槽位,不是 CPU 字节地址转换;实际张量还含层、头、dtype 等维度。
  2. 内部碎片:分给请求的块内部留空。上例分了 2×4=8 个槽,使用 7 个,尾块空 1 个;单序列按需固定块且只考虑尾块时,浪费为 0 到 B−1 个槽,而不是整块以上。
  3. 外部碎片:可用空间散成小洞,合计足够但满足不了一次连续分配。例如两个不相邻的 4 槽空洞,无法满足连续 6 槽;若池已按相同大小 4 槽分块,则可拿两个空闲块满足 6 token,尾块空 2 槽。
  4. 固定页与变长段:分页按固定大小单位映射;分段按代码、数据等逻辑区域组织,段长可不同。以 IA-32 保护模式为例:逻辑地址 selector(段选择子)+offset(段内偏移)→ 分段(经段界限/权限检查,段基址+偏移)→ 线性地址 → 启用的分页映射(保留页内偏移,检查页级权限)→ 物理地址。未启用分页时,线性地址直接作为物理地址。这里“虚拟地址”泛指进程地址空间,分页语境通常指线性地址,不能跨架构一律等同“逻辑地址”。64 位模式的分段规则不同;这条 CPU 转换链也不是 KV 块表。
  5. OS 类比到此为止:在有 MMU 的常见系统中,虚拟内存抽象物理布局,并支持按需驻留、访问保护和受控共享;页表参与 CPU 地址映射。KV 块表主要供引擎/内核定位缓存,块号不是主机物理页号,也不会自动赋予进程隔离、磁盘交换或页面置换策略。

“消除外部碎片”仅指同尺寸 KV 块池里的块分配;底层 GPU 分配器、其他张量与元数据仍有开销。图和下方的 16-token 块、利用率与倍数是特定示意/实验背景,块大小及收益依版本、模型、长度分布和调度而变,不能换算成保证的吞吐。

依据:PagedAttention 原论文 §3–4、vLLM 固定 token 块与块表、Linux 虚拟内存概念、Intel SDM Vol.3A §3.4、§5.1/5.12–5.13(地址转换、分页与段)。这是手算映射,未运行模型或 OS 内存实验。

连续分配(预留最长长度)请求1请求2请求3灰格全是预留但用不上的显存此图示意按上限预留的空槽分页(按需分配小块)012345678物理页请求105请求21268请求33逻辑上连续,物理上可以散着放和操作系统的虚拟内存分页,是同一个思想⭐ 实际长度低于预留上限时,预留空间会有空槽同尺寸块可分散放置,节省的空间可供其他请求使用兼容前缀可以共享物理块;分支改写共享块前要复制
它借用分页映射的思想:请求长度不确定时,按最长长度预留可能浪费;固定块可分散放置。这里的物理块是 KV 缓存池中的块,不等于 CPU 页表中的物理页;兼容前缀的共享还需引擎支持。

信息关系

问题(第 16 章):为每个请求预分配连续显存→没有用完的预留空间不能给其他请求
⭐ 灵感:操作系统怎么解决同样的问题?
虚拟内存分页!物理内存分成固定大小的页,
进程看到的是连续的虚拟地址,实际映射到分散的物理页

结果对照

PagedAttention:
· KV Cache 切成固定大小的【块】(block;下一框用每块 16 槽作例子)
· 每个请求有一张【块表】(block table),记录它的逻辑块→物理块的映射
· 物理块从全局池里按需分配,【不需要连续】⭐
请求A 的块表: [物理块 7, 物理块 3, 物理块 15]
请求B 的块表: [物理块 2, 物理块 9]
↑ 物理上完全分散,逻辑上连续

信息关系

⭐ 效果:
· 内部碎片:若 B=16,单序列按需固定块的尾部空槽为 0–15 token
· 外部碎片:同尺寸 KV 块池无需为一个请求找连续块;不代表整个 GPU 分配器无碎片
· KV 块利用率受长度分布、块大小和共享影响
batch 与吞吐收益须同模型、同负载、同延迟目标实测→不能由块数直接推定

⭐ 意外的收益:写时复制的共享

流程图

因为 KV Cache 现在是【按块管理 + 引用计数】的,
多个请求可以【共享物理块】:
① 前缀共享:匹配的输入前缀与缓存身份→共享那些块(第 16 章的前缀缓存)
② 并行采样:同一个 prompt 生成 n 个候选→共享 prompt 的块 ⭐
③ Beam Search:各个 beam 共享公共前缀
分支要改写尚有空槽的共享块时,先【写时复制】(Copy-on-Write)
💡 分支在满块后分歧时,各自分配后续块即可

🔗 上面 ②③ 两条都是「解码策略」的名字,这一章只把它们当负载形态用,没讲它们各自在干什么: 《大模型全景导论》06b · 解码策略。

前缀相同,具体要相同到什么程度?以 vLLM 的自动前缀缓存为例:对完整块查找可复用的 KV。缓存键含当前块的 token ID、前一块的哈希(把更早的上下文串起来)以及适用的额外标识,例如 LoRA、多模态输入或租户隔离信息;还需要在兼容的模型和缓存配置中,且块尚未被淘汰。vLLM 自动前缀缓存设计

每块 4 个 token,数字为演示用 token ID。假设参考请求的完整块仍在缓存,除表中条件外其他配置一致。
请求块 0块 1可复用什么?
参考请求1 2 3 45 6 7 8两块均已缓存
新请求,后半段变了1 2 3 45 6 9 8只匹配块 0
新请求,开头变了9 2 3 45 6 7 8两块都不匹配:块 1 的历史变了

相同文本要先经相同的输入构造与分词,才能比较 token ID。命中减少的是对既有前缀的 Prefill 重算,后续输出仍须生成。共享块可同时被多个活跃请求引用,其中一个结束不会让另一个失去这块缓存。

解码策略的区别也会改变容量账本:

① Beam Search 和「并行采样 n 个候选」看着都是 n 条路,用途完全相反: beam 是全局按累计对数概率排序取前 k,目标是「最可能的那一句」,所以 k 条 beam 常常只差一两个词; 并行采样是 n 次独立抽签,目标恰恰是「不一样的 n 个结果」。 ⚠️ 那一章的明确结论:要 n 个不同的候选就采样 n 次,别用 beam search。

② 不共享时,k 条 beam 可能各自持有一份 KV Cache,包括重复的前缀;

但块共享只能省掉公共前缀那部分,分歧之后每条 beam 的显存还是各算各的。

那一章还有一个真实的搬运事故:把翻译服务调好的 num_beams=5 原样搬到「生成营销文案」上。

🔑 这是 PagedAttention 最漂亮的地方: 同一个物理块可以存下多条序列都需要的那段 KV,避免为同一份可复用数据重复占空间。 而共享前缀在 Agent、多候选生成、树搜索里到处都是。


🧰 四、实际怎么用

下方是保留的 vLLM 配置片段。实际运行需要兼容的 GPU 和 vLLM、可访问的模型权重,并提前定义 prompts。其中 FP8 可降低 KV 数据量;能否容纳两倍并发还受权重、工作区、块数与调度限制。

from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-8B-Instruct",
    tensor_parallel_size=2,           # 张量并行(第 12 章)
    gpu_memory_utilization=0.90,      # ⭐ 留 10% 余量,调高能装更多 KV
    max_model_len=8192,               # ⭐ 别设太大,它限制请求上下文,不是为每个请求预留全部长度
    enable_prefix_caching=True,       # ⭐ 前缀缓存(第 16 章)
    kv_cache_dtype="fp8",             # ⭐ KV 量化,能开 2 倍 batch
    enable_chunked_prefill=True,      # ⭐ 避免长 prefill 造成 TPOT 毛刺
)

outs = llm.generate(prompts, SamplingParams(temperature=0.7, max_tokens=512))

四个最该调的参数:

参数 作用 调法
gpu_memory_utilization 单实例可使用的 GPU 显存比例(还包括权重、激活等) 从 0.90 起,OOM 就降 ⭐
max_model_len 最大上下文 按实际需求设,核对容量与请求上限,不等于逐请求静态预留 ⭐
max_num_seqs 每轮最多调度的序列数 吞吐/延迟的权衡旋钮
enable_chunked_prefill 分块 prefill 有长输入时比较启用前后的 TTFT 和 TPOT

📊 五、调度策略:吞吐和延迟的旋钮

第 2 轮空了一个序列槽位,为什么有时 C 还是进不来?新请求还需要足够的 KV 块,若尚未 Prefill,还要为输入 token 留本轮计算预算。即使空槽够用,这两个约束之一也可能迫使它排队。已在运行的请求若需要更多 KV 块而池已满,引擎可能暂停部分请求并回收它们的块,之后重算或从别处恢复。这叫抢占(Preemption),行为取决于实现。

看一个新场景:本轮最多处理 8 个输入位置。两个已在解码的请求各处理 1 个位置,新请求 D 还需要 Prefill 12 个位置。先让两条解码前进,本轮剩 8-2=6 个位置,D 先处理 6 个。如果下一轮的条件相同,D 再处理剩下的 12-6=6 个位置。这里的预算按本轮待处理位置数计,位置的计算成本并不保证相等;预算够用也要有 KV 空间。

对已在生成的请求,这个安排能限制一轮塞入的 Prefill 工作。对 D 来说,要等两轮才能处理完整个输入。如果源源不断的解码总把预算占满,D 就会一直等。可比较为排队任务保留部分预算、等待越久优先级越高等策略,同时记录最长等待、超时与分组尾延迟。vLLM 分块 Prefill 与抢占说明

策略 适合
FCFS(先来先服务) 优先照顾先到者;若队首任务暂时放不下,后到的短任务也可能被挡住
优先级队列 区分紧急程度;高优先级持续到达时,要检查低优先级是否长期等不到
最短作业优先 降低平均延迟(但需要预测输出长度,难)
限制 max_num_seqs ⭐ 控制 P99 延迟的候选旋钮,仍需压测排队效应

P99是延迟分布的第 99 百分位,观察的是最慢一小部分请求附近的表现。若更低的 max_num_seqs 让生成间隔变短,但更多请求在队列里等,TTFT 的 P99 可能反而变差。按第 20 章的服务目标(Service Level Objective,SLO),在同一负载下并排测 P99 TTFT、P99 TPOT、吞吐和超时率,再决定序列上限与 token 预算。


🔗 和站内其他章的关系

相关的地方 这里的位置
第 15 章 批处理提吞吐 本章是怎么在动态请求下做到 ⭐
第 15 章 Prefill/Decode 性质不同 混合调度的麻烦 + P/D 分离
第 16 章 KV 容量与碎片 PagedAttention 解决它 ⭐
第 16 章 前缀缓存 靠 PagedAttention 的块共享实现
第 20 章 SLO 调度策略的目标
《大模型全景导论》06 推理优化 PagedAttention 一节 那边只说"借鉴了虚拟内存";块表、写时复制、抢占这三件事在这里 ⭐
《模型上线之后》18 成本与容量 3 秒抖动变成 22 分钟不可用 联系:重算和排队可能彼此放大;用实际负载压测并发上限

✅ 检查点

  1. 静态批处理浪费在哪?根源是什么?
  2. 两槽示例中,静态批和连续批各用几轮?C 各等几轮?
  3. 为什么 87.5% 的有效槽位比例不能当成 GPU 利用率?
  4. Prefill 插进 Decode 批次里会造成什么问题?三种解法是什么?
  5. P/D 分离的动机是什么?
  6. P/D 分离的代价是什么?70B 模型 4000 token 的输入,要搬多少 KV?有效带宽 25 GB/s 时约要多久?
  7. 什么时候【不该】上 P/D 分离?该先做什么?
  8. PagedAttention 借鉴了什么思想?为什么尾块仍会留空?
  9. A 的 KV 增至 9 个 token、B 仍为 3 个时,共用几块?剩几槽?
  10. 为什么块 1 的 token 完全一样,块 0 不同却仍不能命中块 1?
  11. 降低并发上限后,P99 TPOT 降低,P99 TTFT 却升高。哪段时间可能增加了?
👀 答案
  1. 已完成的请求留下不能补位的槽位,新来的请求要等这一批结束。长短请求的结束轮次不同,短请求完工后不必等整批才返回。
  2. 静态批用 6 轮,C 等 3 轮;连续批用 4 轮,C 等 0 轮。结论只适用于上面的到达时刻和容量假设。
  3. 87.5% 是 7 个有效输出槽位除以 8 个可用槽位。每个槽位耗费的时间与硬件资源会随 Prefill、上下文长度等变化。
  4. 同轮 Decode 的 token 间隔可能拉长。分块 Prefill、限制每轮 Prefill 预算和 P/D 分离可以减少干扰,代价不同。
  5. 分离后两阶段可以各自安排 GPU 与并行方式,并减少同一批里的干扰。收益要和传输、排队及资源成本一起量。
  6. 327,680 字节/token × 4,000 token=1,310,720,000 字节,约 1.31 GB。1.31÷25≈0.0524 秒,即约 52 ms 的传输时间估计。
  7. 若现有分块 Prefill 已满足目标,或交接 KV 的开销吞掉了隔离收益,可继续合并部署。输入短、低并发等只能提示评估方向,结论需实测。
  8. 借的是固定块映射,同尺寸块池可分散放置。只要序列长度不是块大小的整数倍,最后一个块就有尚未写入的槽位。
  9. A 占 3 块(9÷4 向上取整),B 占 1 块,共 4 块、16 槽。有效 KV 占 9+3=12 槽,尾部共空 4 槽。
  10. 后块的 K 和 V 取决于前面的上下文。块 0 变化也改变了块 1 的前缀哈希,即使块 1 自身的 token ID 一致也不能复用。
  11. 队列等待可能增加。看首 token 延迟的分解、按请求类型的尾延迟和超时率,再判断吞吐是否值得这笔等待。

本节回顾

⚡ 走神救援

先看调度。连续批按迭代换成员,空位可以在容量和预算允许时被新请求填上。真实收益要同时看吞吐、排队与尾延迟。

再看存储。PagedAttention 用块表把逻辑位置映射到分散的 KV 块。每条序列按块向上取整,尾块可能留空;匹配的前缀可以共享。

最后看阶段干扰。分块 Prefill 用多轮处理长输入。P/D 分离用跨设备 KV 交接换隔离,是否合算取决于传输与排队时间。下一章会改变显存账本中每个数值的字节数;本章改变的是缓存怎么分配与复用。

下一节 👉 18-量化.md

条件与依据

分页主要减少 KV 预留与碎片,不降低模型本身对每个 token 的 KV 需求。原论文的利用率与 2–4 倍吞吐是指定基线和负载下的报告,不能拆成分页或连续批处理各自的通用提速比。调度仍可能排队和抢占;P/D 分离需按实际链路、并行度和传输重叠测量。

原论文

打卡记录保存在你的浏览器里,首页能看到总进度