Skip to content

大模型推理服务调度系统

系统解析 TTFT/TPOT/Goodput、连续批处理、Chunked Prefill、PD 分离与缓存感知路由。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是大模型推理服务调度系统(Serving)?

把一个大模型从实验室脚本变成支撑百万并发的线上服务(如 vLLM、SGLang),拼的不仅是单次推理速度,更是如何同时服务成千上万个长短不一、随时到达的用户请求。

推理调度系统 围绕两个核心体验指标做精细博弈——首字延迟(TTFT,等多久看到第一个字) 与 吐字速度(TPOT,出字卡不卡顿):通过 Continuous Batching 随进随出、Chunked Prefill 防止长请求卡住短请求、以及 PD 分离架构(DistServe / Mooncake) 把吃算力的 Prefill 和吃带宽的 Decode 彻底拆到不同机器上各司其职。

01 问题从何而来:算子再快,调度一乱全盘皆卡 ​

很多人以为把单卡模型压到 FP8、装上 FlashAttention 就能轻松扛住线上高并发。可一旦真正上线对外提供 API,马上就会撞上一个诡异的现象:监控里 GPU 利用率忽高忽低,用户一边抱怨“发完问题半天不蹦第一个字”,另一边抱怨“吐字像挤牙膏,动不动卡顿两秒”。

罪魁祸首在于大语言模型推理的两个阶段天生性格截然相反:

  • Prefill(读题阶段):一口气吞下用户的全部提示词,几千个词并行做矩阵乘法,GPU 算力瞬间拉满,属于典型的算力吃紧型;
  • Decode(吐字阶段):每次只往外蹦 1 个新词,却得把几十 GB 的模型权重和历史 KV Cache 完整搬运一遍,算力几乎闲着,属于极端的带宽吃紧型。

更麻烦的是,用户每个回答到底要写 20 字还是 2000 字,在吐出 `<eos>` 之前谁也猜不到。早期的静态批处理(Static Batching)必须等同一批里最啰嗦的那个请求写完才能放下一批进来,大片显存就这么干等着空转。

类比 · 快餐店里“备菜大锅”和“小火慢炖”挤在同一口灶上

把一台推理服务器想象成一家生意火爆的小馆子:

  • 来了个拿着一万字 PDF 要求总结的新客人,相当于点了一桌需要猛火狂炒半小时的满汉全席(Prefill);
  • 大厅里已经在吃面的二十位老客人,每人每隔几十毫秒需要厨师添一勺汤、夹一筷子菜(Decode)。

如果只有一口锅,厨师为了先炒完那桌满汉全席,大厅里二十位老客人只能眼睁睁看着碗底见空、干等半小时(生成严重卡顿);可如果厨师只顾着给老客人添汤,新来的客人又得等到天荒地老才吃上第一口(首字超时)。

核心设问

在算力与带宽需求完全对立的两个阶段之间,调度器该如何安排请求的切分、拼批、拆池与路由,才能同时保住“首字响应快(TTFT)”和“吐字丝滑不卡顿(TPOT)”,把每一块钱的 GPU 算力都转化为有效吞吐(Goodput)?

02 核心直觉与四代演进类比 ​

推理服务调度系统的全部进化史,说白了就是围绕上面那家餐馆想出来的四套绝妙排班法:

  1. Continuous Batching(迭代级连续批处理,Orca):不再“一桌人必须同进同出”,而是把节奏细化到每炒一勺菜(每生成一个 Token) 就重新清点座位。只要某位客人吃完了,空位下一毫秒立刻补进新客人,彻底消灭木桶短板。
  2. Chunked Prefill(分块预填充,Sarathi-Serve,arXiv:2403.02310 ↗):为了防止满汉全席卡死全场,干脆规定每轮灶台只接固定份量的活(比如固定处理 512 个 Token)。先把大厅里正在吃饭的 50 位老客人每人添一勺(占 50 个名额),剩下的 462 个名额再切一小盘满汉全席的菜顺手炒掉!
类比 · 顺风车效应:为什么 Chunked Prefill 既不卡顿还能变快?

在 GPU Roofline 模型 里,Decode 每次搬运一遍庞大的模型权重,就像开着一辆 40 座大巴车去机场,车里却只坐了 3 个乘客——油钱(显存带宽)已经花出去了,37 个空座白白浪费!

Chunked Prefill 相当于让正在排队的长提示词切成小批乘客,直接坐上这趟本来就要发车的大巴(Piggybacking 搭顺风车)。大巴车耗时几乎没增加,却顺手把 Prefill 的活给干完了,老乘客的吐字节奏(ITL)也丝滑如水。

  1. PD 分离(DistServe,arXiv:2401.09670 ↗)与 KV-Centric 池化(Mooncake,arXiv:2407.00079 ↗):当餐馆开到连锁规模,干脆把后厨彻底拆分成两间房!P 房间(Prefill 节点) 专门配强算力机器猛炒前菜,做好半成品笔记(KV Cache)后,通过高速传送带(NVLink / RDMA 网络)瞬间递给D 房间(Decode 节点),让 D 房间专心致志服务上百位老客人慢慢吐字。Mooncake 更进一步,把全公司所有机器闲置的普通内存(DRAM)和固态硬盘都连成一个超级中央冰箱,专门存大家共用的老汤底(历史 KV Cache)。
类比 · 迎宾领班的“熟客记忆”:Prefix-Cache 感知路由

多轮对话和智能体(Agent)场景下,几十个请求前面往往带着一模一样的几千字系统设定或背景文档。如果网关只会傻傻地轮流派单(Round-Robin),每台机器都要把同一份背景文档从头重读一遍。

Prefix-Cache 感知路由就像一位记性极好的迎宾领班:一眼认出这位客人点的是“A 套餐”,直接把他引到刚才刚熬好 A 套餐高汤的 3 号窗口,瞬间免去重算;但如果发现 3 号窗口队伍实在排太长了,领班也会果断分流到清闲的 5 号窗口,防止把 3 号窗口压垮。

03 把关键公式读成人话 ​

衡量一套推理调度系统到底行不行,不能只看“每秒总计吐了多少字”,工业界真正盯死的是 DistServe 定义的 Goodput(有效吞吐):

Goodput=max{λ|P(TTFT≤τP∧TPOT≤τD)≥1−ϵ}

把公式读成直觉:- λ 是每秒涌进来的用户请求数;

  • TTFT≤τP 要求“首字等待不能超过红线”(比如 500 毫秒内必须出第一个字);
  • TPOT≤τD 要求“后续吐字速度不能慢于红线”(比如平均每 35 毫秒吐一个字,跟上人眼阅读速度);
  • 整个公式翻译成人话就是:在保证绝大多数用户(如 99%)既不等得焦躁、又看得不卡顿的前提下,集群每秒最多能接住多少单? 超时的请求即便算完了,对业务也是零价值!

而 PD 分离能否跑赢单机混部,核心算盘打在 KV Cache 跨机传输耗时这笔账上:

Tkv=2⋅Lin⋅Llayer⋅nkv⋅dh⋅bdtypeBWnet

把公式读成直觉:- 分子是把整段输入提示词算完后得到的 KV Cache 总字节数;分母 BWnet 是两台机器之间高速网卡(如 400Gbps RDMA)的传送带速度。

  • 只要这笔搬运时间远远小于首字红线(甚至在算第 k+1 层时同步偷偷把第 k 层的 KV 发过去,把搬运时间藏得无影无踪),拆成独立 P/D 池就能把双边硬件利用率同时榨干!

04 它在系统里怎么工作 & 与上下游的关系 ​

推理服务调度器是整套大模型线上运行的“交通指挥中心”:

05 选型对比与避坑备忘 ​

架构方案一句话核心思想最适合谁用?
Static Batching整批一起进、一起等最慢的人出仅适合固定长度离线压测,线上早已淘汰
Continuous Batching精确到每个词的动态补位,随完随走短文本、并发适中的基础在线推理
Chunked Prefill (arXiv ↗)定额预算,Decode 优先,长提示词切碎搭顺风车1–8 卡中小规模部署,兼顾性价比与低抖动
PD 分离 (arXiv ↗)备菜与上菜拆成独立机器池,高速网络传 KV有 IB/RoCE 高速网络、严控双 SLO 的大集群
KV-Centric 池化 (arXiv ↗)PD 分离 + 全集群内存/SSD 共享 KV 缓存 + 提前拒绝超长上下文、重度多轮对话与企业级 Agent 平台

线上调优推理调度器,有三个最容易踩的实战坑:

  1. 只盯总吞吐,不管尾延迟(P99 ITL):把批大小一味调大确实能让监控面板上的 Tokens/s 很好看,但一旦某个长请求插队或显存触发换出(Swap),用户侧会瞬间卡住几秒钟。上线压测一定要以 Goodput 为准绳。
  2. 盲目追求缓存命中,把热门节点打挂:如果集群里 80% 的流量都用同一个系统提示词,纯按缓存命中率路由会把所有流量全灌进同一台机器,排队时间比从头算一遍还慢!路由算法里必须给负载权重留足发言权,并在超载时果断做 Early Rejection(提前拒绝),宁可快速返回 429 也别拖死整条队列。
  3. P/D 机器比例拍脑袋乱配:RAG 问答输入长、输出短,算力大头在 Prefill;而深度思考模型(如长思维链推理)输入只有两句话、思考却要吐一万字,压力全在 Decode。务必根据真实线上输入输出比动态调整 P/D 节点配比。

想深入查看 TTFT/TPOT/Goodput 数学建模、PD 传输流水线架构图、各代调度器对比表以及可运行的 Python 调度模拟器代码?按快捷键 M 或点击顶部 技术 Wiki 即可随时切换。

单机算子优化(如 FlashAttention 与 FlashDecoding)决定了单个前向步的物理速度上限,但决定整个推理集群成本效率(美元/百万 Token)与用户体感流畅度的,则是位于引擎与集群中枢的推理服务调度系统(LLM Serving Scheduler)。由于大语言模型 自回归解码 兼具变长输出、Prefill/Decode 双阶段硬件特征割裂以及多轮对话前缀高度重叠三大特点,推理调度系统在短短数年内经历了从 Static Batching、Continuous Batching(Orca)、Chunked Prefill(Sarathi-Serve) 到 Prefill-Decode(PD)分离(DistServe) 与 KV-Centric 分布式池化(Mooncake) 的四代架构跃迁。

直观理解

把推理集群想象成一家大型现炒餐厅:顾客点菜后的“备料切菜”对应 Prefill(需要强算力一口气处理整篇提示词),而“小火慢炖、一勺勺上菜”对应 Decode(每次只吐一个词,极度依赖搬运历史笔记即 KV Cache)。如果把备料和上菜硬塞给同一批厨师,刚来一桌满汉全席就会让全大厅老顾客干等停顿;现代推理调度器要么把大单切碎插空做(Chunked Prefill),要么直接把厨房拆成独立的“备料间”与“出菜间”(PD 分离),再配一个记住哪位厨师留着老汤底的迎宾领班(Prefix-Cache 感知路由)。

起源背景与演进脉络 ​

传统深度学习服务(如图像分类 Triton Inference Server)的输入与计算图长度固定,静态攒批即可打满 GPU。而 LLM 在线服务面对截然不同的负载特性:

  1. 双阶段 GPU Roofline 冲突:Prefill 一次性并行计算整段提示词,算术强度高达数百 FLOP/Byte,处于计算受限(Compute-Bound) 区;Decode 每步仅处理 1 个新 Token,却需反复读取全部模型权重与历史 KV Cache,算术强度不足 B FLOP/Byte,深陷显存带宽受限(Memory-Bound) 区。
  2. 输出长度不可预知:请求何时生成 `<eos>` 无法预先获知,静态批处理被迫以同批最长请求为木桶短板,短请求完成后槽位持续空转。
  3. 服务质量目标(SLO)二维耦合:在线对话不仅要求首字响应快(低 TTFT),还要求后续逐字流式输出平滑不卡顿(低 TPOT)。单纯追求总吞吐量(Throughput)极易造成尾部延迟雪崩,真正衡量集群商业价值的是满足双项 SLO 约束下的有效吞吐——Goodput。

核心原理与数学推导 ​

