罗罗编程学习记录
本页内容 展开查看

10.8.3 批处理、并发与吞吐/延迟权衡

所属:全栈开发面试题库 / 10 AI 应用开发:LLM 与 Agent / 10.8 推理部署与本地化

覆盖范围

  • TTFT、TPOT、吞吐的定义与测量
  • 批处理大小与延迟的关系
  • 吞吐与延迟的权衡曲线
  • 调度策略对 SLA 的影响
  • 限流与排队策略
  • 容量规划与压测方法

高频题速览

编号 题目 难度 频率
10.8.3-001 TTFT 和 TPOT 分别由什么决定? 基础 ★★★★★
10.8.3-002 吞吐和延迟是什么关系? 进阶 ★★★★
10.8.3-003 批处理越大越好吗? 基础 ★★★★
10.8.3-004 怎么设计限流策略? 进阶 ★★★
10.8.3-005 如何做容量规划? 进阶 ★★★★
10.8.3-006 压测要测哪些指标? 基础 ★★★
10.8.3-007 P99 延迟怎么优化? 进阶 ★★★★
10.8.3-008 长请求和短请求怎么调度? 高级 ★★★

10.8.3-001 TTFT 和 TPOT 分别由什么决定?

频率 ★★★★★ | 难度 基础

一句话结论

TTFT(首 token 延迟)由排队等待、prefill 计算、输入长度决定;TPOT(每 token 输出延迟)由 decode 每步计算、批次大小、显存带宽决定;总响应时间 ≈ TTFT + 输出长度 × TPOT。

概念解释

  • TTFT:从请求发起到第一个输出 token 的时间,用户感受为"等多久开始回答"。
  • TPOT:相邻两个输出 token 之间的平均间隔,用户感受为"回答流不流畅"。
  • 端到端延迟:TTFT + 输出 token 数 × TPOT。
  • P99 延迟:99% 的请求在此时间内完成,是 SLA 的核心指标。

原理流程

  1. 请求进入排队队列。
  2. 排队等待调度器分配批次。
  3. Prefill:编码完整 prompt,计算第一个 token。
  4. 进入 decode:每步生成一个 token。
  5. TTFT = 排队 + prefill 时间。
  6. TPOT = 每步 decode 平均时间。

代码 / 示例

延迟分解:
  总响应时间 = 排队时间 + TTFT + n_out × TPOT

  TTFT 影响因素:
    - 排队: 并发数, 队列长度
    - prefill: 输入长度, 模型大小, GPU 算力
    - 前缀缓存命中: 命中则跳过重复 prefill

  TPOT 影响因素:
    - 批次大小: 批次越大, 每步越慢
    - 显存带宽: 读取权重和 KV 的带宽
    - 输出长度: 不影响每步, 但影响总时间

常见误区

  • 误区:响应慢就是模型大;正解:要分解 TTFT 和 TPOT,排队和 prefill 可能才是瓶颈。
  • 误区:流式输出就没有 TTFT;正解:流式只是边生成边推,首 token 前的等待仍然存在。

追问

  • Q:怎么降低 TTFT? A:减少排队、缩短输入、前缀缓存、chunked prefill、选择更快的 GPU。
  • Q:怎么降低 TPOT? A:减少批次大小、保证显存带宽、KV 量化、投机解码。

10.8.3-002 吞吐和延迟是什么关系?

频率 ★★★★ | 难度 进阶

一句话结论

吞吐和延迟是矛盾的:增大并发(批次)提升吞吐,但单请求延迟上升;需要在 SLA 约束下最大化吞吐,找到最优点,而不是无脑堆并发。

概念解释

  • 吞吐:每秒处理的请求数或 token 数。
  • 延迟:单个请求的端到端时间。
  • 权衡曲线:并发增加,吞吐上升,延迟也上升。
  • 最优点:在延迟 SLA 约束下,吞吐最大的并发数。

原理流程

  1. 并发 = 1:吞吐低,延迟最低。
  2. 并发增加:GPU 利用率上升,吞吐上升。
  3. 并发继续增加:TPOT 开始上升(批次大,每步慢)。
  4. 到某个点:吞吐不再增加,延迟快速上升。
  5. 选 SLA 允许的最大并发,最大化吞吐。

代码 / 示例

吞吐-延迟权衡曲线 (示意):

并发   吞吐(req/s)   P99 延迟(s)
----   -----------   -----------
1      1.0           2.0
4      3.5           2.5
8      6.0           3.5
16     9.0           6.0
32     11.0          12.0
64     11.5          25.0

