
线上推理服务经常会遇到一组看似矛盾的现象：GPU 利用率接近 100%，每秒输出的 Token 却没有达到预期；换成更激进的投机推理后，单请求更快了，高并发吞吐反而下降；KV Cache 还有空闲容量，Decode 延迟却继续变差。另一些需求看起来像普通后端限流，例如“普通用户 20 Token/s，高级用户 80 Token/s”，但如果要求限制的是 GPU 实际生成速度，就会直接触及推理引擎内部的调度。

本文从一次推理请求的执行过程讲起，依次解释性能指标、KV Cache、投机推理、请求调度、权重卸载和多租户缓存管理，再把这些知识组织成由浅入深的技术面试题。读者可以先只看各节中的例子，再看对应的工程取舍与问答。

这里讨论的是典型自回归大语言模型的在线推理。不同模型结构、框架版本和硬件可能改变优化结果。文中所有耗时、概率与显存数字，除明确给出来源的项目配置外，均是帮助理解的假设示例，不代表实测 Benchmark。具体功能以所使用的软件版本为准。

<!--more-->

## 从一个请求开始：vLLM 到底在做什么

下载一个模型（例如 Qwen）得到的主要是模型结构配置与训练好的权重，并不等于已经有了高效的在线推理服务。直接使用 PyTorch 的 `model.generate()` 能生成文本，但在大量并发请求下，还需要额外处理请求排队、组批、显存分配、流式响应和故障恢复。

