大模型推理入门:一次 generate 调用链拆解

作者:新兰2026.11.17 03:38浏览量:0

简介:推理引擎入门难在"从哪拆":本文以 nano-vllm 为样本,按 LLMEngine → Scheduler → ModelRunner 一条主线走通单卡下 llm.generate() 的全过程,讲清 Prefill/Decode 两阶段、Continuous Batching 的调度时机、Sequence 状态机与 KV cache 块数计算,并给出日志对照法与代码片段,帮程序员少走弯路。

入门大模型推理引擎,真正的门槛不是数学,而是 怎么拆 ——从哪一层开始看、哪些先当黑盒、调用链按什么顺序跟。这篇文章给一条能走通的主线:单 GPU 前提下,把一次 llm.generate() 从用户调用到返回结果,在 LLMEngine → Scheduler → ModelRunner 这条链路上跑一遍,以 nano-vllm 这类精简实现为样本。

先说一个现实问题:如果你只是想先感受不同模型的推理效果、或者对比几个候选模型的输出质量与调用成本,不必一上来就啃引擎源码。可以先在 百度智能云词元所 上看看有哪些模型可选、价格与能力如何对比,再用统一 API 把调用跑通,等到需要压榨延迟和吞吐时再回到引擎层做优化。两条路不冲突,后者恰恰是前者的进阶。

读这类代码的四个习惯

这也是本文的写作顺序,建议照抄:

  1. 黑盒 + 接口 :这次不讲的东西(PagedAttention 内部 block hash 怎么算、TP 多进程怎么同步),就当它有明确的输入输出,像 DDD 里的一个 bounded context。先把整体模型搭起来,下次再拆黑盒。
  2. 日志对着代码看 :分析任何流程都要读真实跑出来的日志。光看代码容易脑补,日志不会骗你。
  3. 读函数前先搞清输入输出 :这个函数吃什么、吐什么、为什么存在。牵涉前置概念(continuous batching、cu_seqlens)先把概念讲透再进代码。
  4. 看不懂就举例跑一遍 :构造一个具体输入,用它过一遍执行流程,比抽象地读代码有效得多。

一次 llm.generate() 发生了什么

推理引擎本质是生成式模型的”发动机”:接收带采样参数的并发请求,分词组 batch,调度 GPU 做前向推理,再把结果转成 token 返回。落到代码上,主循环短得让人意外:

  1. while self.is_running():
  2. seqs = self.scheduler.schedule() # 决策:这一步跑谁
  3. if not seqs:
  4. continue # 没请求可跑,等新请求入队
  5. self.model_runner.run(seqs) # 执行:prepare → forward → sample
  6. self.scheduler.postprocess(seqs) # 收尾:判结束、回收 KV cache 块

三个模块的职责边界,先记这张表:

模块 输入 输出 核心职责
LLMEngine 用户 prompt、采样参数 生成结果 请求生命周期、主循环、持有 Scheduler 与 ModelRunner
Scheduler 等待队列 + 运行队列 本次 step 要跑的 Sequence 列表 KV cache 块分配、抢占、prefill/decode 混批
ModelRunner Sequence 列表 每个 seq 的下一个 token prepare 输入张量、forward、采样、写回 KV cache

Prefill 与 Decode:为什么必须分开看

Prefill 阶段模型一次性吃掉整个 prompt,建立带记忆能力的上下文;Decode 阶段则在此基础上自回归地一个个吐 token,直到遇到停止符或满足采样停止条件。两者的性能特征完全相反:

  • Prefill :一次处理 N 个 token,算力密集(compute-bound),GPU 利用率容易打满。
  • Decode :一次只处理 1 个 token,访存密集(memory-bound),GPU 算力大量闲置。

这就是为什么”0 token 间间隔、100% GPU 利用率”会成为推理引擎优化的目标——把多个请求的 decode 步骤拼进同一个 batch,用别人的算力空档跑自己的活。

Continuous Batching 在 nano-vllm 里怎么落地

传统静态 batching 要等一批请求全部生成完才能换下一批,短请求会被长请求拖死。Continuous Batching 把调度粒度从”批”降到”step”:每执行完一个 token 生成步,就重新调度一次。schedule() 的逻辑因此非常朴素:

  1. def schedule(self):
  2. scheduled = []
  3. # 1) 等待队列:能分到 KV cache 块就转成 prefill
  4. while self.waiting and self.can_allocate(self.waiting):
  5. seq = self.waiting.pop(0)
  6. self.allocate(seq) # 按 (seq_len + block_size - 1) // block_size 分块
  7. scheduled.append(seq)
  8. # 2) 运行队列:还没结束的 seq 全部参与本 step 的 decode
  9. scheduled += self.running
  10. return scheduled