1. TTFT、TPOT 与 Goodput 形式化定义 ​

设请求 r 在时刻 trarr 到达,输入提示词长度为 Lin(r),生成输出长度为 Lout(r),首字输出时刻为 tr(1),第 k 个输出 Token 的完成时刻为 tr(k):

  • 首字延迟(Time to First Token, TTFT):包含排队等待时间 Wr 与 Prefill 执行时间(含跨节点 KV 传输时间 Tkv):
TTFTr=tr(1)−trarr=Wr+Tprefill(Lin(r))+Tkv
  • 单字生成延迟(Time Per Output Token, TPOT) 与 步间延迟(Inter-Token Latency, ITL):
ITLr,k=tr(k)−tr(k−1),TPOTr=tr(Lout(r))−tr(1)Lout(r)−1
  • 有效吞吐(Goodput,DistServe):给定首字 SLO 阈值 τP、生成速度 SLO 阈值 τD 及达标率下限 1−ϵ(如 P90 或 P99 达标),集群最大可承载请求速率 λ 定义为:
Goodput=max{λ|P(TTFT≤τP∧TPOT≤τD)≥1−ϵ}

2. Static Batching、Continuous Batching 与 Chunked Prefill ​

  1. Static Batching(请求级调度):批内所有请求必须同步开始、同步结束。若批内输出长度服从均值 μ、最大值 Lmax,有效计算占比仅为 μ/Lmax,长尾分布下超过 60% 显存与算力槽位白白浪费。
  2. Continuous Batching(迭代级调度,Orca):以单个前向步(Iteration) 为调度粒度。只要任意请求吐出 `<eos>` 立即回收其 KV 物理块并插入新请求,消除木桶短板。但在 Prefill 优先策略下,一旦插入长提示词(如 16K Token)的 Prefill,整张 GPU 被独占数百毫秒,导致所有正在 Decode 的并发用户发生严重的 Generation Stall(生成卡顿),TPOT 瞬间击穿 SLO。
  3. Chunked Prefill(分块预填充,Sarathi-Serve):设定每步前向的总 Token 预算 Bbudget(通常取接近 GPU Roofline 拐点 I∗ 的数值,如 512–2048)。调度器首先放入当前所有 Ndec 个 Decode 请求(各占 1 Token),再将剩余预算 Bbudget−Ndec 分配给排队中的长 Prefill 请求,将其切分为固定块长 c 拼入同一微批:
Niter=Ndec+∑jcj≤Bbudget

由于 Decode 步本就需要将权重 W 从 HBM 加载一遍,搭顺风车(Piggybacking)的 Prefill 块复用同一份权重完成 GEMM,在不显著拉长单步耗时的同时填满 Tensor Core 空窗,使每步 ITL 高度均匀。

3. PD 分离架构与 Mooncake KV-Centric 池化 ​

Chunked Prefill 虽缓解了混部干扰,但在超长上下文(32K–128K)与严格双 SLO 下仍有固有瓶颈:Prefill 阶段对小延迟敏感、适合较低张量并行(TP)与小批量;Decode 阶段对显存容量与带宽敏感、需要大批量并往往采用不同并行拓扑(如大 DP+EP 或高 TP)。DistServe(arXiv:2401.09670 ↗)提出彻底的 Prefill-Decode(PD)分离:

  • Prefill 实例池(P-Node):仅运行 Prefill,按 TTFT SLO 独立搜索最优并行配置 (TPP,PPP);
  • Decode 实例池(D-Node):仅运行 Decode,按 TPOT SLO 独立配置 (TPD,PPD) 与超大并发批大小;
  • KV Cache 跨节点直传:Prefill 计算完每层或全层 KV 后,经由 NVLink 或 RDMA 高速互联(InfiniBand / RoCEv2)异步零拷贝写入 D-Node 显存。其单请求 KV 传输时延为:
Tkv=2⋅Lin⋅Llayer⋅nkv⋅dh⋅bdtypeBWnet

以采用 GQA/MLA 的模型为例,若单请求 8K Token 的 KV 为 1.2 GB,在 400 Gbps(50 GB/s)RDMA 链路上仅耗时约 24 ms,且可通过逐层流水传输(Layer-wise Pipelining) 将传输完全隐藏在后续层计算之后。

Mooncake(arXiv:2407.00079 ↗)进一步演进为 KV-Centric(以 KV 缓存为中心)分离架构:将集群各节点闲置的 CPU DRAM、NVMe SSD 与 GPU HBM 统一抽象为全局分布式 KV 缓存池(Transfer Engine),由全局调度器 Conductor 统一编排前缀复用、跨池拉取与 P→D 路由;当预测系统即将过载时,基于当前队列直接执行 Early Rejection(提前拒绝),防止系统陷入队列雪崩导致所有请求双双超时。

4. Prefix-Cache 感知路由调度(Cache-Aware Routing) ​

在多副本推理集群中,传统随机或轮询(Round-Robin)负载均衡会破坏各节点本地 RadixAttention 前缀树命中率。Cache-Aware Routing(如 SGLang Router 与 Mooncake Conductor)在网关层维护近似前缀索引,对到达请求 r 选择综合收益最高的工作节点 w∗:

w∗=arg⁡maxw∈W[α⋅MatchedPrefixLen(r,w)Lin(r)−β⋅Qw+UwkvCw]

其中 MatchedPrefixLen(r,w) 为节点 w 上命中的最长缓存前缀长度,Qw 与 Uwkv 分别反映排队负载与显存压力。当集群负载较低时优先亲和缓存命中以削减重复 Prefill;当热点节点负载超过阈值(如最大最小队列差超出平衡因子)时自动回退至最小负载节点,避免热点倾斜。

架构与数据流图 ​

以下架构图展示了融合 Prefix-Cache 感知路由、PD 分离集群与 Mooncake 分布式 KV 缓存池的现代推理服务调度全链路:

图表加载中...

相关优化模式与横向对比表 ​

调度范式典型系统批处理粒度Prefill/Decode 干扰前缀缓存复用主要瓶颈与适用场景
Static Batching早期 Triton / FasterTransformer请求级极高(同步阻塞)无长尾空转严重,仅适合离线定长压测
Continuous BatchingOrca / 早期 vLLM迭代级(Token Step)高(长 Prefill 引发 ITL 毛刺)单机 Radix/Block 复用短上下文高吞吐服务
Chunked PrefillSarathi-Serve / vLLM V1固定 Token Budget 混合微批低(Stall-Free 平滑插空)单机前缀复用中小规模集群(1–8 卡),兼顾吞吐与延迟
PD DisaggregationDistServe / SplitwiseP 池与 D 池完全解耦独立调度零干扰(物理隔离)需搭配路由亲和严格双 SLO 的中大规模在线服务(需高速 RDMA)
KV-Centric PoolingMooncake / SGLang HiCachePD 分离 + 跨机多层 KV 池零干扰 + Early Rejection 防雪崩跨节点全局前缀复用超长上下文、多轮 Agent 与重度 RAG 生产集群

核心 Python 调度模拟器实现 ​

以下轻量级离散步调度模拟器对比了 Continuous Batching(Prefill 优先) 与 Chunked Prefill(固定 Token Budget) 在长短混合负载下的 TTFT、最大 ITL 毛刺与 Goodput 表现,并内置 Prefix-Cache 感知路由评分逻辑:

python
from dataclasses import dataclass, field
from typing import Dict, List, Tuple


@dataclass
class Request:
    req_id: int
    arrival_ms: float
    prompt_tokens: int
    output_tokens: int
    prefix_key: str = ""
    prefilled: int = 0
    decoded: int = 0
    first_token_ms: float = -1.0
    last_token_ms: float = -1.0
    itl_list: List[float] = field(default_factory=list)


def step_latency_ms(total_tokens: int, num_decode_reqs: int) -> float:
    """简化的 Roofline 步耗时模型:固定权重搬运底噪 + 线性算力斜率"""
    base_mem_ms = 12.0 + 0.15 * num_decode_reqs   # 模拟 HBM 权重与 KV 读取
    compute_ms = 0.025 * max(0, total_tokens - 128)
    return base_mem_ms + compute_ms


def simulate_scheduler(
    requests: List[Request],
    mode: str = "chunked",
    token_budget: int = 512,
    slo_ttft_ms: float = 400.0,
    slo_tpot_ms: float = 35.0,
) -> Dict[str, float]:
    """对比 prefill_first (传统连续批) 与 chunked (Sarathi-Serve 分块预填充)"""
    reqs = [
        Request(r.req_id, r.arrival_ms, r.prompt_tokens, r.output_tokens, r.prefix_key)
        for r in requests
    ]
    reqs.sort(key=lambda r: r.arrival_ms)

    now_ms = 0.0
    waiting: List[Request] = []
    running_decode: List[Request] = []
    finished: List[Request] = []
    idx = 0

    while idx < len(reqs) or waiting or running_decode:
        while idx < len(reqs) and reqs[idx].arrival_ms <= now_ms:
            waiting.append(reqs[idx])
            idx += 1

        if not waiting and not running_decode:
            now_ms = reqs[idx].arrival_ms
            continue

        batch_tokens = 0
        active_prefill: List[Tuple[Request, int]] = []
        active_decode: List[Request] = []

        if mode == "prefill_first" and waiting:
            # 传统 Prefill 优先:整段 Prompt 独占当前步,阻塞所有 Decode 请求
            r = waiting[0]
            chunk = r.prompt_tokens - r.prefilled
            active_prefill.append((r, chunk))
            batch_tokens = chunk
        else:
            # Chunked Prefill:优先保障全部 Decode 推进 1 Token,剩余预算切分 Prefill
            active_decode = list(running_decode)
            batch_tokens = len(active_decode)
            rem_budget = max(0, token_budget - batch_tokens)
            for r in list(waiting):
                if rem_budget <= 0:
                    break
                need = r.prompt_tokens - r.prefilled
                chunk = min(need, rem_budget)
                active_prefill.append((r, chunk))
                batch_tokens += chunk
                rem_budget -= chunk

        dt = step_latency_ms(batch_tokens, len(active_decode))
        now_ms += dt

        for r in active_decode:
            r.itl_list.append(now_ms - r.last_token_ms)
            r.last_token_ms = now_ms
            r.decoded += 1
            if r.decoded >= r.output_tokens:
                running_decode.remove(r)
                finished.append(r)

        for r, chunk in active_prefill:
            r.prefilled += chunk
            if r.prefilled >= r.prompt_tokens:
                waiting.remove(r)
                r.first_token_ms = now_ms
                r.last_token_ms = now_ms
                r.decoded = 1
                if r.decoded >= r.output_tokens:
                    finished.append(r)
                else:
                    running_decode.append(r)

    ttfts = [r.first_token_ms - r.arrival_ms for r in finished]
    tpots = [sum(r.itl_list) / max(1, len(r.itl_list)) for r in finished]
    max_itl = max((max(r.itl_list) for r in finished if r.itl_list), default=0.0)
    good = sum(1 for t1, t2 in zip(ttfts, tpots) if t1 <= slo_ttft_ms and t2 <= slo_tpot_ms)
    return {
        "avg_ttft_ms": sum(ttfts) / len(ttfts),
        "avg_tpot_ms": sum(tpots) / len(tpots),
        "max_itl_ms": max_itl,
        "slo_goodput_ratio": good / len(finished),
    }


def cache_aware_route(
    prefix_key: str,
    worker_caches: Dict[str, Dict[str, int]],
    worker_loads: Dict[str, float],
    prompt_len: int,
    alpha: float = 1.0,
    beta: float = 0.6,
) -> str:
    """Prefix-Cache 感知路由:在缓存命中收益与队列负载均衡间动态折中"""
    best_worker, best_score = "", float("-inf")
    for w, cache in worker_caches.items():
        hit_ratio = min(cache.get(prefix_key, 0), prompt_len) / max(1, prompt_len)
        score = alpha * hit_ratio - beta * worker_loads[w]
        if score > best_score:
            best_score, best_worker = score, w
    return best_worker


if __name__ == "__main__":
    workload = [
        Request(0, 0.0, 256, 40),
        Request(1, 5.0, 256, 40),
        Request(2, 60.0, 4096, 20),  # 突发长 Prompt
        Request(3, 120.0, 512, 30),
    ]
    for m in ("prefill_first", "chunked"):
        stats = simulate_scheduler(workload, mode=m, token_budget=512)
        print(f"[{m:13s}] " + ", ".join(f"{k}={v:.2f}" for k, v in stats.items()))

工程实践与常见陷阱 ​

工程实践

  1. Token Budget 的甜点区标定:在 Chunked Prefill 模式下,将 max_num_batched_tokens 设置在硬件 Roofline 拐点附近(通常 H100 上为 1024–4096,A100 上为 512–2048),过小会损失矩阵乘算力,过大则会把 ITL 拉高至超过人类阅读体感阈值(约 50 ms/Token)。
  2. PD 节点配比与动态扩缩容:P 节点与 D 节点的理想配比高度依赖业务输入/输出长度比 Lin/Lout。RAG 与代码仓库问答等长输入场景需配置更多 P 节点(如 3P:1D);而思维链推理(CoT 测试时扩展)等超长输出场景则应偏向多 D 节点(如 1P:4D),并在波峰波谷间按 Goodput 告警动态重配角色。
  3. 跨层异步传输掩盖 KV 迁移开销:在 PD 分离部署中,切忌等待全部 Transformer 层 Prefill 结束后再一次性发送数十 GB KV Cache,而应采用每算完一层即刻触发异步 RDMA Write 的逐层流水线,并优先选用 MLA 或 GQA 架构降低单 Token KV 带宽需求。

常见陷阱

  1. Cache-Aware 路由引发热点雪崩(Hot-Spot Skew):若所有使用同一热门系统提示词的请求一味粘滞到同一台命中缓存的机器,该机队列会迅速积压导致 TTFT 反而远高于重新 Prefill。生产路由必须设置过载熔断阈值,一旦负载差距超限立即分流并允许热点前缀多副本冗余缓存。
  2. 忽略队列过载保护(Early Rejection):当请求到达率持续超过集群最大处理速率时,FIFO 无限排队会让队列内几乎所有请求在轮到执行前就已违背 TTFT SLO,白白燃烧算力产生零 Goodput。必须实施预测式准入控制(Admission Control)或主动丢弃即将超时的排队请求。
  3. Chunked Prefill 下的长前缀注意力重读开销:将 32K Prompt 切成 64 个 512-Token 的块时,第 k 块不仅计算自身,还需从 HBM 重复读取前 k−1 块的 KV Cache,导致 Prefill 阶段总 KV 读流量按分块数平方增长。对于超长上下文,应适当放大分块上限或直接切换至 PD 分离架构。

参考文献 ​

  • 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. USENIX OSDI 22 ↗(提出迭代级连续批处理 Continuous Batching)
  • Kwon, W., Li, Z., Zhuang, S., et al. (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention. SOSP 2023. arXiv:2309.06180 ↗(vLLM 分页显存管理)
  • Zheng, L., Yin, L., Xie, Z., et al. (2024). SGLang: Efficient Execution of Structured Language Model Programs. NeurIPS 2024. arXiv:2312.07104 ↗(RadixAttention 自动前缀缓存与缓存感知调度)
  • Patel, P., Choukse, E., Zhang, C., et al. (2024). Splitwise: Efficient Generative LLM Inference Using Phase Splitting. ISCA 2024. arXiv:2311.18677 ↗(异构硬件上的 Prefill/Decode 相位分离)
  • Zhong, Y., Liu, S., Chen, J., et al. (2024). DistServe: Disaggregating Prefill and Decoding for Goodput-Optimized LLM Serving. OSDI 2024. arXiv:2401.09670 ↗(Goodput 建模与 PD 分离优化框架)
  • Agrawal, A., Kedia, N., Panwar, A., et al. (2024). Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi-Serve. OSDI 2024. arXiv:2403.02310 ↗(Chunked Prefill 与 Stall-Free 调度)
  • Qin, R., Li, Z., He, W., et al. (2024). Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving. FAST 2025. arXiv:2407.00079 ↗(Kimi 生产级 KV-Centric 池化调度与过载保护架构)