SLA 要求 P99 < 5s → 最大并发 12 左右, 吞吐约 8 req/s

常见误区

  • 误区:吞吐越高越好;正解:如果延迟 SLA 是 P99 < 5s,超过这个点的吞吐没有意义,用户体验崩溃。
  • 误区:并发和吞吐是线性关系;正解:并发到一定程度后吞吐增长放缓,因为 GPU 带宽和算力都到极限。

追问

  • Q:怎么找最优点? A:压测不同并发数,画吞吐-延迟曲线,在 SLA 线上找最大吞吐点。
  • Q:不同请求的延迟差异大怎么办? A:短请求和长请求分开调度,或者用优先级调度,保证短请求的 SLA。

10.8.3-003 批处理越大越好吗?

频率 ★★★★ | 难度 基础

一句话结论

不是。批处理大小受 KV Cache 显存限制,太大直接 OOM;同时批次越大,每步 decode 越慢,TPOT 上升;连续批处理是动态调整批次大小,不是固定大批次。

概念解释

  • 批次大小:每步前向同时处理的请求数。
  • 显存限制:批次越大,KV 占用越多,超过显存就 OOM。
  • 延迟限制:批次越大,每步计算量越大,TPOT 越高。
  • 动态调整:连续批处理每步根据 KV 容量和请求队列动态决定批次大小。

原理流程

  1. 每步前,调度器统计当前有多少活跃请求。
  2. 检查 KV 容量是否够容纳所有请求。
  3. 不够时,优先让已在 decode 的请求继续,新请求等待。
  4. 够时,组成当前批次做前向。
  5. 批次大小随时间动态变化。

代码 / 示例

批次大小的约束:
  1. 显存约束: batch × 单请求 KV ≤ KV 预算
  2. 延迟约束: batch 太大 → TPOT 上升 → SLA 不达标
  3. 计算约束: batch 太大 → GPU 算力到顶, 吞吐不增反降

最佳实践:
  - 不要手动设固定大 batch
  - 让推理引擎的调度器动态决定
  - 通过压测找到 SLA 内的最大并发

常见误区

  • 误区:静态批处理越大越好;正解:静态批处理是固定大小,要么太小浪费,要么太大 OOM;连续批处理动态调整才是最优。
  • 误区:batch size 越大模型越快;正解:batch 大了 GPU 利用率高,但单请求延迟也高,要权衡。

追问

  • Q:怎么配置最大并发? A:设置 --max-num-seqs 或类似参数,限制同时在跑的请求数,压测调到 SLA 允许的最大值。
  • Q:prefill 阶段批次也受这个限制吗? A:prefill 是计算密集型,限制因素是算力,不是 KV;通常 prefill 批次可以和 decode 批次分开调度。

10.8.3-004 怎么设计限流策略?

频率 ★★★ | 难度 进阶

一句话结论

限流策略要在保护服务不被打垮的前提下,尽量满足用户需求:常用策略有并发限制、队列排队、优先级分流、超时降级;核心是在过载时优雅降级而不是直接拒绝。

概念解释

  • 并发限制:同时处理的请求数上限,超过就排队或拒绝。
  • 队列排队:超出并发的请求排队等待,不立即拒绝。
  • 优先级分流:重要用户/高价值请求优先,低优先级等待。
  • 超时降级:排队超时后返回降级响应或引导稍后重试。

原理流程

  1. 设定最大并发数(压测得出)。
  2. 新请求进来,检查当前并发。
  3. 没满:直接处理。
  4. 满了:放入等待队列。
  5. 队列也满了:拒绝或降级。
  6. 按优先级调度队列中的请求。

代码 / 示例

限流策略分层:

层 1: 并发上限 (如 32 个同时在跑)
  → 保护 GPU 不被打垮

层 2: 等待队列 (如 64 个排队)
  → 短时间过载不丢请求

层 3: 优先级
  → 付费用户优先, 免费用户降级
  → 短请求优先, 长请求单独队列

层 4: 超时降级
  → 排队超过 10s: 返回"系统繁忙, 请稍后重试"
  → 或降级到更小模型

常见误区

  • 误区:限流就是直接拒绝;正解:限流应该有排队、有优先级、有降级,尽量不丢请求。
  • 误区:限流是服务端的事;正解:客户端也要做重试和退避,配合服务端限流。

追问

  • Q:怎么防止雪崩? A:限流 + 超时 + 降级 + 客户端重试退避,多层防护,避免一个节点打垮整个系统。
  • Q:长请求怎么限流? A:长请求(如生成 2000 token)占用资源久,可以单独设限制,避免一个长请求占住资源影响短请求。

10.8.3-005 如何做容量规划?

频率 ★★★★ | 难度 进阶

一句话结论

容量规划的核心是:根据业务目标(QPS、平均输出长度、SLA),算出需要多少 GPU、什么型号、什么配置;步骤是:先压测基线 → 再按业务量推算 → 最后留余量。

概念解释

  • 业务指标:QPS、平均 prompt 长度、平均输出长度、峰值/均值比例。
  • 性能基线:压测得出每块 GPU 的吞吐、延迟、并发上限。
  • 推算:业务量 / 单 GPU 吞吐 = 需要的 GPU 数。
  • 余量:留 30%~50% 余量,应对峰值和突发。

原理流程

  1. 明确业务目标:日活、峰值 QPS、平均输出长度。
  2. 压测单块 GPU:在目标模型、目标量化下,测吞吐-延迟曲线。
  3. 推算:所需吞吐 = 峰值 QPS × 平均输出 token 数。
  4. 单 GPU 吞吐 = 压测得出的 SLA 内最大吞吐。
  5. GPU 数 = 所需吞吐 / 单 GPU 吞吐 × 余量系数。

代码 / 示例

容量规划示例:

业务目标:
  峰值 QPS: 50 req/s
  平均输出长度: 500 token
  所需吞吐: 50 × 500 = 25000 token/s

单 GPU 压测 (7B, AWQ 4bit, 24GB):
  SLA P99 < 5s 时, 吞吐约 12000 token/s

GPU 数 = 25000 / 12000 ≈ 2.1
余量 50%: 2.1 × 1.5 ≈ 3.2 → 4 块 GPU

部署方案: 2 台机器, 每台 2 块 GPU, 负载均衡

常见误区

  • 误区:按平均 QPS 算容量;正解:按峰值 QPS 算,留足够余量应对突发。
  • 误区:容量规划一次就够了;正解:业务增长后要定期重新压测和扩容。

追问

  • Q:怎么估算输出长度? A:从历史日志统计平均输出长度和分布,P90/P99 输出长度也要考虑。
  • Q:多模型混合部署怎么算? A:不同模型资源占用不同,要分别压测,加权计算总资源需求。

10.8.3-006 压测要测哪些指标?

频率 ★★★ | 难度 基础

一句话结论

压测核心指标:吞吐(req/s、token/s)、延迟(TTFT、TPOT、端到端的 P50/P90/P99)、GPU 利用率(显存、算力、带宽);压测要模拟真实请求分布(长度、并发模式)。

概念解释

  • 吞吐:每秒完成的请求数,或每秒生成的 token 数。
  • 延迟分布:P50/P90/P99,不只看平均值。
  • GPU 利用率:显存占用、SM 利用率、显存带宽。
  • 请求分布:模拟真实的 prompt 长度分布、输出长度分布、并发模式。

原理流程

  1. 准备压测脚本:模拟真实请求格式和长度分布。
  2. 从低并发开始,逐步加压。
  3. 每个并发级别稳定运行一段时间。
  4. 收集指标:吞吐、延迟、GPU 利用率。
  5. 画曲线,找 SLA 内的最大并发。

代码 / 示例

压测指标清单:

  吞吐类:
    - 请求吞吐 (req/s)
    - token 生成吞吐 (token/s)

  延迟类:
    - TTFT: P50/P90/P99
    - TPOT: P50/P90/P99
    - 端到端延迟: P50/P90/P99

  资源类:
    - GPU 显存占用 (峰值/均值)
    - GPU 算力利用率 (SM%)
    - GPU 显存带宽利用率

  稳定性:
    - 错误率
    - 超时率
    - 长时间运行是否 OOM

常见误区

  • 误区:压测只看平均值;正解:P99 延迟才是用户体验的关键,必须看分布。
  • 误区:压测用短请求就行;正解:要模拟真实的长度分布,长请求对资源占用影响大。

追问

  • Q:用什么工具压测? A:vLLM 自带 benchmark_serving.py,也可以用 Locust、k6 等通用压测工具。
  • Q:压测要跑多久? A:至少跑 10~30 分钟,看 GPU 显存是否稳定、有没有内存泄漏。

10.8.3-007 P99 延迟怎么优化?

频率 ★★★★ | 难度 进阶

一句话结论

P99 延迟优化的核心是减少长尾:找到 P99 请求为什么慢(排队?长 prefill?KV 碎片?),针对性优化;常见手段有:优先级调度、chunked prefill、前缀缓存、KV 量化、预留资源。

概念解释

  • 长尾:少数请求延迟远高于平均值,通常是因为排队、长 prompt、KV 不足。
  • 优化思路:消除或减少长尾请求的等待时间。
  • 优先级:重要请求不排队,直接处理。
  • chunked prefill:长 prefill 分块,不阻塞 decode。

原理流程

  1. 分析 P99 请求的特征:是长 prompt 还是长输出?
  2. 看排队时间占比:排队长 → 限流或扩容。
  3. 看 prefill 时间:长 → chunked prefill 或前缀缓存。
  4. 看 decode 时间:长 → KV 量化、减少批次。
  5. 针对性优化后重新压测。

代码 / 示例

P99 延迟优化手段:

  排队导致的长尾:
    - 优先级调度: 重要请求直接进批次
    - 预留资源: 留一定并发给高优先级
    - 扩容: 增加 GPU 减少排队

  Prefill 导致的长尾:
    - chunked prefill: 长输入分块编码
    - 前缀缓存: 重复系统提示不重算
    - 输入长度限制: 超长输入截断或拒绝

  Decode 导致的长尾:
    - KV 量化: 减少带宽压力
    - 减少批次大小: 每步更快
    - 投机解码: 减少 decode 步数

常见误区

  • 误区:优化 P50 就能优化 P99;正解:P99 是长尾问题,和 P50 的原因可能完全不同,要单独分析。
  • 误区:P99 慢是因为模型慢;正解:很多时候 P99 慢是因为排队和调度,不是模型本身慢。

追问

  • Q:怎么定位 P99 瓶颈? A:给每个请求打时间戳,分解排队、prefill、decode 各段时间,看 P99 慢在哪一段。
  • Q:P99 和成本怎么平衡? A:P99 要求越高,需要的资源越多,成本越高;根据业务价值设定合理的 SLA。

10.8.3-008 长请求和短请求怎么调度?

频率 ★★★ | 难度 高级

一句话结论

长请求(长输出)占用资源久,短请求(短输出)希望快速响应;混在一起调度会导致短请求被长请求拖慢;常见方案是分池调度:短请求和长请求用不同的资源池,互不影响。

概念解释

  • 短请求:输出 < 200 token,希望 TTFT 低、TPOT 低。
  • 长请求:输出 > 1000 token,占用资源久,对延迟不敏感。
  • 分池:短请求池和长请求池分开,各自有并发和配额。
  • 好处:短请求不被长请求阻塞,长请求不因为短请求频繁切换而效率低。

原理流程

  1. 请求进来,按预估输出长度分类。
  2. 短请求进入短请求池,长请求进入长请求池。
  3. 两个池独立调度,互不影响。
  4. 短请求池 SLA 要求高,并发小;长请求池吞吐优先,并发大。

代码 / 示例

分池调度方案:

  短请求池 (对话/问答, 输出 < 200 token):
    并发: 16
    SLA: P99 < 3s
    目标: 快速响应

  长请求池 (长文生成/摘要, 输出 > 1000 token):
    并发: 8
    SLA: P99 < 30s
    目标: 高吞吐

  好处:
    - 短请求不被长请求拖慢
    - 长请求批量处理效率高
    - 各自调优, 互不干扰

常见误区

  • 误区:所有请求统一调度就好;正解:混合调度会导致短请求被长请求阻塞,P99 变差。
  • 误区:分池太复杂不值得;正解:当业务有明显的长短请求分布时,分池对用户体验提升很大。

追问

  • Q:怎么预估请求是长还是短? A:按 prompt 类型或用户意图预判,比如"写一篇文章"就是长请求,"翻译这个词"就是短请求。
  • Q:分池资源怎么分配? A:按业务比例分配 GPU,短请求少分配但保证 SLA,长请求多分配追求吞吐。

待整理清单

  • [ ] 推理服务的监控告警体系
  • [ ] 自动扩缩容策略(HPA)
  • [ ] 多模型负载均衡
  • [ ] 灰度发布与版本切换
  • [ ] 压测脚本的编写与自动化