关键结论: 一个 step 里可以同时存在 prefill 和 decode 。新请求刚入队就能插进来做 prefill,不必等老请求结束;老请求则继续 decode。这就是”continuous”的来源,也是它比静态 batching 吞吐高出一大截的原因。

ModelRunner 侧要配合做两件事:把变长序列压平(用 cu_seqlens 记录每条序列的边界,避免 padding 浪费算力),以及按位置把 token 映射到对应的 KV cache 块。

Sequence:把一条请求当状态机读

Sequence 是整个引擎里最值得精读的数据结构,它就是一个状态机:

  1. WAITING --(分到块)--> RUNNING --(遇到 eos/达到 max_tokens)--> FINISHED
  2. ^ |
  3. +--(被抢占,回收块)----+

字段大致分四类:身份(seq_id)、token 序列(token_ids、num_tokens)、资源(block_table 指向的 KV cache 块)、状态(status、采样参数)。把 Scheduler 的 schedule() 和 ModelRunner 的 prepare_* 对着这个状态机读,抢占(preemption)和块回收这些看似绕的逻辑会立刻清晰。

引擎初始化:运行时的基础设施

初始化阶段决定了后续能跑多大 batch,三件事必须搞明白:

权重加载 :按 dtype 把 safetensors 分片 mmap 进显存,记录实际占用 model_mem。

KV cache 块数计算 ,这是容量规划的核心公式:

  1. block_bytes = block_size × num_layers × 2(K和V) × kv_heads × head_dim × dtype_size
  2. num_blocks = (gpu_mem_total × 利用率 - model_mem - 激活/显存开销) // block_bytes

num_blocks × block_size 就是所有并发请求能共享的 token 总容量。日志里打印的 num_blocks 一旦偏小,最先出现的症状就是频繁 preemption、吞吐断崖。

CUDA Graph 捕获 :decode 阶段每步只跑 1 个 token,kernel 启动开销占比极高。把固定 batch size 档位(如 1/2/4/8…)的计算图提前录下来,运行时直接 replay,能显著压低单步延迟。注意 graph 只对形状固定的 decode 有效,prefill 因序列长度可变一般不捕获。

对着日志验证理解

跑起来后,把日志打开,你应该能看到类似这样的轨迹:

  1. [init] num_blocks=1024 block_size=256 max_num_seqs=256
  2. [step 1] prefill seq=0 prompt_len=17 -> '我'
  3. [step 2] decode seq=0 -> '是'
  4. [step 3] prefill seq=1 prompt_len=9 -> '你' # 新请求插入,与 seq=0 同批
  5. [step 4] decode seq=0,1 -> '一' '好' # 两条请求共享一次 forward
  6. [step 5] decode seq=0 -> '<eos>' # seq=1 已结束,块被回收

对着这几行去反查 schedule() 的分支走向,比读十遍代码都管用。建议自己动手加日志:在 schedule() 打印 waiting/running 长度,在 postprocess() 打印回收的块数。

这些先当黑盒(留到后面)

  • PagedAttention 的 block hash 与前缀复用细节
  • TP/PP 多卡切分与进程间通信
  • 投机采样(speculative decoding)、量化 kernel
  • 调度公平性、优先级与 SLA 保障

最后:什么时候不该自己读引擎

如果你的目标是把 AI 能力落进业务,而不是造推理引擎,那么合理的顺序是:先用托管服务把效果验通,再评估自建成本。做模型选型时,词元所 这类平台的价值在于把”能力—价格—接入方式”放在一张表里对比,避免凭感觉拍板;接入阶段则可以用统一 API 屏蔽各家 SDK 差异,把精力留给业务逻辑。等到调用量上来、成本或延迟成为瓶颈,再回头读引擎源码——那时你对 KV cache、continuous batching 的理解会带着明确的优化目标,学习效率完全不同。

想动手的话,建议路径是:跑通 nano-vllm 的 example → 打开日志观察 prefill/decode 切换 → 改 max_num_seqs 和 gpu_memory_utilization 看吞吐变化 → 最后才进 PagedAttention 的 block 管理。