返回专栏
· 29 分钟阅读

AI 系统的缓存与资源调度


一、为什么 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)表示缓存中没有对应数据,需要访问下层存储或重新执行计算。

缓存命中率:

HitRate=\frac{CacheHit}{CacheHit+CacheMiss}

缓存未命中率:

MissRate=1-HitRate

例如,一段时间内有 10000 次缓存查询,其中 8500 次命中:

HitRate=\frac{8500}{10000}=85\%

但高命中率不一定意味着系统性能好。

例如:

  • 缓存命中的都是轻量级数据,节省的计算成本有限。
  • 缓存查询本身需要访问远程服务,可能增加网络延迟。
  • 缓存命中后仍然需要执行大量后续计算。
  • 缓存数据过期或失效,可能导致错误结果。

因此,除了命中率,还应关注缓存节省的计算时间、请求延迟、网络开销和缓存维护成本。

2.3 缓存收益如何计算

设:

  • T_c:缓存查询耗时。
  • T_m:缓存未命中时重新计算的耗时。
  • H:缓存命中率。

忽略其他开销时,平均请求耗时可以近似表示为:

T_{avg}=T_c+(1-H)T_m

例如:

  • 缓存查询耗时为 2ms。
  • 原始计算耗时为 200ms。
  • 缓存命中率为 80%。

则:

T_{avg}=2+(1-0.8)\times200=42ms

相较于每次都执行 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:

Q=XW_Q,\quad K=XW_K,\quad V=XW_V

注意力计算:

Attention(Q,K,V)= Softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V

在自回归生成过程中,新 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 的显存需求近似为:

M_{KV}=2\times B\times L\times H_{kv}\times D\times S\times P

其中的 2 表示 Key 和 Value 两部分。

例如:

  • Batch Size = 1。
  • Transformer 层数 = 32。
  • KV Head 数量 = 8。
  • Head Dimension = 128。
  • 上下文长度 = 8192。
  • 数据类型为 FP16,每个元素占 2 字节。

则:

M_{KV} =2\times1\times32\times8\times128\times8192\times2

约为 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 模型将文本转换为向量:

v=Embedding(text)

如果相同文本反复进行向量化,就可以缓存对应的 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 是用来做什么的?

两者表达不同,但语义接近。如果历史回答仍然适用,就可能直接复用。

与普通精确缓存相比,语义缓存需要先生成查询向量,再进行相似度检索:

sim(q_1,q_2)= \frac{q_1\cdot q_2}

当相似度超过阈值时,才考虑复用结果。

典型流程:

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

语义缓存存在一个重要风险:语义相似不代表业务答案可以复用。

例如:

  • “今天的美元汇率是多少?”
  • “昨天的美元汇率是多少?”

两者语义高度接近,但时间条件不同。

再例如:

  • “张三的订单状态是什么?”
  • “李四的订单状态是什么?”

如果忽略用户身份和数据权限,可能造成严重的信息泄露。

因此,语义缓存至少需要结合:

  1. 相似度阈值。
  2. 租户与用户权限。
  3. 时间敏感性。
  4. 数据版本。
  5. 查询上下文。
  6. 结果新鲜度。
  7. 业务规则约束。

对金融、医疗、订单、权限和实时状态等场景,不能仅依赖语义相似度决定缓存命中。

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 是最常见的缓存模式。

读取时:

  1. 先查询缓存。
  2. 命中则直接返回。
  3. 未命中则查询数据库或执行计算。
  4. 将结果写入缓存。
  5. 返回结果。

更新时:

  1. 更新数据库。
  2. 删除对应缓存。
  3. 后续读取重新加载数据。
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_{total}= M_{weights} +M_{KV} +M_{activations} +M_{workspace} +M_{runtime}

其中:

  • 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 生成输出。

特点: