一、为什么 AI 系统需要缓存与资源调度
传统 Web 系统的主要瓶颈通常是数据库、网络 I/O 和应用服务器。AI 系统则面临更复杂的资源约束:
- 计算成本高:模型推理、Embedding 生成、文档解析和向量检索都可能消耗大量计算资源。
- GPU 资源昂贵:GPU 显存有限,不同模型和任务对显存的需求差异很大。
- 请求差异明显:短文本问答与长上下文推理的计算量可能相差数十倍。
- 重复计算普遍:相同提示词、相同文档、相同 Embedding 可能被反复处理。
- 资源竞争严重:在线推理、批量 Embedding、RAG 索引构建和模型训练可能同时争用 GPU、CPU、内存与存储。
- 延迟目标不同:在线交互关注 TTFT 和 TPOT,离线任务更关注吞吐量和单位任务成本。
如果没有缓存,系统会不断重复执行昂贵的计算;如果没有合理调度,即使拥有大量 GPU,也可能出现部分 GPU 空闲、部分任务排队、显存不足和请求超时等问题。
缓存与资源调度解决的是两个相互关联的问题:
| 能力 | 主要目标 | 典型手段 |
|---|---|---|
| 缓存 | 减少重复计算与数据访问 | KV Cache、语义缓存、Embedding 缓存、结果缓存 |
| 资源调度 | 提高资源利用率和服务稳定性 | 队列调度、GPU 分配、并发控制、优先级调度 |
| 联合优化 | 降低整体成本与端到端延迟 | 缓存感知调度、资源隔离、动态扩缩容 |
核心思想是:能复用的计算尽量复用,必须执行的计算尽量安排在合适的资源上。
二、AI 系统中的缓存体系
AI 系统并不存在一种通用缓存。不同缓存保存的数据、生命周期、命中条件和一致性要求都不相同。
2.1 缓存的主要层次
可以按照数据距离计算节点的远近,将缓存划分为多个层次。
| 缓存层次 | 存储位置 | 典型内容 | 主要特点 |
|---|---|---|---|
| L1 | 进程内存 | 热点配置、对象、短期结果 | 延迟低,但容量有限 |
| L2 | 分布式缓存 | 查询结果、Embedding、会话状态 | 多实例共享,适合跨进程复用 |
| L3 | 本地磁盘或 NVMe | 模型权重、数据块、索引文件 | 容量较大,访问速度高于远程存储 |
| L4 | 对象存储或持久化存储 | 模型文件、数据集、历史结果 | 容量大,适合长期保存 |
典型的数据访问路径如下:
flowchart TD
A["请求到达"] --> B["查询进程内缓存"]
B --> C{"L1 命中?"}
C -->|是| H["返回缓存结果"]
C -->|否| D["查询分布式缓存"]
D --> E{"L2 命中?"}
E -->|是| I["回填 L1 并返回"]
E -->|否| F["访问本地磁盘或持久化存储"]
F --> G["执行必要的计算或加载"]
G --> J["写入缓存"]
J --> H
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#E5F0E9,stroke:#83A995,color:#315D49
style I fill:#E5F0E9,stroke:#83A995,color:#315D49
这里需要注意:不同缓存层并不一定构成严格的逐级访问链。例如,模型权重可能直接从对象存储下载到本地 NVMe,再加载到 GPU 显存;Embedding 缓存则可能直接访问 Redis 或专用向量存储。
2.2 缓存命中与缓存未命中
缓存命中(Cache Hit)表示请求所需的数据已经存在于缓存中,可以直接复用。
缓存未命中(Cache Miss)表示缓存中没有对应数据,需要访问下层存储或重新执行计算。
缓存命中率:
缓存未命中率:
例如,一段时间内有 10000 次缓存查询,其中 8500 次命中:
但高命中率不一定意味着系统性能好。
例如:
- 缓存命中的都是轻量级数据,节省的计算成本有限。
- 缓存查询本身需要访问远程服务,可能增加网络延迟。
- 缓存命中后仍然需要执行大量后续计算。
- 缓存数据过期或失效,可能导致错误结果。
因此,除了命中率,还应关注缓存节省的计算时间、请求延迟、网络开销和缓存维护成本。
2.3 缓存收益如何计算
设:
- T_c:缓存查询耗时。
- T_m:缓存未命中时重新计算的耗时。
- H:缓存命中率。
忽略其他开销时,平均请求耗时可以近似表示为:
例如:
- 缓存查询耗时为 2ms。
- 原始计算耗时为 200ms。
- 缓存命中率为 80%。
则:
相较于每次都执行 200ms 的计算,平均耗时明显降低。
不过在实际系统中,还需要计算缓存序列化、网络传输、数据回填、失效处理和并发竞争带来的额外成本。
三、AI 系统的主要缓存类型
3.1 Prompt Cache:提示词缓存
Prompt Cache 用于缓存已经处理过的提示词或相关计算结果。
在 LLM 推理中,一个请求通常包含:
- System Prompt。
- 用户输入。
- 历史对话。
- 工具定义。
- RAG 检索内容。
如果多个请求共享相同的前缀,例如相同的 System Prompt、长篇背景知识和工具定义,就可能复用已经完成的前缀计算。
需要区分两种不同机制:
应用层 Prompt 缓存
缓存完整请求或提示词对应的结果。只有请求满足相应的匹配条件,才能直接复用。
模型推理层 Prefix Cache
缓存相同 Token 前缀经过 Transformer 计算后产生的 KV 状态,使后续请求能够跳过重复的 Prefill 计算。
两者的区别:
| 对比维度 | 应用层 Prompt 缓存 | Prefix Cache |
|---|---|---|
| 缓存内容 | 请求结果或中间数据 | Transformer 的 KV 状态 |
| 复用方式 | 直接返回或复用应用数据 | 跳过部分 Prefill 计算 |
| 主要收益 | 减少完整计算 | 减少重复前缀计算 |
| 适用场景 | 重复问题、固定任务 | 共享长前缀的推理请求 |
Prefix Cache 不代表模型完全不需要推理。即使前缀命中,新的用户输入和生成阶段仍然需要计算。
3.2 KV Cache:注意力键值缓存
KV Cache 是 LLM 推理中最重要的缓存机制之一。
在 Transformer 的自注意力计算中,每个 Token 会产生 Key 和 Value:
注意力计算:
在自回归生成过程中,新 Token 需要关注之前已经生成的 Token。
如果每次生成新 Token 都重新计算历史 Token 的 Key 和 Value,就会产生大量重复计算。
KV Cache 将历史 Token 的 Key 和 Value 保存下来,后续生成时只计算新 Token 对应的 K、V,再与历史缓存进行注意力计算。
flowchart TD
A["输入 Prompt"] --> B["Prefill 阶段"]
B --> C["计算所有输入 Token 的 K 和 V"]
C --> D["保存 KV Cache"]
D --> E["Decode 阶段生成新 Token"]
E --> F["计算新 Token 的 Q、K、V"]
F --> G["追加新 K、V 到缓存"]
G --> H["使用历史 KV 计算 Attention"]
H --> I["输出下一个 Token"]
I --> J{"是否结束?"}
J -->|否| E
J -->|是| K["释放 KV Cache"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#E5F0E9,stroke:#83A995,color:#315D49
style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style K fill:#E5F0E9,stroke:#83A995,color:#315D49
KV Cache 的主要收益是避免历史 K、V 的重复计算,但也会消耗大量 GPU 显存。
假设:
- Batch Size 为 B。
- Transformer 层数为 L。
- KV Head 数量为 H_{kv}。
- 每个 Head 的维度为 D。
- 每个序列的 Token 数量为 S。
- 每个元素占用 P 字节。
忽略对齐和额外管理开销,KV Cache 的显存需求近似为:
其中的 2 表示 Key 和 Value 两部分。
例如:
- Batch Size = 1。
- Transformer 层数 = 32。
- KV Head 数量 = 8。
- Head Dimension = 128。
- 上下文长度 = 8192。
- 数据类型为 FP16,每个元素占 2 字节。
则:
约为 1GiB。
这意味着,一个长上下文请求就可能占用大量显存。并发请求越多,KV Cache 对显存的压力越大。
实际模型还可能采用 GQA、MQA、量化 KV Cache、分页管理等机制降低占用。
3.3 Prefix Cache:前缀缓存
Prefix Cache 是对 KV Cache 的进一步复用。
例如,多个请求都使用同一段系统提示词:
你是一个专业的技术助手。
请遵循以下回答规范:
1. 使用准确的技术术语。
2. 给出必要的代码示例。
3. 明确说明适用条件。
后续请求只在末尾追加不同的问题:
请求 A:解释 Redis 的持久化机制。
请求 B:解释 Kafka 的消息投递语义。
请求 C:解释 Kubernetes 的调度机制。
如果模型服务支持前缀 KV 缓存,就可以复用共同前缀对应的 KV 状态。
Prefix Cache 的命中通常依赖:
- Token 化之后的前缀一致性。
- 模型权重和模型版本一致。
- LoRA 等适配器配置兼容。
- 位置编码及相关推理参数兼容。
- 缓存块仍然存在且未被回收。
- 多租户隔离与缓存访问权限满足要求。
不能简单认为两段文本看起来相似,就一定可以复用 KV Cache。
尤其要注意:Prefix Cache 是基于模型计算状态的复用,不是语义相似度缓存。
3.4 Embedding Cache:向量缓存
Embedding 模型将文本转换为向量:
如果相同文本反复进行向量化,就可以缓存对应的 Embedding 结果。
例如:
输入文本:
Redis 是一种高性能的内存数据结构存储。
缓存结果:
[0.125, -0.328, 0.741, ...]
Embedding 缓存的 Key 不应只依赖原始文本,还应包含影响向量结果的配置:
cache_key = hash(
normalized_text
+ model_name
+ model_version
+ preprocessing_version
+ embedding_dimension
)
需要考虑:
- 不同 Embedding 模型产生的向量不能随意混用。
- 文本预处理规则变化可能使缓存失效。
- 模型升级后应区分新旧向量。
- 多语言、分块策略和归一化配置可能影响结果。
- 大规模 Embedding 缓存需要控制存储容量。
Embedding Cache 主要减少重复向量化计算,但不等于缓存向量检索结果。
3.5 Semantic Cache:语义缓存
语义缓存根据语义相似度复用历史问答结果。
例如:
历史问题:
什么是 Redis?
新问题:
Redis 是用来做什么的?
两者表达不同,但语义接近。如果历史回答仍然适用,就可能直接复用。
与普通精确缓存相比,语义缓存需要先生成查询向量,再进行相似度检索:
当相似度超过阈值时,才考虑复用结果。
典型流程:
flowchart TD
A["收到用户问题"] --> B["文本规范化"]
B --> C["生成 Query Embedding"]
C --> D["检索语义缓存"]
D --> E{"是否存在高相似度结果?"}
E -->|是| F["检查权限与上下文约束"]
F --> G{"结果是否可复用?"}
G -->|是| H["返回缓存答案"]
G -->|否| I["调用 LLM"]
E -->|否| I
I --> J["生成答案"]
J --> K["检查缓存策略"]
K --> L["写入语义缓存"]
L --> M["返回答案"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#E5F0E9,stroke:#83A995,color:#315D49
style I fill:#EAF3EC,stroke:#83A995,color:#315D49
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style L fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style M fill:#E5F0E9,stroke:#83A995,color:#315D49
语义缓存存在一个重要风险:语义相似不代表业务答案可以复用。
例如:
- “今天的美元汇率是多少?”
- “昨天的美元汇率是多少?”
两者语义高度接近,但时间条件不同。
再例如:
- “张三的订单状态是什么?”
- “李四的订单状态是什么?”
如果忽略用户身份和数据权限,可能造成严重的信息泄露。
因此,语义缓存至少需要结合:
- 相似度阈值。
- 租户与用户权限。
- 时间敏感性。
- 数据版本。
- 查询上下文。
- 结果新鲜度。
- 业务规则约束。
对金融、医疗、订单、权限和实时状态等场景,不能仅依赖语义相似度决定缓存命中。
3.6 RAG 缓存
RAG 系统中有多个适合缓存的环节:
| 缓存对象 | 缓存内容 | 失效条件 |
|---|---|---|
| Query Embedding | 查询向量 | 模型或预处理版本变化 |
| Retrieval Cache | 检索到的文档 ID | 索引更新、权限变化 |
| Rerank Cache | 重排结果 | 模型或排序策略变化 |
| Document Cache | 文档内容 | 文档更新或删除 |
| Prompt Cache | 拼装后的上下文 | 检索内容、提示词变化 |
| LLM Result Cache | 最终答案 | 上下文、模型或生成参数变化 |
一个完整的 RAG 请求可以利用多层缓存减少重复计算:
flowchart TD
A["用户问题"] --> B["查询缓存"]
B --> C{"查询向量命中?"}
C -->|是| D["复用 Query Embedding"]
C -->|否| E["调用 Embedding 模型"]
E --> F["保存向量缓存"]
F --> G["向量检索"]
D --> G
G --> H["检索结果缓存检查"]
H --> I{"检索结果可复用?"}
I -->|是| J["复用候选文档"]
I -->|否| K["执行向量检索"]
K --> L["执行重排"]
L --> M["保存检索与重排结果"]
J --> N["组装 Prompt"]
M --> N
N --> O["检查 LLM 结果缓存"]
O --> P{"最终答案命中?"}
P -->|是| Q["返回答案"]
P -->|否| R["调用 LLM"]
R --> S["保存结果缓存"]
S --> Q
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#EAF3EC,stroke:#83A995,color:#315D49
style L fill:#EAF3EC,stroke:#83A995,color:#315D49
style M fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style N fill:#EAF3EC,stroke:#83A995,color:#315D49
style O fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style P fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style Q fill:#E5F0E9,stroke:#83A995,color:#315D49
style R fill:#EAF3EC,stroke:#83A995,color:#315D49
style S fill:#EAE8FA,stroke:#A49BD5,color:#51477D
需要特别注意:RAG 的检索结果依赖文档版本、索引版本和用户权限。缓存命中不能绕过权限过滤,也不能让已经删除的文档继续出现在回答中。
四、缓存策略与一致性管理
缓存并不是数据的永久副本。需要根据数据特征选择缓存策略。
4.1 Cache Aside:旁路缓存
Cache Aside 是最常见的缓存模式。
读取时:
- 先查询缓存。
- 命中则直接返回。
- 未命中则查询数据库或执行计算。
- 将结果写入缓存。
- 返回结果。
更新时:
- 更新数据库。
- 删除对应缓存。
- 后续读取重新加载数据。
flowchart TD
A["读取请求"] --> B["查询缓存"]
B --> C{"缓存命中?"}
C -->|是| D["返回缓存数据"]
C -->|否| E["读取数据库"]
E --> F["写入缓存"]
F --> D
G["更新请求"] --> H["更新数据库"]
H --> I["删除缓存"]
I --> J["更新完成"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#E5F0E9,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style J fill:#E5F0E9,stroke:#83A995,color:#315D49
这种模式实现简单,适合查询频繁、更新相对较少的数据。
但它存在并发竞态:缓存删除之后,旧请求可能重新读取旧数据并写回缓存。因此,在对一致性要求较高的系统中,需要版本号、延迟双删、写入校验或事件驱动失效等补充机制。
4.2 Read Through:读穿透
Read Through 将缓存读取与底层数据加载逻辑封装在缓存层中。
应用只访问缓存:
Application
|
v
Cache Layer
|
+-- Cache Hit:直接返回
|
+-- Cache Miss:自动加载数据源
与 Cache Aside 相比,应用层不需要自己处理缓存未命中的加载过程。
这种方式适合通过缓存框架统一管理读取逻辑的场景。
4.3 Write Through:写穿透
Write Through 在写入缓存时同步更新底层数据源。
Application
|
v
Cache Layer
|
+-- 更新缓存
|
+-- 更新数据库
优点是缓存和数据源更新路径相对统一。
缺点是写入延迟可能增加,而且需要处理数据库更新失败时的回滚或一致性问题。
4.4 Write Back:回写缓存
Write Back 先更新缓存,再异步将数据写入持久化存储。
适合写入频繁、能够容忍一定持久化延迟的场景。
但如果缓存节点故障,尚未写入数据库的数据可能丢失。因此,需要配合:
- 持久化日志。
- 写入队列。
- 故障恢复。
- 重试与补偿。
- 明确的数据丢失容忍策略。
对订单、支付和关键业务状态,不应仅依赖缺少持久化保障的 Write Back 机制。
4.5 TTL:过期时间
TTL(Time To Live)表示缓存数据的有效时间。
例如:
redis.set(
"embedding:doc:1001",
vector_data,
ex=3600
)
表示缓存 3600 秒后过期。
TTL 适合处理:
- 配置缓存。
- 热点查询结果。
- 临时会话状态。
- 有明确有效期的数据。
但 TTL 并不能完全保证数据一致性。数据可能在有效期内发生变化,因此需要根据业务要求配合主动失效。
建议:
- 实时性要求高的数据使用短 TTL。
- 稳定且变化较少的数据使用长 TTL。
- 热点数据采用随机 TTL,降低集中失效风险。
- 对关键数据使用版本号或事件通知主动失效。
4.6 缓存击穿、穿透与雪崩
这是缓存系统最常见的三类问题。
| 问题 | 表现 | 解决方法 |
|---|---|---|
| 缓存穿透 | 查询不存在的数据,持续访问底层存储 | 布隆过滤器、空值缓存、参数校验 |
| 缓存击穿 | 某个热点 Key 过期,大量请求同时重建 | 互斥锁、逻辑过期、后台刷新 |
| 缓存雪崩 | 大量缓存同时过期或缓存服务故障 | TTL 随机化、多级缓存、限流、降级 |
缓存穿透
例如,攻击者不断查询不存在的文档 ID。由于缓存中没有这些数据,请求持续落到底层数据库。
可以使用布隆过滤器(Bloom Filter)提前判断某个对象是否可能存在。
需要注意,布隆过滤器存在误判,可能返回“可能存在”,但不会正常地产生假阴性,前提是构建与更新过程正确。
缓存击穿
例如,某个热门 Prompt 缓存突然过期,10000 个并发请求同时访问模型服务,导致模型推理压力激增。
可以使用互斥锁控制缓存重建:
import redis
client = redis.Redis()
def get_or_build(key, builder):
cached = client.get(key)
if cached is not None:
return cached
lock_key = f"lock:{key}"
acquired = client.set(
lock_key,
"1",
nx=True,
ex=10
)
if acquired:
try:
cached = client.get(key)
if cached is not None:
return cached
value = builder()
client.set(key, value, ex=3600)
return value
finally:
client.delete(lock_key)
# 简化示例:生产环境应采用有界等待或降级策略
raise RuntimeError("Cache rebuild in progress")
生产环境中,锁的释放需要校验锁持有者标识,避免误删其他实例持有的锁;还需要考虑锁过期、执行超时和重建失败。
缓存雪崩
如果大量缓存都设置为相同 TTL,可能在同一时间集中失效。
可以通过随机化过期时间缓解:
import random
ttl = 3600 + random.randint(0, 600)
client.set("cache:key", value, ex=ttl)
这样能够分散缓存失效时间。
五、AI 系统的资源类型与资源瓶颈
缓存解决重复计算问题,资源调度则解决计算资源如何分配的问题。
AI 系统通常涉及以下资源:
| 资源 | 典型用途 | 常见瓶颈 |
|---|---|---|
| CPU | Tokenization、数据预处理、请求处理 | CPU 利用率过高 |
| GPU | LLM 推理、Embedding、训练 | GPU 计算饱和 |
| GPU 显存 | 模型权重、KV Cache、激活值 | OOM、并发受限 |
| 系统内存 | 数据加载、缓存、批处理 | 内存不足、交换抖动 |
| NVMe | 模型权重、数据集、索引 | I/O 吞吐不足 |
| 网络 | 分布式推理、模型加载、数据传输 | 带宽与延迟 |
| 对象存储 | 模型文件、数据集、结果文件 | 请求延迟、吞吐受限 |
5.1 GPU 计算资源
GPU 的主要计算能力由计算单元、显存带宽和显存容量等因素共同决定。
不同任务对 GPU 的需求并不相同:
- Prefill 阶段通常有较大的矩阵计算量。
- Decode 阶段通常需要频繁访问模型权重和 KV Cache。
- Embedding 任务可以通过批处理提升吞吐。
- 模型训练需要保存梯度、优化器状态和中间激活值。
因此,不能只看 GPU 利用率判断系统是否充分利用资源。
例如:
- GPU 利用率很高,但显存剩余很少,说明并发扩展空间有限。
- GPU 利用率很低,但请求排队严重,可能是 CPU 预处理、网络或调度环节存在瓶颈。
- 显存占用很高,但计算利用率很低,可能存在 KV Cache 占用过多或请求长度分布不合理的问题。
5.2 GPU 显存的组成
GPU 显存通常被以下内容占用:
其中:
- M_{weights}:模型权重。
- M_{KV}:KV Cache。
- M_{activations}:中间激活值。
- M_{workspace}:算子临时工作空间。
- M_{runtime}:CUDA Runtime、通信缓冲区等开销。
因此,判断一个模型能否部署在某张 GPU 上,不能只比较模型权重大小与显存容量。
例如,一个 70B 参数模型即使通过量化将权重压缩到可以装入显存,也仍然需要为 KV Cache、算子工作空间和运行时预留空间。
5.3 CPU 与 GPU 的协同
LLM 推理不是只有 GPU 计算。
一个完整请求可能包含:
请求接收
-> 文本规范化
-> Tokenization
-> Prompt 构建
-> GPU 推理
-> Detokenization
-> 流式输出
CPU 负责大量数据处理与调度工作,GPU 负责核心张量计算。
如果 CPU 预处理能力不足,GPU 可能因为等待输入数据而无法充分利用。
因此,需要同时监控 CPU、GPU、内存、网络和存储资源,而不是只监控 GPU 利用率。
六、AI 系统的资源调度架构
资源调度的目标是根据任务类型、优先级、资源需求和系统负载,决定任务由哪个计算节点执行。
一个典型的调度架构包含:
- API Gateway:接收请求。
- Scheduler:任务调度器。
- Task Queue:任务队列。
- Resource Manager:资源管理器。
- Worker:执行任务的计算节点。
- Model Server:模型推理服务。
- Cache Service:缓存服务。
- Metrics:资源与任务监控。
flowchart TD
A["用户请求"] --> B["API Gateway"]
B --> C["任务分类与资源估算"]
C --> D["Scheduler 调度器"]
D --> E["任务队列"]
E --> F["资源管理器"]
F --> G{"资源是否满足?"}
G -->|是| H["选择计算节点"]
G -->|否| I["等待、限流或拒绝"]
H --> J["Worker 执行任务"]
J --> K["访问缓存"]
K --> L{"缓存命中?"}
L -->|是| M["复用缓存数据"]
L -->|否| N["调用模型或计算服务"]
N --> O["更新缓存"]
M --> P["保存结果"]
O --> P
P --> Q["返回结果或更新任务状态"]
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
style J fill:#EAF3EC,stroke:#83A995,color:#315D49
style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style M fill:#EAF3EC,stroke:#83A995,color:#315D49
style N fill:#EAF3EC,stroke:#83A995,color:#315D49
style O fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style P fill:#E5F0E9,stroke:#83A995,color:#315D49
style Q fill:#E5F0E9,stroke:#83A995,color:#315D49
实际生产系统通常会将 Scheduler、Resource Manager 和 Worker 拆分为独立服务,并通过消息队列、资源注册表和监控系统进行协作。
七、常见资源调度策略
7.1 FIFO:先进先出
FIFO(First In First Out)按照任务进入队列的顺序执行。
优点:
- 实现简单。
- 调度规则明确。
- 不容易产生复杂的优先级管理问题。
缺点:
- 长任务可能阻塞短任务。
- 无法体现请求优先级。
- 不适合任务资源需求差异很大的场景。
例如:
任务 A:需要 30 分钟
任务 B:需要 10 秒
任务 C:需要 5 秒
如果采用严格 FIFO,B 和 C 可能需要等待 A 执行结束。
7.2 Priority Scheduling:优先级调度
为不同任务分配优先级:
P0:紧急在线请求
P1:普通在线请求
P2:交互式后台任务
P3:批量离线任务
P4:低优先级维护任务
调度器优先处理高优先级任务。
但如果始终优先处理高优先级请求,低优先级任务可能长期得不到执行,形成饥饿问题。
常见解决方法:
- Aging:等待时间越长,优先级逐渐提高。
- 配额:限制高优先级任务占用的最大资源比例。
- Weighted Fair Queueing:按权重分配处理能力。
- Deadline Scheduling:根据截止时间进行调度。
7.3 Round Robin:轮询调度
多个任务队列按照轮询方式获取执行机会。
例如:
Tenant A -> Tenant B -> Tenant C -> Tenant A
优点是可以避免单一租户长期占据所有资源。
缺点是不同任务的计算成本可能差异很大,简单轮询不能保证资源消耗公平。
7.4 Weighted Fair Scheduling:加权公平调度
为不同租户或任务类别分配权重。
例如:
| 租户 | 权重 | 资源分配目标 |
|---|---|---|
| A | 5 | 50% |
| B | 3 | 30% |
| C | 2 | 20% |
当所有租户都持续有任务时,调度器可以根据权重分配计算资源。
实际系统还需要考虑任务的真实资源消耗,而不是简单按照任务数量分配。
例如,一个任务生成 1000 个 Token,另一个任务生成 100 个 Token,两者的计算成本并不相同。
7.5 Resource-aware Scheduling:资源感知调度
根据任务的资源需求选择执行节点。
例如:
| 任务 | 主要资源需求 | 调度策略 |
|---|---|---|
| LLM 推理 | GPU、显存 | 选择有足够显存的 GPU 节点 |
| Embedding | GPU 或 CPU | 批处理并按模型分组 |
| OCR | GPU、CPU | 根据模型和图像尺寸选择节点 |
| 文档解析 | CPU、内存 | 调度到 CPU 计算池 |
| RAG 索引构建 | CPU、GPU、磁盘、网络 | 分阶段调度 |
| 模型训练 | GPU、显存、网络 | 预留集群资源 |
资源感知调度的关键不是简单地选择空闲机器,而是判断机器是否能够在目标时间内完成任务。
7.6 Bin Packing:装箱调度
Bin Packing 是将不同资源需求的任务分配到有限资源容器中的优化问题。
例如:
- GPU 节点 A:显存 80GB。
- GPU 节点 B:显存 80GB。
- 任务 1:预计需要 30GB。
- 任务 2:预计需要 20GB。
- 任务 3:预计需要 50GB。
调度器需要决定任务放置方式,使资源得到充分利用,同时避免超出显存容量。
这类问题在一般形式下属于 NP-hard 问题,因此实际系统通常采用启发式算法:
- First Fit:找到第一个可容纳任务的节点。
- Best Fit:选择剩余资源最少但仍可容纳任务的节点。
- Worst Fit:优先选择剩余资源最多的节点。
- Spread:尽量分散任务,避免节点过载。
- Pack:尽量集中任务,为其他节点保留完整资源。
不同策略适用于不同目标:
- Pack 有利于释放整块空闲节点。
- Spread 有利于降低单节点故障和热点风险。
- Best Fit 有利于提高资源空间利用率,但可能增加碎片问题。
八、LLM 推理中的资源调度
LLM 推理是 AI 系统中最典型的资源调度场景。
8.1 Prefill 与 Decode 的资源特征
LLM 推理主要分为两个阶段:
Prefill 阶段
处理输入 Prompt,计算输入 Token 的表示并构建 KV Cache。
特点:
- 输入 Token 数量通常较多。
- 并行矩阵计算较多。
- 对 GPU 计算能力和显存带宽有较高要求。
- 输入长度直接影响 Prefill 工作量。
Decode 阶段
逐 Token 生成输出。
特点: