《AI Agent 技术原理与架构·模型、推理与能力边界》4.1 Prefill/Decode:TTFT 与 TPOT 的来源

一次大模型调用分两个阶段:prefill 并行读入上下文,decode 逐个生成 token。前者决定首 token 延迟 TTFT,后者决定每 token 延迟 TPOT。本节用一个可计算的延迟分解模型,说明两条负载预算如何分开设定,以及为什么“平均延迟达标”仍然可能在 p95 上失败。

以下工作负载、预算与数字均为教学假设,不构成对任何真实产品、供应商或生产系统的承诺。

用户感知到的“慢”至少有两种:一种是点了发送后迟迟没有反应,另一种是文字开始出现后一个字一个字地蹦。前者对应首 token 延迟(TTFT),后者对应每 token 延迟(TPOT)。把两者压成一个“总延迟”,会掩盖真正的瓶颈:上下文太长会拖慢 TTFT,输出太长会拖慢 TPOT,而两者的优化手段并不相同。

这一节用最简单的延迟分解模型说明 TTFT 和 TPOT 从哪里来,然后讨论三个架构问题:预算为什么要分开、平均值为什么不够、排队为什么会让 p95 失控。

两个阶段

阶段做什么并行性主要成本对应指标
Prefill读入全部输入 token,计算并缓存 KV输入内并行注意力与矩阵乘、KV 写入TTFT
Decode每次生成一个 token,读取 KV Cache逐 token 串行内存带宽、KV 读取TPOT

Prefill 像“批处理读入”:所有输入 token 可以并行计算,所以输入长度影响的是计算量,不是串行步数。Decode 像“逐字输出”:每生成一个 token 都要读一次完整的 KV Cache,步数与输出长度线性相关。Pope et al. 2023 在讨论大模型推理的扩展性时,把这两个阶段的瓶颈区分得很清楚:prefill 更偏计算密集,decode 更偏内存带宽密集。

一个常用的算术模型是:

$$
\text{TTFT} = T_{\text{queue}} + \frac{N_{\text{prefill}}}{R_{\text{prefill}}}
$$

$$
\text{Total} = \text{TTFT} + \frac{N_{\text{decode}}}{R_{\text{decode}}}
$$

其中 $R_{\text{prefill}}$ 和 $R_{\text{decode}}$ 是有效吞吐,不是硬件峰值。它们已经包含了批处理、并行策略和调度开销;用它们做预算估算可以,但不能拿去宣称硬件性能。

最小实验:三条负载的延迟分解

下面的实验把上面的公式写成一个可计算模块,并用 W1/W2/W3 的教学参数对比。它还会算一个反例 W1-heavy:输入不长,但输出很长,用来观察 TPOT 如何把总延迟推过预算。

# file: agp_lab/latency.py | write
# tier: 2
# verify: python3 -m unittest tests.test_latency
"""Prefill/Decode 的延迟分解:TTFT、TPOT 与预算判定。"""
from __future__ import annotations

from dataclasses import dataclass


@dataclass(frozen=True)
class Config:
    name: str
    prefill_tokens: int
    decode_tokens: int
    prefill_rate: float
    decode_rate: float
    queue_s: float
    budget_s: float


def ttft(prefill_tokens: int, prefill_rate: float, queue_s: float = 0.0) -> float:
    if prefill_rate <= 0 or queue_s < 0:
        raise ValueError("prefill_rate 必须为正,queue_s 不能为负")
    return queue_s + prefill_tokens / prefill_rate


def tpot(decode_rate: float) -> float:
    if decode_rate <= 0:
        raise ValueError("decode_rate 必须为正")
    return 1.0 / decode_rate


def total_latency(
    prefill_tokens: int,
    decode_tokens: int,
    prefill_rate: float,
    decode_rate: float,
    queue_s: float = 0.0,
) -> float:
    return ttft(prefill_tokens, prefill_rate, queue_s) + decode_tokens * tpot(decode_rate)


CONFIGS = (
    Config("W1", 3000, 200, 1500, 60, 0.2, 8),
    Config("W2", 20000, 4000, 5000, 80, 0.5, 300),
    Config("W3", 2000, 100, 1000, 50, 0.1, 60),
    Config("W1-heavy", 3000, 800, 1500, 60, 0.2, 8),
)


if __name__ == "__main__":
    print("config    ttft_s  tpot_ms  total_s  budget  verdict")
    for config in CONFIGS:
        first = ttft(config.prefill_tokens, config.prefill_rate, config.queue_s)
        per_token = tpot(config.decode_rate)
        total = total_latency(
            config.prefill_tokens,
            config.decode_tokens,
            config.prefill_rate,
            config.decode_rate,
            config.queue_s,
        )
        verdict = "pass" if total <= config.budget_s else "fail"
        print(f"{config.name:<9} {first:>6.2f} {per_token * 1000:>8.1f} "
              f"{total:>8.2f} {config.budget_s:>7}  {verdict}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.latency

输出:

config    ttft_s  tpot_ms  total_s  budget  verdict
W1          2.20     16.7     5.53       8  pass
W2          4.50     12.5    54.50     300  pass
W3          2.10     20.0     4.10      60  pass
W1-heavy    2.20     16.7    15.53       8  fail

W1 的 TTFT 是 2.20 秒,总延迟 5.53 秒,低于 8 秒预算。W1-heavy 的 TTFT 完全一样,但因为输出从 200 token 增加到 800 token,总延迟变成 15.53 秒,超出预算接近一倍。这个对比说明:TTFT 达标不代表总延迟达标;输出长度是独立的预算变量。

W2 的总延迟 54.50 秒看起来很长,但它的预算也是 300 秒,所以通过。W3 的总延迟只有 4.10 秒,预算 60 秒,通过得更轻松;但 W3 的风险不在延迟,而在不可逆副作用,延迟预算只是必要条件。

这些数字是教学假设,不能拿去和真实供应商对比。实验的价值在于分解方式:把 TTFT、TPOT、输出长度和预算分开,才能看出哪一项是瓶颈。

平均延迟为什么不够

上面的模型算的是“平均”或“典型”延迟,生产系统关心的是 p95 和 p99。排队会让尾延迟非线性增长:当利用率接近 100% 时,少量突发请求就会让队列迅速变长。一个简单的直觉是:如果平均服务时间是 $S$,到达率是 $\lambda$,服务率是 $\mu$,系统利用率 $\rho = \lambda/\mu$,那么排队延迟大致随 $1/(1-\rho)$ 增长。$\rho$ 从 0.5 升到 0.9,排队延迟会放大数倍。

对 Agent 架构,这意味着两件事:

  1. 预算要按 p95 设定,不是按平均值。 平均 5 秒、p95 20 秒的系统,在用户体验上仍然是“经常很慢”。
  2. 并发上限要留余量。 把 GPU 利用率压到 95% 以上,尾延迟会迅速恶化;留出 20%–30% 的余量通常比“榨满”更稳。

排队模型的具体形式取决于服务架构,这里不展开。重要的是记住:TTFT 包含排队,TPOT 也可能受批处理影响;延迟预算是分布,不是标量。

架构含义

Prefill/Decode 的分解对 Agent 架构有四个直接约束:

  1. TTFT 与 TPOT 分开设预算。 流式输出场景尤其如此:用户能接受首 token 2 秒、后续每 token 50 毫秒,但不能接受首 token 10 秒。
  2. 上下文长度是 TTFT 的主要杠杆。 检索文档越多、系统提示越长,prefill 越慢;上下文预算要同时考虑质量和延迟。
  3. 输出长度是 TPOT 的主要杠杆。 要求模型“详细解释”会线性增加总延迟;W1 这类延迟敏感负载应该限制输出长度。
  4. 流式输出改变体验,不改变总成本。 流式能让用户更早看到内容,但 decode 的总 token 数不变,成本和总计算量也不变。

第 4 条经常被误解。流式输出把“等待”变成了“逐步看到”,改善了感知延迟,但没有减少 GPU 时间。如果预算按总计算量算,流式不会省钱;如果预算按用户感知算,流式很有价值。两种预算要分开记。

架构判据

判据合格的样子不合格的样子
预算分开TTFT 与 TPOT 各有 p95 目标只写“总延迟 ≤ N 秒”
长度有上限输入/输出 token 上限明确让模型自由发挥
尾延迟有监控p95/p99 与队列长度可见只看平均值
并发有余量利用率上限与降级策略明确长期跑在 95% 以上
流式有区分感知延迟与总计算量分开统计用流式掩盖总成本

这些判据里,“预算分开”是最基本的。只有把 TTFT 和 TPOT 分开,才能判断是该缩上下文还是该缩输出;压成一个总延迟,优化方向会变得模糊。

排队与尾延迟

把服务看成一个队列:请求到达率 $\lambda$,服务率 $\mu$,利用率 $\rho=\lambda/\mu$。在简单排队模型里,平均等待时间随 $\rho$ 接近 1 而快速上升。工程上不必精确建模,但要记住三条:

  1. 利用率 50% 时,队列通常很短;90% 时,少量突发就会造成明显等待。
  2. 尾延迟比平均延迟更敏感;p99 可能是平均值的数倍。
  3. 降级策略(缩短上下文、减少候选、跳过非关键工具)应该在容量规划时就设计好。

对 Agent 来说,排队不只发生在模型服务入口。工具调用、检索、审批都可能排队;端到端 TTFT 是各段排队与计算的和。

流式输出的预算

流式输出把“等待完整回答”变成“逐步看到 token”,但它不减少总计算量。两种预算要分开:

预算关注点流式是否改善
感知延迟用户多久看到第一个字是,显著改善
总计算量GPU 时间与成本否,decode token 数不变
完成时间最后一个 token 何时出现否,甚至可能略慢

如果产品指标是“用户感觉快”,流式很值得;如果指标是“单位成本”,流式不会省钱。两者不能混为一谈。

一个容量规划算例

假设单卡有效 prefill 吞吐 5000 token/s、decode 吞吐 80 token/s,目标 p95 TTFT ≤ 5 秒。忽略排队时,单请求最多可 prefill 25000 token;但还要给 decode 留算力。如果平均输出 1000 token,单请求 decode 需要 12.5 秒,显然不能串行服务。

实际规划要同时考虑并发、批处理和显存。步骤是:

  1. 用 KV 公式算单序列显存;
  2. 用显存预算算最大并发;
  3. 用并发和吞吐算排队;
  4. 用 p95 目标反推可接受的输入/输出长度。

这四步里,任何一步用平均值代替分布,都会低估尾延迟。

TTFT 与 TPOT 的优化手段

目标手段代价
降 TTFT前缀缓存、缩短输入、提高 prefill 并行缓存隔离、信息损失
降 TPOTGQA、KV 量化、更大 batch质量与显存权衡
降尾延迟预留容量、请求分级、降级资源利用率下降

优化前要先确认瓶颈在哪一段。TTFT 高但 TPOT 正常,说明问题在 prefill 或排队;TTFT 正常但 TPOT 高,说明 decode 受带宽或 batch 影响。把两类问题混在一起调,通常两边都调不好。

常见误区

  • 只报平均延迟。 平均值掩盖排队和长请求,必须报 p95/p99。
  • 把流式当降本。 流式改善感知,不减少总 token 计算。
  • 忽略输出长度。 输入相同、输出翻倍,decode 时间也翻倍。
  • 按单请求规划容量。 并发和批处理会改变实际吞吐,必须压测。

最后要强调:TTFT 和 TPOT 是分布指标,不是单次测量。用平均值做容量规划,会在流量高峰和长请求上系统性低估延迟;用 p95 或 p99 做预算,才能把排队和尾部长尾算进去。

小结

  • 一次调用分 prefill 和 decode 两个阶段:prefill 并行读入上下文,决定 TTFT;decode 逐 token 生成,决定 TPOT。
  • 算术模型 TTFT = 排队 + prefill/rate、总延迟 = TTFT + decode/rate 可用于预算估算,但 rate 是有效吞吐,不是硬件峰值。
  • TTFT 达标不代表总延迟达标;输出长度是独立变量,W1-heavy 的对比说明了这一点。
  • 生产环境要按 p95/p99 设预算;排队会让尾延迟在利用率接近饱和时非线性增长。
  • 上下文长度主要影响 TTFT,输出长度主要影响 TPOT;两者的优化手段不同。
  • 流式输出改善感知延迟,但不减少总计算量;两种预算要分开统计。

阅读导航:上一节:3.3 残差、归一化与深层信息流 · 下一节:4.2 KV Cache:显存、批处理与并发上限 。

常见错误与边界

  1. 把 TTFT 和 TPOT 压成一个总延迟。 两者瓶颈不同;不分开就无法判断该缩上下文还是缩输出。
  2. 用平均值做容量规划。 排队让尾延迟非线性增长;预算要按 p95/p99 设定。
  3. 把有效吞吐当硬件峰值。 实验里的 rate 已包含批处理和调度开销,不能用于宣称硬件性能。
  4. 忽略输出长度。 输入不变、输出变长,总延迟会线性增加;W1-heavy 就是反例。
  5. 长期跑在高利用率。 利用率接近饱和时,少量突发就会让队列失控;需要留余量。
  6. 用流式掩盖总成本。 流式改善感知延迟,但 decode 的 token 数和 GPU 时间不变。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图