返回专栏
· 22 分钟阅读

推理延迟、吞吐量与 TTFT、TPOT:大模型推理性能指标详解


一、为什么需要理解推理性能指标?

大模型推理性能不仅取决于模型生成答案的速度,还取决于用户需要等待多久、系统每秒能够处理多少请求,以及并发增加时服务能否保持稳定。

例如,两个模型服务可能表现完全不同:

  • 服务 A:用户发送请求后 200ms 就开始返回内容,但后续每个 Token 生成需要 100ms。
  • 服务 B:用户需要等待 1s 才看到第一个 Token,但之后每个 Token 只需要 20ms。

如果用户只需要简单问答,服务 A 可能体验更好;如果用户需要生成长篇内容,服务 B 可能更有优势。

因此,不能只用一个数字评价大模型推理性能。

通常需要关注以下指标:

指标 英文 含义 主要衡量对象
推理延迟 Latency 一次请求从发出到完成的耗时 单请求响应速度
首 Token 延迟 TTFT 从请求发出到第一个 Token 返回的时间 首次响应速度
Token 间延迟 TPOT 生成过程中相邻 Token 的平均时间间隔 持续生成速度
吞吐量 Throughput 单位时间处理的数据量或请求量 系统处理能力
请求吞吐量 Request Throughput 单位时间完成的请求数量 请求处理能力
Token 吞吐量 Token Throughput 单位时间生成的 Token 数量 Token 处理能力
端到端延迟 E2E Latency 从请求发出到完整响应结束的时间 完整交互体验

其中,TTFT 和 TPOT 是理解大模型流式推理性能的两个关键指标。

二、推理延迟 Latency

2.1 什么是推理延迟?

推理延迟(Inference Latency)是指模型服务处理一次推理请求所消耗的时间。

在完整的在线推理系统中,延迟通常不只是模型计算时间,还包括请求传输、排队、预处理、模型执行和响应传输等环节。

可以将一次请求的延迟拆分为:

T_{\text{total}} = T_{\text{network}} + T_{\text{queue}} + T_{\text{preprocess}} + T_{\text{inference}} + T_{\text{postprocess}} + T_{\text{return}}

其中:

  • T_{\text{network}}:请求传输和网络通信时间。
  • T_{\text{queue}}:请求在服务端等待调度的时间。
  • T_{\text{preprocess}}:Tokenizer、输入校验、模板拼接等预处理时间。
  • T_{\text{inference}}:模型执行时间。
  • T_{\text{postprocess}}:结果解析、后处理和格式化时间。
  • T_{\text{return}}:响应传输到客户端的时间。

实际部署中,还可能存在鉴权、限流、缓存查询、工具调用和多模型路由等额外耗时。

2.2 推理延迟的组成

以一次典型的大模型请求为例:

flowchart TD
    A["客户端发送请求"] --> B["网络接入"]
    B --> C["请求排队与调度"]
    C --> D["输入预处理"]
    D --> E["模型 Prefill"]
    E --> F["模型 Decode"]
    F --> G["结果后处理"]
    G --> H["响应返回"]
    H --> I["请求完成"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意,流式响应场景下,响应返回并不一定发生在模型全部生成完成之后。

模型生成第一个 Token 后,就可以将其发送给客户端。之后模型继续生成 Token,并逐步返回内容。

因此,流式推理需要进一步拆分为 TTFT、TPOT 和端到端延迟。

2.3 平均延迟与百分位延迟

平均延迟(Average Latency)是所有请求延迟的算术平均值:

T_{\text{avg}}=\frac{1}{N}\sum_{i=1}^{N}T_i

其中:

  • N:请求数量。
  • T_i:第 i 个请求的延迟。

但是,平均值容易掩盖长尾请求。

例如:

请求 延迟
请求 1 100ms
请求 2 120ms
请求 3 130ms
请求 4 150ms
请求 5 2000ms

平均延迟为 500ms,但大部分请求实际上在 200ms 内完成。

因此,生产环境通常还会关注百分位延迟:

  • P50:50% 的请求延迟不超过该值,也称中位数。
  • P90:90% 的请求延迟不超过该值。
  • P95:95% 的请求延迟不超过该值。
  • P99:99% 的请求延迟不超过该值。
  • P99.9:99.9% 的请求延迟不超过该值。

例如:

指标 延迟
P50 180ms
P90 350ms
P95 500ms
P99 1200ms

这意味着系统的典型请求表现不错,但仍有少量请求需要等待较长时间。

工程实践: 对在线服务而言,P95 和 P99 往往比平均延迟更能反映真实用户体验。

三、TTFT:首 Token 延迟

3.1 什么是 TTFT?

TTFT(Time To First Token)是指从用户发出请求,到模型返回第一个生成 Token 所经历的时间。

它主要衡量用户开始看到模型响应之前需要等待多久。

TTFT=T_{\text{first token}}-T_{\text{request start}}

对于大模型服务,TTFT 通常受到以下因素影响:

  1. 请求进入系统后的排队时间。
  2. 输入 Tokenization 和预处理时间。
  3. Prefill 阶段的计算时间。
  4. 首个 Decode 步骤的计算时间。
  5. 首个 Token 的采样与传输时间。

3.2 TTFT 与 Prefill 的关系

大模型推理通常包含两个阶段:

  • Prefill:处理完整输入 Prompt,计算输入 Token 对应的隐藏状态和 KV Cache。
  • Decode:基于已有上下文,逐步生成后续 Token。

Prefill 阶段需要处理整个输入序列。

假设用户输入 2000 个 Token,模型需要完成这些 Token 的前向计算,才能开始生成第一个 Token。

因此,Prompt 越长,Prefill 的计算量通常越大,TTFT 也可能越高。

flowchart TD
    A["用户提交 Prompt"] --> B["请求排队"]
    B --> C["Tokenization 与预处理"]
    C --> D["Prefill:处理输入 Token"]
    D --> E["构建 KV Cache"]
    E --> F["执行首个 Decode 步骤"]
    F --> G["生成第一个 Token"]
    G --> H["返回首 Token"]
    H --> I["TTFT 结束"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

严格来说,TTFT 计时的起点和终点需要在压测工具中统一定义。

例如,客户端可能从发起请求开始计时,而服务端可能从请求进入推理引擎开始计时。两者得到的 TTFT 不一定相同。

3.3 影响 TTFT 的主要因素

因素 影响机制 优化方向
Prompt 长度 输入 Token 越多,Prefill 工作量通常越大 缩短上下文、压缩 Prompt
请求排队 并发请求增加,等待调度时间上升 连续批处理、合理限流
模型规模 参数量增加,计算和访存开销增加 模型优化、量化
GPU 算力 Prefill 计算受硬件性能限制 使用更高性能 GPU
KV Cache 分配 显存紧张可能导致等待或抢占 优化显存管理
Prefill 调度 大型 Prefill 任务可能影响其他请求 Chunked Prefill
网络传输 首 Token 返回受到网络和服务链路影响 优化网络与响应链路

3.4 TTFT 优化的重点

TTFT 优化不等于单纯提升 Decode 速度。

因为 TTFT 的主要计算成本往往集中在请求排队和 Prefill 阶段。

常见优化方式包括:

  • Prompt 压缩:减少无效上下文和重复内容。
  • Prefix Caching:复用相同前缀的 KV Cache,减少重复 Prefill。
  • Chunked Prefill:将长 Prompt 拆分为多个计算块,避免单个长 Prefill 长时间占用 GPU。
  • Continuous Batching:动态调度请求,减少等待时间。
  • 量化与高效 Kernel:降低模型计算和访存成本。
  • 请求优先级调度:对交互式请求提供更低的等待时间。
  • 负载均衡:避免请求集中在少数 GPU 实例。

需要注意,Prefix Caching 只有在前缀能够匹配且缓存仍然可用时才能带来收益;它并不意味着所有 Prompt 都可以跳过 Prefill。

四、TPOT:每个输出 Token 的生成时间

4.1 什么是 TPOT?

TPOT(Time Per Output Token)表示模型生成输出 Token 时,平均每个 Token 所需要的时间。

它主要衡量 Decode 阶段的持续生成速度。

常用计算方式为:

TPOT=\frac{T_{\text{decode}}}{N_{\text{output}}-1}

其中:

  • T_{\text{decode}}:首 Token 之后,到最后一个 Token 生成之间的时间。
  • N_{\text{output}}:输出 Token 数量。

这里减去 1,是因为首 Token 已经由 TTFT 覆盖,TPOT 主要计算后续 Token 之间的平均生成时间。

例如:

模型生成 101 个 Token:

  • 首 Token 延迟:500ms。
  • 从首 Token 之后到最后一个 Token 的时间:2000ms。

那么:

TPOT=\frac{2000}{101-1}=20ms

也就是说,模型平均每 20ms 生成一个后续 Token。

4.2 TPOT 与 Token 生成速度

TPOT 和每秒 Token 数量(Tokens Per Second,TPS)存在倒数关系。

对于单个请求、稳定且连续的生成过程:

TPS_{\text{generation}}\approx\frac{1000}{TPOT_{\text{ms}}}

例如:

TPOT 近似生成速度
100ms 10 Token/s
50ms 20 Token/s
25ms 40 Token/s
20ms 50 Token/s
10ms 100 Token/s

注意:这里的 TPS 是单个请求的平均生成速度,不是整个推理集群的 Token 吞吐量。

4.3 TPOT 与 Decode 阶段

Decode 阶段具有明显的自回归特征:

模型生成下一个 Token 时,需要依赖此前已经生成的 Token。

典型过程如下:

flowchart TD
    A["已有 Prompt 与 KV Cache"] --> B["Decode Step 1"]
    B --> C["生成 Token 1"]
    C --> D["更新上下文与 KV Cache"]
    D --> E["Decode Step 2"]
    E --> F["生成 Token 2"]
    F --> G["更新上下文与 KV Cache"]
    G --> H["Decode Step 3"]
    H --> I["继续生成后续 Token"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

每个 Decode Step 通常需要:

  1. 读取模型权重。
  2. 读取历史 Token 对应的 KV Cache。
  3. 执行模型前向计算。
  4. 计算下一个 Token 的概率分布。
  5. 执行采样或解码策略。
  6. 将新 Token 对应的 KV 信息写入缓存。

随着上下文不断增长,KV Cache 也会持续增长,注意力计算的访存成本可能随之上升。

4.4 影响 TPOT 的主要因素

因素 影响机制
模型参数量 参数越多,权重读取和计算成本通常越高
GPU 内存带宽 Decode 阶段经常受到权重与 KV Cache 访存限制
KV Cache 长度 上下文越长,注意力计算和缓存读取开销可能越大
并发请求数 批处理规模变化会影响单请求生成速度
Batch Size 批处理增大可能提高 GPU 利用率,也可能增加单请求等待
Attention Kernel 不同 Kernel 的访存效率和计算效率不同
量化方式 可能减少权重访存,但也引入反量化开销
调度策略 Prefill 与 Decode 的资源竞争可能影响生成间隔

4.5 TPOT 与 ITL 的区别

ITL(Inter-Token Latency)表示相邻输出 Token 之间的时间间隔。

TPOT 和 ITL 在很多性能评测中容易混用,但需要区分:

  • ITL:可以描述某一次相邻 Token 的实际时间间隔。
  • TPOT:通常描述一个请求生成阶段的平均 Token 间隔。

例如,某个请求生成 5 个 Token,时间间隔分别为:

[20, 22, 18, 40]ms

平均 TPOT 为:

TPOT=\frac{20+22+18+40}{4}=25ms

但仅观察平均值,会忽略第 4 个 Token 出现了明显延迟。

因此,评估流式生成体验时,可以同时关注平均 TPOT、P95 ITL 和 P99 ITL。

不同推理框架对 TPOT、ITL 的计时边界可能存在差异,比较数据时必须先统一定义。

五、TTFT、TPOT 与端到端延迟的关系

5.1 三者如何关联?

对于一个完整生成请求:

  • TTFT:用户等待第一个 Token 的时间。
  • TPOT:首 Token 之后,后续 Token 的平均生成时间。
  • E2E Latency:用户等待整个响应完成的总时间。

假设:

  • TTFT = 500ms。
  • 输出 Token 数量 = 100。
  • TPOT = 20ms。

则:

T_{\text{E2E}} \approx TTFT+(N_{\text{output}}-1)\times TPOT

代入:

T_{\text{E2E}} =500+99\times20 =2480ms

即整个请求大约需要 2.48 秒。

该公式适用于流式输出中 Token 生成时间的近似计算。实际系统还可能存在网络传输、输出缓冲、调度间隔和后处理开销。

5.2 不同指标对应不同优化目标

优化目标 优先关注指标 典型优化方向
用户尽快看到响应 TTFT 缓存、缩短 Prompt、降低排队
用户连续阅读更流畅 TPOT、ITL 优化 Decode、KV Cache、Kernel
完整请求尽快结束 E2E Latency 同时优化 Prefill 和 Decode
系统处理更多请求 Request Throughput 并发调度、负载均衡
系统生成更多 Token Token Throughput 批处理、GPU 利用率、量化
稳定满足服务承诺 P95、P99 限流、隔离、资源预留

一个常见误区是:只追求更低的 TPOT,却忽略 TTFT。

例如,某个系统将 Decode 优化得很快,但由于 Prefill 阶段排队严重,用户依然需要等待很长时间才能看到第一个 Token。

另一个误区是:只追求更低的 TTFT,导致系统采用过于激进的低并发调度,GPU 利用率下降,整体吞吐量也随之降低。

因此,需要根据业务场景确定指标优先级。

六、吞吐量 Throughput

6.1 什么是吞吐量?

吞吐量(Throughput)表示系统在单位时间内完成的工作量。

大模型推理中,常见吞吐量包括:

  1. Request Throughput:每秒处理或完成的请求数。
  2. Input Token Throughput:每秒处理的输入 Token 数。
  3. Output Token Throughput:每秒生成的输出 Token 数。
  4. Total Token Throughput:每秒处理的输入和输出 Token 总量。

这些指标衡量的是不同维度,不能直接互相替代。

6.2 Request Throughput

请求吞吐量通常表示单位时间内完成的请求数量:

RPS=\frac{N_{\text{completed requests}}}{T}

例如,60 秒内完成 1200 个请求:

RPS=\frac{1200}{60}=20

表示系统平均每秒完成 20 个请求。

也可以使用 QPS(Queries Per Second)描述每秒处理的查询数量。

在大模型服务中,RPS 和 QPS 常被近似使用,但应根据系统实际统计口径区分:

  • 接收请求数。
  • 成功处理请求数。
  • 完成请求数。

对于超时、失败和取消请求,是否计入吞吐量需要明确说明。

6.3 Token Throughput

Token Throughput 表示单位时间内处理或生成的 Token 数量。

输出 Token 吞吐量:

TPS_{\text{output}}= \frac{N_{\text{output tokens}}}{T}

输入 Token 吞吐量:

TPS_{\text{input}}= \frac{N_{\text{input tokens}}}{T}

总 Token 吞吐量:

TPS_{\text{total}}= \frac{N_{\text{input tokens}}+N_{\text{output tokens}}}{T}

例如,系统在 10 秒内:

  • 处理 100000 个输入 Token。
  • 生成 20000 个输出 Token。

那么:

TPS_{\text{input}}=10000
TPS_{\text{output}}=2000
TPS_{\text{total}}=12000

需要注意,输入 Token 吞吐量和输出 Token 吞吐量对应不同的计算阶段:

  • 输入 Token 吞吐量主要反映 Prefill 能力。
  • 输出 Token 吞吐量主要反映 Decode 能力。

将两者直接相加虽然可以描述总体 Token 处理规模,但不适合单独用来判断 Decode 速度。

6.4 单请求 TPS 与系统 TPS

这是性能测试中非常容易混淆的概念。

假设系统同时处理 10 个请求,每个请求平均生成 20 Token/s。

那么:

TPS_{\text{system}}\approx10\times20=200

即:

  • 单请求生成速度:20 Token/s。
  • 系统总输出吞吐量:200 Token/s。

实际系统中,各请求生成速度不一定相同,因此系统总吞吐量应通过所有请求的 Token 数量进行统计,而不是简单假设每个请求速度一致。

6.5 吞吐量与并发量

增加并发量通常可以提升 GPU 利用率。

但吞吐量并不会随着并发量无限增长。

当 GPU 算力、显存带宽、KV Cache 容量或调度能力达到瓶颈时,继续增加并发可能导致:

  • 请求排队增加。
  • TTFT 上升。
  • TPOT 上升。
  • P95、P99 延迟恶化。
  • OOM 或请求失败。
  • 系统吞吐量进入平台期,甚至下降。

典型关系可以表示为:

flowchart TD
    A["增加并发请求"] --> B["扩大批处理规模"]
    B --> C["GPU 利用率提升"]
    C --> D["系统吞吐量增长"]
    D --> E{"是否达到资源瓶颈"}
    E -->|"否"| F["继续提升吞吐量"]
    E -->|"是"| G["请求排队增加"]
    G --> H["TTFT 与 TPOT 恶化"]
    H --> I["尾延迟上升"]
    I --> J["吞吐量进入平台期或下降"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D

七、吞吐量与延迟之间的关系

7.1 吞吐量和延迟不是同一个指标

吞吐量衡量系统整体处理能力,延迟衡量单个请求的等待时间。

例如:

系统 并发请求 平均 TTFT 单请求生成速度 系统输出吞吐量
A 1 200ms 50 Token/s 50 Token/s
B 10 500ms 30 Token/s 300 Token/s
C 30 1500ms 15 Token/s 450 Token/s

从表格可以看出:

  • A 的单请求响应体验较好。
  • C 的系统整体输出吞吐量更高。
  • 但 C 的单请求体验明显变差。

因此,不能仅凭系统 TPS 判断服务体验,也不能仅凭单请求 TPOT 判断集群处理能力。

7.2 Little's Law:请求量、并发量与延迟

Little's Law(利特尔法则)是排队论中的重要关系:

L=\lambda W

其中:

  • L:系统中的平均请求数量,也可以理解为平均在途请求数。
  • \lambda:平均请求到达率。
  • W:请求在系统中的平均停留时间。

例如:

  • 每秒进入 20 个请求。
  • 平均每个请求在系统中停留 2 秒。

那么:

L=20\times2=40

系统平均需要同时容纳 40 个在途请求。

Little's Law 适用于稳定系统,并要求统计口径一致。它不是说并发数越大吞吐量就越高,而是说明请求到达率、在途请求数和平均停留时间之间存在约束关系。

7.3 延迟与吞吐量的权衡

系统优化通常存在以下关系:

调度策略 优点 潜在问题
小批次、低并发 单请求延迟较低 GPU 利用率和吞吐量可能不足
大批次、高并发 提升资源利用率和整体吞吐量 单请求延迟可能上升
动态批处理 根据请求变化调整批次 调度器实现复杂
Continuous Batching 请求可动态加入和退出 需要处理 KV Cache 和调度开销
优先级调度 保障关键请求 低优先级请求可能等待过久

合理的目标不是将某一个指标优化到极致,而是在业务约束下找到合适的性能平衡点。

八、Prefill 与 Decode 对性能指标的影响

大模型推理的两个主要阶段具有不同的计算特征,因此对性能指标的影响也不同。

8.1 Prefill 阶段

Prefill 负责处理输入 Prompt。

主要特点:

  • 一次处理多个输入 Token。
  • 具有较高的并行度。
  • 计算量通常随输入长度增加。
  • 更容易利用 GPU 的并行计算能力。
  • 主要影响 TTFT 和输入 Token 吞吐量。

8.2 Decode 阶段

Decode 负责逐 Token 生成输出。

主要特点:

  • 自回归生成,Token 之间存在依赖。
  • 每次生成通常只新增一个 Token。
  • 需要持续读取模型权重和 KV Cache。
  • 在很多推理场景下受到内存带宽限制。
  • 主要影响 TPOT 和输出 Token 吞吐量。

8.3 Prefill 与 Decode 的性能对照

维度 Prefill Decode
输入 整个 Prompt 已有上下文和最新 Token
输出 初始 KV Cache 和首个可生成结果所需状态 新 Token 和增量 KV Cache
计算模式 大规模并行 逐步自回归
常见瓶颈 GPU 计算能力 内存带宽、KV Cache 访存
主要指标 TTFT、输入 TPS TPOT、输出 TPS
优化重点 Chunked Prefill、FlashAttention KV Cache、连续批处理、量化

8.4 两个阶段之间的资源竞争

当系统同时处理大量请求时,Prefill 和 Decode 可能竞争 GPU 计算资源。

例如,一个很长的 Prompt 进入系统,可能占用较多计算资源,使正在生成内容的请求出现 Token 间隔增大。

这种情况可能造成:

  • TTFT 上升:新请求等待 Prefill 资源。
  • TPOT 上升:已有请求的 Decode 被干扰。
  • P95、P99 延迟上升:不同请求之间出现明显的性能差异。

因此,推理引擎通常需要协调 Prefill 与 Decode 的执行顺序。

常见技术包括:

  • Chunked Prefill:将长 Prompt 分块处理。
  • Continuous Batching:在每轮 Decode 后动态调度请求。
  • Prefill-Decode Disaggregation:将 Prefill 与 Decode 放在不同计算资源上执行。
  • Token Budget:限制每轮调度能够处理的 Token 数量。

九、性能优化的核心技术

9.1 Continuous Batching 连续批处理

传统静态批处理需要等待一个批次中的请求整体结束,才能进行下一批处理。

Continuous Batching 则允许请求在每轮生成之后动态加入或退出。

主要收益:

  • 请求完成后立即释放批次位置。
  • 新请求可以补充空闲位置。
  • 降低因请求长度不同造成的 GPU 空闲。
  • 提高系统整体 Token 吞吐量。

但 Continuous Batching 不代表所有请求的延迟都会降低。它的核心价值是提高资源利用率,实际 TTFT 和 TPOT 仍取决于调度策略和资源竞争。

9.2 PagedAttention 与 KV Cache 管理

KV Cache 用于保存历史 Token 的 Key 和 Value,避免每生成一个 Token 都重新计算全部历史状态。

PagedAttention 通过分块管理 KV Cache,减少连续显存分配带来的碎片问题。

它可以帮助推理引擎:

  • 动态分配 KV Cache Block。
  • 按需释放已经完成请求的缓存。
  • 提高显存利用率。
  • 支持更多并发请求。
  • 降低显存碎片带来的资源浪费。

其主要作用是优化 KV Cache 的内存管理,不应与 Continuous Batching 混为一谈。

两者通常协同使用:

  • Continuous Batching 负责请求调度。
  • PagedAttention 负责 KV Cache 内存管理。

9.3 Prefix Caching

对于重复使用相同前缀的请求,可以复用之前计算得到的 KV Cache。

例如,多个请求共享相同的系统提示词或长文档上下文时,可以减少重复 Prefill 工作。

主要收益:

  • 降低 TTFT。
  • 减少重复计算。
  • 提升 Prefill 吞吐量。

需要关注缓存命中率、缓存容量、前缀匹配规则和缓存淘汰策略。