[vLLM](https://github.com/vllm-project/vllm) 是为高吞吐、低延迟推理设计的开源执行引擎。一次典型请求的大致路径如下：

```mermaid
flowchart TD
    PROMPT["用户发送 Prompt"] --> API["HTTP / API 网关接入"]
    API --> TOK["分词器 Tokenizer<br/>文本切分为 Token ID 序列"]
    TOK --> SCHED["Scheduler 调度器<br/>请求准入、KV Cache 预算分配、动态组 Batch"]
    SCHED --> PREFILL["Prefill 阶段<br/>全量并行前向计算，构建初始 KV Cache"]
    PREFILL --> DECODE["Decode 阶段<br/>自回归逐步生成，逐步向后追加 KV Cache"]
    DECODE --> SAMPLE["Logits 计算与采样策略<br/>Greedy / Top-P 确定候选 Token"]
    SAMPLE --> DETOK["Detokenize / 流式输出<br/>转换回可读文本返回客户端"]
```

Token 是模型处理的基本单位，不一定等于一个汉字、英文单词或一次 HTTP 传输的文本片段。生成下一 Token 时，模型会为词表中的候选 Token 计算 `logits`（未归一化分数），然后根据 Greedy、Temperature、Top-p 等策略选择结果。

在 Transformer 自回归模型中，后一个 Token 依赖之前已经产生的 Token，因此正常 Decode 存在顺序依赖；但是不同请求可以一起组成 Batch 计算。vLLM 优化的是这条执行路径，而不是把模型重新训练得更聪明。

### Prefill 和 Decode

Prefill 对输入 Prompt 进行计算。如果输入有 4,096 个 Token，通常可以批量处理许多位置，建立相应的 KV Cache。大规模矩阵计算（GEMM）更容易利用 GPU 算力，因此 Prefill 往往偏向计算密集型（Compute-bound）。

Decode 在已有上下文上继续生成 Token。对低并发、小 Batch 的典型模型，每一步计算量相对较少，却仍需访问大量权重，因此往往更容易受显存带宽限制（Memory-bound）。这只是常见情况；并发足够高时，Decode 也可能变为计算瓶颈。

这一区分直接影响优化选择：Prefill 慢，不应只盯着投机推理；Decode 慢，也不应只增大 Prefill Batch。

### Continuous Batching 与 Chunked Prefill

**Static Batching** 是预先组成相对固定的一批请求；**Continuous Batching** 则允许请求在执行过程中加入、完成后退出，避免整个 Batch 被执行时间最长的请求拖住。

**Chunked Prefill** 可以把长 Prompt 的 Prefill 拆为更小的片段，再与 Decode 请求交错组批。这样可以降低长 Prefill 对持续生成请求的干扰，但块过小也可能增加调度和执行开销。vLLM V1 在合适的配置下会使用这种机制，详见 [Optimization and Tuning](https://docs.vllm.ai/en/stable/configuration/optimization/)。

## 先把性能指标讲清楚

优化前如果没有统一的指标口径，所有“提升百分之多少”都很难比较。

| 名称 | 含义 | 观察什么 |
| --- | --- | --- |
| TTFT（Time To First Token） | 从发起请求到收到首个输出 Token 的时间 | 排队、预处理、Prefill、首轮生成 |
| TPOT（Time Per Output Token） | 首 Token 之后，平均每个输出 Token 的耗时 | Decode 的平均交互速度 |
| ITL（Inter-Token Latency） | 相邻流式输出事件或 Token 的时间间隔（须说明统计口径） | 用户看到的流畅程度和抖动 |
| Output Tokens/s | 一段时间内所有请求实际生成的输出 Token 数 / 时间 | 整体生成吞吐 |
| Input Tokens/s | 一段时间内处理的输入 Token 数 / 时间 | Prompt 处理吞吐 |
| QPS | 每秒完成或处理的请求数（须明确口径） | 请求级容量 |
| P95 / P99 | 95% / 99% 样本延迟不超过的数值 | 尾延迟和少数慢请求 |
| SLO | 服务级目标，例如 P95 TTFT 小于 1 秒 | 优化必须满足的约束 |
| Goodput | 满足业务延迟与成功率要求的有效吞吐 | 真正可售卖的服务能力 |

假设一个请求总共生成 101 个 Token：第一个 Token 在 800ms 时到达，最后一个 Token 在 5,800ms 时到达，那么平均 TPOT 可以近似为 `(5800 - 800) / 100 = 50ms`，对应约 20 Token/s。这个值并不代表流中每一个间隔都恰好为 50ms。

尤其在投机推理中，一次验证可能接受多个 Token，它们可能被合并成一次流式输出事件。因此 **ITL、TPOT、用户可见的流式块间隔不必完全相同**；指标的定义和埋点位置必须明确。

### 吞吐与单用户速度不是一回事

例如有 100 个并发请求，每个请求平均 20 Token/s，则整机可能输出约 2,000 Token/s。但用户看见的单请求速度仍然只有 20 Token/s。

增加 Batch 可能提高整机 Output Tokens/s，同时使每条请求 TPOT 上升。如果业务要求单用户至少达到某个速度，就不能仅追求最大总吞吐。

### GPU Util=100% 不代表算力用满

常见 GPU Util 指标主要反映采样窗口内有没有活跃 Kernel，并不等于 Tensor Core 算力利用率、显存带宽利用率、并行效率或真实有效 Token 产出都达到 100%。

需要进一步拆分瓶颈：

- **Compute-bound**：计算操作本身耗时较多，例如 GEMM 或 Attention Kernel。
- **Memory-bound**：权重、KV Cache 等显存访问限制速度。
- **Communication-bound**：跨卡 All-Reduce、All-Gather、同步和数据传输耗时过高。
- **Scheduler / Launch-bound**：调度、CPU 侧组织 Batch、Kernel Launch、同步空档造成浪费。

定位要看 Kernel Timeline、硬件计数器、Batch 规模和端到端 TPOT，不能只凭 `nvidia-smi` 的 GPU Util 作判断。

## KV Cache：为什么显存用量会随上下文增长

### KV Cache 保存了什么

Transformer 的 Attention 需要利用历史 Token 的 Key 和 Value。若每生成一个新 Token 都重新计算整个历史的 K、V，会产生大量重复工作。

**KV Cache** 保存历史位置对应的 K、V，使后续 Token 能复用这些结果。

对于常规全注意力模型，在不考虑分片、压缩和额外开销时，容量可粗略估算为：

```text
KV 字节数 ≈ 2 × 层数 × KV Head 数 × Head Dimension
             × 当前缓存 Token 数 × 每元素字节数
```

这里的 `2` 是 K 和 V 两份数据。模型结构、GQA/MLA 等注意力变体、数据类型、分布式分片方式都会改变公式，不能对所有模型照搬。

如果有 100 个并发请求、每个请求都保留很长的上下文，KV Cache 往往会成为显存中的重要部分。需要区分**模型权重显存**、**KV Cache 显存**和**中间激活/工作区显存**，它们的变化规律不一样。

### PagedAttention 与 Prefix Caching

**PagedAttention** 从数据结构和 Attention 访问角度，支持将 KV Cache 分成多个固定大小的 Block，降低为请求预分配大片连续内存所产生的浪费。

**Automatic Prefix Caching** 是另一层优化：如果新请求与旧请求有相同的 Token 前缀，就直接复用前缀已计算出的 KV Cache，从而跳过重复 Prefill。

vLLM 使用 Block Hash：通常结合父 Block 的 Hash、当前 Block 的 Token ID 以及必要的额外信息确定缓存身份。对于多租户，还可以使用 `cache_salt` 隔离不应互相复用缓存的请求。见 [vLLM Prefix Caching 设计](https://docs.vllm.ai/en/latest/design/prefix_caching/)。

它们的区别是：

| 技术 | 主要解决的问题 |
| --- | --- |
| KV Cache | 避免同一个请求重复计算历史 Key/Value |
| PagedAttention | KV 数据如何分块分配与访问 |
| Prefix Caching | 不同请求能否复用共同前缀 |
| KV Offload | GPU 空间不足时，将缓存移到其他存储层 |
| Weight Offload | GPU 放不下模型权重时，卸载并按需预取权重 |

开启 Prefix Caching 不代表所有请求都能命中：前缀、模型、适配器、缓存隔离域等条件必须兼容。命中率高通常能减少 Prefill，但若 Decode 是瓶颈，未必改善整体输出速度。

## 投机推理：用更便宜的预测减少昂贵的 Decode 轮次

### 为什么目标模型能一次验证多个 Token

普通自回归 Decode 需要先确定第一个 Token，才能决定第二个 Token。投机推理（Speculative Decoding）把工作拆成两步：

```mermaid
sequenceDiagram
    autonumber
    participant D as Draft 草稿生成 (小模型 / 预测头)
    participant V as Target 目标模型 (主模型)
    participant S as 验证器 / 拒绝采样

    loop 投机推进循环
        D->>D: 低成本连续生成 K 个草稿候选 [T1, T2, T3, T4]
        D->>V: 打包草稿序列送入目标模型
        V->>V: 单次前向并行计算所有 K 个位置的条件概率分布
        V->>S: 传递分布与草稿建议
        S->>S: 逐位置验证：若 T3 校验失败，保留连续前缀 [T1, T2]
        S->>V: 从残差分布重新采样修正 T3
        S-->>D: 一轮产出 3 个有效 Token 并更新 KV Cache
    end
```

1. Draft（草稿生成）：使用较低成本的方法提前猜测多个 Token。
2. Verify（目标模型验证）：把已经猜出的 Token 当作已知输入，一次前向计算多个位置的预测分布，然后决定接受哪些。

草稿可能来自独立小模型、附加轻量预测网络，也可能来自 N-gram 等不依赖独立神经网络的方法。投机推理不是必须运行另一个完整的小语言模型。

假设草稿生成 `A B C D E`，目标模型发现 C 不符合验证准则，则线性草稿只能保留之前连续接受的 `A B`，C 由目标模型修正，原来基于 C 预测出的 D、E 不能继续沿用。

### 性能收益取决于什么

草稿一次生成 5 个 Token，不意味着最终一定能输出 5 个有效 Token。一个简单的评价关系是：

```text
有效生成效率 ≈ 每轮实际输出的 Token 数
               /（草稿耗时 + 验证耗时 + 调度与采样开销）
```

严格比较还需要包括所有草稿被接受时可能产生的 Bonus Token，并在不同 Batch/并发条件下测量。

举例：方案 A 一轮有效输出 4 个 Token、总耗时 20ms；方案 B 一轮有效输出 3 个 Token、总耗时 8ms。B 的有效 Token/ms 可能反而更高。

高并发时，GPU 可能已经处于计算饱和状态，草稿网络和验证额外消耗的 FLOPs 不再是“免费的”，投机推理就可能从正收益变成负收益。

## EAGLE3、DFlash、DSpark：三种草稿生成思路

### EAGLE3：使用目标模型的内部特征

[EAGLE3](https://arxiv.org/abs/2503.01840) 利用目标模型多个层的 Hidden States（中间特征）来训练轻量草稿模型。草稿模型从这些特征出发，自回归地预测接下来的 Token。

重点不是“中间特征参数少，所以预测不准”，而是**轻量草稿模型在近似目标模型未来的计算**，无法保证与目标模型的输出分布完全一致。预测越往后，先前草稿的不确定性也可能积累。

EAGLE3 的改进包括多层特征融合以及让训练过程更接近真实多步草稿生成的做法。它仍需要目标模型验证，不能因为用了目标模型的特征就直接信任草稿。

### DFlash：整个 Token Block 并行预测

[DFlash](https://docs.vllm.ai/projects/speculators/en/stable/user_guide/algorithms/) 将草稿生成组织成块级并行预测。对同一个草稿块的多个位置，可以用更少的串行草稿步骤产生候选。

优势是草稿速度快；困难在于同一块内部的不同位置缺少足够的直接顺序依赖，可能产生组合不协调或后缀接受率下降的问题。

例如想输出 `of course` 或 `no problem`，并行预测时可能得到不协调的 `of problem`。它们每个位置单独看似乎都有合理概率，组合在一起却不合适。

### DSpark：顺序修正 + 置信度调度

[DSpark 论文](https://arxiv.org/abs/2607.05147) 在块级并行草稿上增加两个关键模块：

**Markov Head** 让后一个草稿 Token 的分数受到前一个草稿 Token 的影响。它可以通过低秩分解产生轻量级的 Logit Bias：

```text
Logits_new = Logits_DFlash + B(previous_token)
B = W1 × W2
```

如果词表很大，直接存一张“前一个 Token × 下一个 Token”的完整矩阵非常昂贵；低秩分解让顺序修正更便宜。这里修正的是候选概率分布，不是替代完整的 Transformer。

**Confidence Head** 预测每个候选位置被目标模型接受的可能性。它判断的不是“文本是不是事实正确”，而是“该位置能否通过投机验证”。

由于只能接受连续前缀，调度器关心的不只是每个位置的条件概率，还关心“前面的所有位置都接受，才能走到这里”的存活概率。例如条件接受概率为：

```text
位置：          1     2     3     4     5
条件接受概率： 95%   90%   80%   20%   85%
前缀存活概率： 95% 85.5% 68.4% 13.7% 11.6%
```

第 5 个 Token 自己的条件接受概率虽有 85%，但前面第 4 个位置很容易失败，所以完整前缀接受到第 5 个位置的概率只有约 11.6%。

**Hardware-Aware Scheduler** 利用这些估计值与硬件性能曲线，为不同请求动态选择验证长度。验证过长会浪费计算，过短则降低一轮可以产生的 Token 数量。

它追求的不是单独提高接受率，而是**在目标延迟和实际硬件成本下提高有效 Token 吞吐**。参见 [DSpark 实现说明](https://github.com/vllm-project/speculators/blob/main/docs/user_guide/algorithms/dspark.md)。

### 三种算法怎么比较

| 算法 | 草稿生成特点 | 主要优势 | 主要代价 |
| --- | --- | --- | --- |
| EAGLE3 | 轻量网络递推，利用目标模型特征 | 预测质量、成熟度 | 存在串行草稿步骤 |
| DFlash | 块级并行草稿 | 降低 Draft 阶段的串行开销 | 块内依赖弱时接受长度下降 |
| DSpark | 并行草稿 + Markov Head + 置信度调度 | 同时改善草稿质量和验证资源利用 | 多了预测头、调度和校准成本 |

不能只从论文里的接受率判断谁最快；应比较 **Draft 耗时、Verify 耗时、平均接受长度、端到端 TPOT、Output Tokens/s 和不同并发下的变化**。

## 拒绝采样：为什么接受率高不代表正确性高

### 标准无损拒绝采样

设草稿模型对 Token `x` 的概率为 `q(x)`，目标模型的概率为 `p(x)`。标准接受概率为：

```text
accept(x) = min(1, p(x) / q(x))
```

假设草稿认为 A 的概率为 80%、B 为 20%；目标模型认为 A 为 60%、B 为 40%。草稿抽到 A 后，以 `60%/80%=75%` 概率接受；抽到 B 后，可以直接接受。

在大量试验的期望中：草稿抽到 A 80 次，其中约 60 次被接受；B 原本约 20 次被接受；剩下约 20 次被拒绝的 A，按正确的残差分布修正为 B。最终约 60% 是 A、40% 是 B，与目标模型一致。

一般情况下，被拒绝后的修正采样分布与 `max(0, p(x)-q(x))` 成正比，需归一化。正确实现接受与修正后，最终采样分布可以保持目标模型原来的分布。

这里的“无损”指**输出概率分布**，不意味着每次随机采样生成完全相同的文本，也不意味着目标模型不会回答错事实。

### Magic MTP / Block Verify

Block Verification 使用多个草稿 Token 的累计概率信息调整块级接受判定，目的是提高有效前缀长度或减少验证浪费。

应当区分 **算法理论** 与 **具体版本实现**：

- 某些块验证算法可以在正确的联合接受与残差采样设计下保持目标模型的采样分布。
- vLLM-Ascend 早期 Model Runner V1 的 Block Verify / Entropy Verify 配置属于带质量取舍的近似优化，官方文档明确提示可能改变输出。
- Model Runner V2 还提供了另一套无损 Block Verification 实现，使用累积概率比和残差分布，不能混为一谈。

因此“Block Verify 一定有损”或者“提高接受率就一定更好”都不准确。见 [vLLM-Ascend Speculative Decoding](https://docs.vllm.ai/projects/ascend/en/latest/user_guide/feature_guide/speculative_decoding.html)。

### Entropy Verify（熵校验）

熵衡量概率分布的不确定性：

```text
H = - Σ p_i × log(p_i)
```

低熵表示模型高度倾向少数 Token，例如算术题下一 Token 的概率集中于一个答案；高熵表示多个候选概率相近。

vLLM-Ascend 对应配置中的示例阈值形式为：

```text
T = min(exp(-posterior_alpha × H), posterior_threshold)
```

低熵时阈值较严格，高熵时可以放宽，以提高草稿接受长度。代价是：如果它改变了标准接受准则而没有对应的严格修正，就可能偏离原本的目标分布。

例如 `q(A)=90%`、`p(A)=45%`，标准接受概率只有 50%。如果为了性能把 A 的接受概率直接放宽到 90%，单是“草稿生成 A 且被接受”的概率就达到 `0.9×0.9=81%`，已经超过目标模型对 A 的 45%，无法再称为无损。

这种近似优化需要按业务质量评测决定是否启用，不能默认放开。

## Scheduler：SJF 如何改变响应延迟和吞吐

### SJF（Shortest Job First，短作业优先）

假设一个简化的**单资源串行**调度器同时收到三个任务：

| 请求 | 预计计算时间 |
| --- | ---: |
| A | 400ms |
| B | 10ms |
| C | 10ms |

按先来先服务（FCFS）依次执行 A、B、C，完成时间为 400、410、420ms，平均为 **410ms**。

按 SJF 依次执行 B、C、A，完成时间为 10、20、420ms，平均为 **150ms**。

两者总计算时间都是 420ms。这个例子说明 **SJF 降低平均完成时间，不自动减少总计算量或增加理论 Tokens/s**。

真实 vLLM 会动态组批，因此请求排序还可能改变 Batch 组成、KV Cache 压力、抢占成本和阶段间资源利用率。但要证明“吞吐提升 6.2%”，必须解释哪个机制改变了、比较的是 Requests/s 还是 Output Tokens/s，以及样本长度分布和延迟尾部是否变化。

### 为什么推理里的“短请求”难定义

Prompt 长度在请求到达时已经知道，可以据此识别短 Prefill；但**最终输出长度通常事先不知道**，所以“短 Prompt 优先”不等于知道完整任务计算量。

如果短请求持续进入，长请求可能无限等待（Starvation）。常见做法是 Aging：等待越久越提高优先级，或设置最长等待时间以保证最终执行。

这时应同时观察：

- 短请求 TTFT 与完成时间是否改善；
- 长请求的 P95/P99 是否恶化；
- 真实 Output Tokens/s 是否提高；
- 是否增加了抢占、KV Cache 重新计算或显存碎片开销。

## Weight Offload：模型放得下与跑得快是两件事

假设模型有 70B 参数，用 BF16 保存权重，仅权重理论体积就是：

```text
70 × 10^9 × 2 Byte = 140 GB
```

如果单卡显存装不下，可以选择量化、多卡 TP，或者将部分权重保存在 CPU 内存里，在执行对应层之前将其搬回 GPU/NPU。

**Weight Offload** 是模型权重卸载，不是 KV Cache Offload。它通常首先解决“模型能否装下”的问题，未必提升性能。

### 逐层预取与 Double Buffer

最简单的方式是“搬一层、算一层、再搬下一层”，设备会频繁等待传输。

异步预取使用独立传输流和缓冲区，让**当前层计算与下一层权重搬运重叠**：

```text
计算流： [计算 Layer 1] [计算 Layer 2] [计算 Layer 3]
传输流： [预取 Layer 2] [预取 Layer 3] [预取 Layer 4]
```

Double Buffer 是常见方法：计算使用 Buffer A 的权重，传输流向 Buffer B 写入下一层权重。切换前必须确认传输完成，复用 Buffer 前还要确认旧计算已结束。

假设计算一层 40ms，预取下一层 15ms，理论上较容易隐藏传输；若计算只有 10ms，传输却需 30ms，长期稳态仍受传输带宽限制。**提前多层预取只能缓解流水线空洞，不能突破长期带宽上限**，还会占用更多缓冲显存。

[vLLM Weight Offloading v2 的设计说明](https://vllm.ai/blog/2026-02-03-dsr1-gb200-part1) 就强调了异步预取与计算重叠。

### TP 和量化作为前置选项

**Tensor Parallelism（TP）** 将支持切分的权重和计算分给多张 GPU/NPU。它能让单卡装不下的模型运行，但会增加设备间通信。TP=8 不一定比 TP=4 快，也不一定比两个 TP=4 副本拥有更高的整机吞吐。

**量化（Quantization）** 用更少的位数表示权重或激活。对 7B 参数，权重体积粗略为 BF16 14GB、INT8 7GB、INT4 3.5GB（未计 Scale、Zero Point 等额外开销）。INT4 权重更小，但是否更快取决于硬件算子与反量化成本，也需要评估质量变化。

## 每用户 Token/s 限流：为什么不是简单的网关限流

先区别三种服务承诺：

| 规则 | 示例 | 适合的位置 |
| --- | --- | --- |
| 单请求输出上限 | 一次最多生成 2,048 Token | API / 生成参数 `max_tokens` |
| 单用户总量配额 | 每分钟最多输出 10,000 Token | 可信 Gateway / 计量服务 |
| 实际生成速率上限 | 普通用户 20 Token/s，高级用户 80 Token/s | 推理 Scheduler 或网关输出整形 |

**网关延迟发送**只能限制用户看见的速度，GPU 可能已经提前生成完毕，因此不一定节省算力。如果需要真正控制 GPU 的 Decode，Scheduler 必须按照额度安排请求执行。

### 每请求限速与每用户聚合限速

“普通用户每条请求 20 Token/s”和“同一个用户所有请求合计最多 3,000 Token/s”是两个不同策略。

假设某用户有 100 条并发请求，每条本来都能生成 50 Token/s，总需求 5,000 Token/s，但用户总额度只有 3,000 Token/s。需要在请求间分配预算，而不是给每条请求都设置 3,000 Token/s。

一种可扩展的设计是：

1. Gateway 认证用户，把可信的 `tenant_id`、`user_id` 和权益等级传入调度系统。
2. 全局配额服务为用户维护输出 Token/s 预算；按批次预分配额度给不同推理副本，避免每个 Token 都远程访问中心服务。
3. 推理实例内部 Scheduler 按预算决定哪些请求进入 Decode；额度不足时挂起或延后调度。
4. 依据真正**已接受且提交为输出**的 Token 数结算。投机推理单轮可能产生多个 Token，需要预留额度、限制超发、按实际产量退款或扣账。
5. 用户级预算在多个实例间共享；实例故障时处理未用配额回收与重复结算。
6. 监控实际窗口内 Output Tokens/s、超发比例、每用户等待时间、缓存占用和恢复开销。

这里还要先明确是**速率上限**还是**最低速率保证**。“普通用户最多 20 Token/s”可以用限流实现；“高级用户至少稳定 80 Token/s”需要额外的容量预留、调度优先级和服务质量保障。

### 限速会放大 KV Cache 占用问题

一个低速用户同时发起 1,000 个长上下文请求，如果允许全部进入 Prefill，它们可能很快占满 GPU KV Cache，然后长时间等待慢速 Decode。

因此不能只给每个用户一个令牌桶；还需要**准入控制**：

- 限制每用户活跃请求数量和 KV Block 预算；
- 在 Prefill 前判断预计 KV 占用，避免只完成 Prefill 就长期占住资源；
- 请求被暂停时，在保留 GPU KV、KV Offload、抢占/重算与超时取消之间做取舍；
- VIP 优先级并不能自动实现精确 Token/s 上限。

### 可用于面试的核心设计题

> 基于 vLLM，希望普通用户最多 20 Token/s、高级用户最多 80 Token/s；另有企业用户要求全部并发请求合计不得超过 3,000 Output Tokens/s。限制的是实际 GPU 生成，不是 SSE 发送速度。多副本、投机推理和 KV Cache 暂停恢复怎么处理？

合格回答至少应包括**可信身份、用户共享 Budget、分布式额度协调、Decode 侧调度、投机接受 Token 的结算和暂停的 KV Cache 生命周期**。只说“Nginx + Redis 限流”不足以回答实际计算侧限流的问题。

## KV Cache TTL：过期时间与最低保留时间不能混为一谈

### 两种完全不同的“十分钟”

**普通 TTL**：缓存超过 10 分钟后可以失效；若显存提前不足，LRU 等容量策略也可能提前淘汰它。

**最低保留 10 分钟**：缓存生成后 10 分钟内必须可供复用，不允许因为新请求多、显存满而提前丢失。后者是严格缓存保留承诺，不是通常意义上的“配置一个 expires_at”。

还需要定义时钟起点：创建完成后固定 10 分钟是绝对保留期限；最后一次有效访问后再延长 10 分钟则是滑动保留期限，后者可能被持续刷新，容量压力更大。

### 运行中 KV Cache 与可复用 Prefix Cache

**活跃请求的 KV Cache** 是计算状态。即使超过普通缓存 TTL，也不能随意把仍被请求引用的 Block 覆盖掉，否则生成会错误。

**请求完成后保留的 Prefix Cache** 是可选复用缓存。普通 vLLM 会在缓存空间紧张时淘汰空闲 Block，不能将默认 LRU 等同于“至少保证命中十分钟”。

针对“严格十分钟”，一个可行的方案是 GPU + CPU 内存 + NVMe/远程缓存的分层存储：

```text
活跃请求与热数据            GPU KV Block
         | 显存紧张，确认外部已保存
         v
受保护的可复用 KV 数据      CPU / NVMe / 外部 KV Store
         | 命中时回迁
         v
GPU 重新使用 / 恢复 Prefill
         |
         v
保留期结束 -> 解除保护 -> 允许容量淘汰
```

这里“保证可复用”和“保证一直留在 GPU”不是同一个等级的承诺：前者可以在外部存储命中后再搬回 GPU，TTFT 可能上升；后者必须为这些数据预留足够的 GPU 物理容量。

### 显存和外部存储都满了怎么办

假设受保护缓存容量是 40GB，但最近 10 分钟产生的新缓存需要 60GB。无论使用什么淘汰算法，都不可能同时满足这两个条件：

1. 所有缓存都不得在十分钟内删除；
2. 对所有新请求都无条件接受并生成同等规模缓存。

必须增加可用容量，或者在承诺产生前做 **Admission Control（准入控制）**，拒绝、排队或降级新的保留请求。只有返回明确的“未承诺缓存保留”或未接受该请求，才不至于违反原有承诺。

设计中还需要：

- **容量预留**：创建受保护缓存前就为其预留可用空间与冗余。
- **迁移确认**：GPU Block 被覆写前，必须确认外部副本持久化成功。
- **引用计数与租约**：被活跃请求读取的 Block 不能因为过期时间到达就被回收。
- **多租户隔离**：根据可信身份、Cache Salt 和数据版本确定复用范围。
- **恢复与故障模型**：节点故障、数据副本丢失、存储不可用时还是否承诺“十分钟可命中”。
- **容量预测**：按 Token 量、去重率、缓存字节数和未来十分钟流量预算资源，不能只数请求数。

### 开源实现对照

| 项目 | 可以借鉴什么 | 不能误解成什么 |
| --- | --- | --- |
| [vLLM Prefix Cache](https://docs.vllm.ai/en/latest/design/prefix_caching/) | Block Hash、引用计数、LRU、Cache Salt | 通用 Prefix Cache 的默认 LRU 不是最低十分钟保证 |
| [LMCache](https://github.com/LMCache/LMCache) | GPU 之外的多级缓存、外部 Valkey/Redis 等存储和 TTL | 设置外部 Key TTL 不等于容量满时不能提前被淘汰 |
| [Mooncake](https://github.com/kvcache-ai/Mooncake) | Lease、Soft Pin、Hard Pin、分布式缓存及配额 | Soft Pin 可在内存压力下被淘汰；Hard Pin 也不自动到期 |

LMCache 的 Valkey 存储配置支持 `ttl_seconds` 等字段，但要避免与某些容量统计/服务端淘汰机制冲突。参考 [LMCache Valkey Adapter](https://github.com/LMCache/LMCache/blob/dev/docs/source/mp/l2_storage/valkey.rst)。

Mooncake 的 Soft Pin 是淘汰优先级，不是绝对保证；Hard Pin 可保护数据免受普通淘汰，但需要在保留期结束后由业务显式解除或删除，并配合容量准入。详见 [Mooncake Store 设计](https://github.com/kvcache-ai/Mooncake/blob/main/docs/source/design/store/mooncake-store.md)。

2026 年 10 月 vLLM 社区也有针对普通 KV Block TTL 的功能讨论：[TTL-based Eviction for KV Cache Blocks #61478](https://github.com/vllm-project/vllm/issues/61478)。该讨论提出的主要是**到期后可淘汰**，不能与本文所说的**十分钟内不可提前淘汰**混淆。

## 怎么判断一次性能优化真正有效

任何优化先回答四个问题：

1. **问题是什么**：TTFT、TPOT、吞吐、显存占用，还是错误率？改善哪个 SLO？
2. **瓶颈在哪里**：调度、GEMM、Attention、采样、通信还是数据搬运？Profiling 证据是什么？
3. **为什么该方案能解决**：到底减少了哪些计算、传输、同步或空闲时间？增加了什么新成本？
4. **结果是否可靠**：固定了哪些测试条件？有没有质量回退、P99 恶化或另一种负载退化？

例如有人说“把 Short Job First 加入 Scheduler 后吞吐提高了 6%”。只回答“SJF 让短请求先完成”不够：这解释的是平均完成时间，不是 Output Tokens/s 变化的根本原因。需要继续看到 Batch 组成、缓存释放、GPU Trace 或抢占次数的对照结果。

同样，声称“通过投机推理提升 TPOT 50%”也应明确：50% 是延迟下降 50%，还是速度提升 50%？两者不是一个指标。

### 一套可复用的压测矩阵

| 变量 | 至少覆盖哪些条件 |
| --- | --- |
| 并发 | 单请求、低并发、中并发、高并发 |
| Prompt 长度 | 短、典型、长、极长 |
| 输出长度 | 短输出和长输出 |
| 输入分布 | 固定长度和真实长尾混合 |
| Sampling | Greedy、Temperature/Top-p 等实际使用模式 |
| 缓存状态 | 冷缓存、热缓存、不同 Prefix 命中率 |
| 指标 | TTFT、TPOT、P95/P99、Output Tokens/s、显存、错误率 |
| 质量 | 采样分布一致性、任务准确率、有损功能开关对照 |

**消融实验（Ablation Study）** 是确认某个改动是否有效的关键：从稳定 Baseline 出发，每次只启用一个优化；如果优化之间有交互，再补充组合实验。不要直接把不同实验的百分比相加。

## 技术面试题：从原理走到优化实现

下面的题目都可以独立使用。每题均给出**期望答案**和**能区分是否真正做过优化的追问**，不是要求候选人背同一个固定答案。

### 基础原理

**Q1：一次请求进入 vLLM 后，执行流程是什么？**

期望答案：Server 接收、Tokenize、Scheduler、KV Cache 分配、Prefill/Decode、Logits/Sampling、Streaming。应说明 Decode 需要多轮调度，每轮不一定只有一个请求。

追问：“Prefill 很慢，但 Decode 正常，优先采集什么指标？”——答：排队、Prompt 长度、Prefill Kernel、Prefix Cache 命中、TTFT 分段。

**Q2：为什么 Prefill 常偏 Compute-bound，Decode 常偏 Memory-bound？**

期望答案：Prefill 能并行处理较多输入位置；低 Batch Decode 每步访问大量权重，但单步计算量不高。高 Batch Decode 也可能成为计算瓶颈。

追问：“GPU Util 100% 是否说明计算已经到理论峰值？”——答：否，需要看硬件计算计数器和执行 Timeline。

**Q3：KV Cache、PagedAttention、Prefix Caching 各解决什么问题？**

期望答案：重复 K/V 计算、KV 分块存储、不同请求前缀复用，三者不能混为一谈。

追问：“请求结束后没有正在使用的 KV Block，是否一定要立即丢掉内容？”——答：不一定，允许以缓存形式保留到容量淘汰。

**Q4：Continuous Batching 的收益与副作用是什么？**

期望答案：动态加入退出请求，提高批次利用；Batch 过大可能增加 KV 资源压力及延迟。需要同时看吞吐和 P99。

追问：“Chunked Prefill 为什么能减少长 Prompt 对 Decode 的干扰？”——答：把长 Prefill 拆段，允许更灵活地与 Decode 一起调度，代价是更多调度开销。

### 投机推理与正确性

**Q5：为什么投机推理能够减少 Decode 延迟？**

期望答案：便宜的草稿先产生候选，目标模型一次计算多个已知位置的概率，再确认连续有效前缀。目标模型计算并没有消失，只是减少昂贵的串行轮次。

追问：“草稿 A B C D E 在 C 处第一次拒绝，保留什么？”——答：线性草稿只能保留 A B，C 修正后 D E 失效。

**Q6：EAGLE3、DFlash、DSpark 的主要取舍？**

期望答案：EAGLE3 更偏顺序草稿与特征利用；DFlash 降低草稿串行计算；DSpark 增加块内顺序修正与按接受概率/硬件成本调度验证长度。

追问：“DFlash 草稿更快但接受长度更短，是否必然更优？”——答：不能，要比较有效 Token/ms。

**Q7：DSpark 的 Markov Head 和 Confidence Head 为什么值得增加？**

期望答案：Markov Head 用轻量分数偏置改善块内依赖，Confidence Head 估计接受概率，只有增加的计算成本小于节省的目标模型验证成本才有收益。

追问：“如何证明三个模块分别有贡献？”——答：消融实验，分别关闭模块，测 Draft 时间、接受长度、Verify 时间和整体 TPS/TPOT。

**Q8：标准拒绝采样的接受概率是多少？**

条件：`q(A)=90%`，`p(A)=45%`。

期望答案：`min(1,0.45/0.90)=50%`。拒绝后还需按正确残差分布采样，以保持目标输出分布。

追问：“把接受率随意改到 90% 有什么问题？”——答：草稿生成且直接接受 A 的概率达到 81%，超过目标对 A 的 45%，破坏分布一致性。

**Q9：Magic MTP / Block Verify 和 Entropy Verify 都是无损的吗？**

期望答案：不能笼统回答。标准拒绝采样无损；某些严格块验证也可以无损；部分 vLLM-Ascend V1 近似策略可能改变目标分布。版本和采样算法很关键。

追问：“吞吐提升 5%，但业务准确率下降，是否上线？”——答：先确认显著性和正确性原因；有损功能不能默认无条件开启，需质量门槛、开关和回滚。

**Q10：为什么投机推理在高并发下可能负收益？**

期望答案：草稿与验证增加总算力消耗，GPU 可能已处于计算饱和；高并发的额外内存、调度和验证工作影响整体吞吐。

追问：“能否动态关闭投机推理或改变草稿长度？”——答：可以设计负载感知策略，但要把策略切换成本和正确性验证纳入对比。

### 调度、内存和用户限流

**Q11：SJF 为什么可能改善平均完成时间，却不一定提高 Tokens/s？**

期望答案：简单改变顺序并不减少总计算量。真实收益需从 Batch、缓存释放、抢占和硬件执行等方面证明，不能把延迟改善冒充吞吐改善。

追问：“如何避免长请求被无限延后？”——答：Aging、最长等待时间、配额或公平性约束，同时监控长请求 P99。

**Q12：Weight Offload 如何实现计算与传输重叠？**

条件：每层计算 10ms，下一层传输 30ms。

期望答案：异步流、双缓冲、预取距离可降低停顿，但稳态仍可能受传输瓶颈限制；不可能凭空把 30ms 永远隐藏在 10ms 计算中。

追问：“如何证明传输被重叠了？”——答：Profiler Timeline 中计算与 H2D 传输确实重叠，同时测整体 TPOT 和显存成本。

**Q13：TP 从 4 调到 8 会不会一定更快？**

期望答案：不会。每卡计算减少的同时，通信成本可能上升；模型是否能放下、GPU 互联、Batch 和副本数都影响结果。

追问：“整机吞吐与单请求延迟目标不同时，TP 策略是否应变化？”——答：需要重新比较单副本 TP 和多副本布局，不能只看卡数。

**Q14：BF16 改为 INT4，为什么不一定更快？**

期望答案：权重体积下降，但硬件低精度计算支持、反量化、Kernel 融合、精度限制与模型结构决定最终性能。

追问：“如何判断收益是带宽减少还是计算加速？”——答：受控 Kernel Benchmark、Profiling 与不同 Batch 测试。

**Q15：普通用户最多 20 Token/s、VIP 最多 80 Token/s，如何限制真实 Decode 速度？**

期望答案：可信用户身份 + 请求或用户级 Token Budget + Scheduler 额度判断，不是仅降低 SSE 发送速度。

追问：“暂停请求的 KV Cache 怎么办？”——答：准入上限、保留或 Offload、超时抢占及恢复的综合策略。

**Q16：一个用户的 100 条请求合计最多 3,000 Output Tokens/s，且分散在多实例，如何实现？**

期望答案：跨实例聚合配额、批量租用额度、实例内公平分配、令牌预留和实际输出结算；避免每生成一个 Token 就访问中心 Redis。

追问：“投机一次接受 5 个 Token，但预算只剩 2 个，怎么防止超发？”——答：预留、截断/延后提交、严格计量和下一轮调整；设计必须保持采样与状态一致性，不能简单丢弃已经改变模型状态的输出。

**Q17：用户要求 KV Cache 至少保留十分钟，显存已经满了怎么办？**

期望答案：这是**最低保留时间**而非普通 TTL；可以通过分层缓存、保护租约、容量预留和准入控制实现。若所有缓存层都满，必须扩容或拒绝新的保留承诺，不能无条件继续接收。

追问：“GPU Block 删除前外部副本未传输成功怎么办？”——答：不能覆写唯一有效副本，必须等待确认、重试或保持原 Block 受保护。

**Q18：缓存已经过期，但仍被一个正在 Decode 的请求引用，可以直接释放吗？**

期望答案：不能。过期只影响新复用资格，活跃引用需根据引用计数/租约安全释放，除非执行明确的受控请求取消路径。

追问：“如何验证没有并发竞态？”——答：覆盖过期与命中同时发生、节点恢复、复制失败、存储满、删除与读取竞争，以及多租户缓存隔离。

### 真实优化能力

**Q19：一个模型号称优化后 Output Tokens/s 提升 65%，要怎么审查？**

期望答案：先问指标口径、原始基线、硬件/模型/精度/输入输出长度/并发、Profiling 热点、具体代码改动与消融实验，最后看 TTFT/TPOT/P99 是否回退。

追问：“这个提升是否由你修改的模块带来？”——答：需要候选人提供可解释的调用路径、改动前后 Trace 与控制变量实验，而不是只说“我们做了算子融合”。

**Q20：GPU Util 100%，KV Cache 只用了少量容量，但单用户 TPOT 已很差，下一步怎么做？**

期望答案：缓存容量尚有余量不意味着计算、带宽、Kernel 执行或通信也有余量。先测量真实瓶颈，不应直接“把剩余 KV Cache 填满”。

追问：“再增大并发反而变慢，如何设停止扩容条件？”——答：通过延迟 SLO 下的吞吐曲线确定最大 Goodput，并观察分布尾部、抢占和功耗成本。

**Q21：某项优化第一次 Benchmark 反而回退，你如何定位？**

期望答案：说明优化假设、分层 Profiling、开关对照、复现负载、发现的新增开销和修改方案，以及最终回归测试。

这道题没有唯一算法答案，却最容易区分“了解论文原理”和“真正做过性能优化”。

## 面试应该怎样逐层追问

对一个项目，按以下次序问，比随机考术语更有区分度：

```text
原理：这个方案解决什么问题？
  -> 瓶颈：有什么 Profile、Trace 或数据证明？
  -> 设计：为什么选它，而不是另一种方案？
  -> 实现：修改了哪个模块、数据结构、调度点？
  -> 收益：基线和优化后 TTFT/TPOT/TPS/P99 是多少？
  -> 代价：什么负载会回退？质量、显存、复杂度成本是什么？
  -> 验证：消融、回归、上线开关和回滚怎么做？
```

判断重点不是候选人能否背出 EAGLE3、DSpark 或 SJF 的定义，而是能否把**性能瓶颈、实际实现和实验收益建立因果关系**。

建议把“原理正确”与“独立优化能力”分开打分：

| 能力 | 建议权重 |
| --- | ---: |
| 基础原理与概念边界 | 15% |
| Profiling、瓶颈定位与假设验证 | 25% |
| 投机推理算法与采样正确性 | 25% |
| Scheduler、KV Cache、Offload 的工程设计 | 20% |
| 真实代码改动、消融实验、回归与上线 | 15% |

## 延伸阅读

优先阅读官方设计与论文，注意具体软件版本：

1. [vLLM 官方仓库](https://github.com/vllm-project/vllm) 和 [Optimization and Tuning](https://docs.vllm.ai/en/stable/configuration/optimization/)：调度、Chunked Prefill、吞吐与延迟。
2. [vLLM Automatic Prefix Caching](https://docs.vllm.ai/en/latest/design/prefix_caching/)：Block Hash、引用计数、缓存复用和租户隔离。
3. [vLLM Speculative Decoding](https://docs.vllm.ai/en/latest/features/speculative_decoding/index.html)：各类投机方法及采样配置。
4. [Speculators Algorithms](https://docs.vllm.ai/projects/speculators/en/stable/user_guide/algorithms/)：EAGLE3、DFlash、DSpark 的草稿机制。
5. [EAGLE3 论文](https://arxiv.org/abs/2503.01840)、[DSpark 论文](https://arxiv.org/abs/2607.05147)：草稿特征、块内依赖与置信度调度。
6. [vLLM-Ascend Speculative Decoding](https://docs.vllm.ai/projects/ascend/en/latest/user_guide/feature_guide/speculative_decoding.html)：不同版本的 Block Verify 与 Entropy Verify 正确性边界。
7. [vLLM Weight Offloading v2](https://vllm.ai/blog/2026-02-03-dsr1-gb200-part1)：异步预取与计算/传输重叠。
8. [LMCache](https://github.com/LMCache/LMCache) 与 [Mooncake Store](https://github.com/kvcache-ai/Mooncake)：多层 KV 存储、TTL、Pin、Lease 与容量管理。

本文将基本概念与面试题放在一起，是为了让每道面试题都能回到真实的工程目标：**给定明确 SLO，测出瓶颈，用可验证的代码改变减少开销，而不是只叠加优化名词。**

