vLLM 的启动与初始化流程

vLLM的启动链路可以划分为三个核心阶段：配置构建（Configuration）、引擎构建（Engine Construction）和服务启动（Serving）。

一、宏观流程

CLI 入口
 ├── api_server.main()                # 1. 入口层：接收外部信号
 └── run_server(args)
     ├── setup_server(args)           # 基础环境配置
     └── run_server_worker()          # 2. 核心工作流
         ├── build_async_engine_client(args)  # ---> [核心：构建引擎]
         │    ├── create_engine_config()      # ---> [配置解析]
         │    └── AsyncLLM.from_vllm_config() # ---> [实例化异步大模型]
         │         ├── EngineCoreClient       # IPC 通信客户端
         │         └── EngineCore             # 后台推理核心
         │              ├── Executor          # 执行器管理
         │              └── Scheduler         # 调度器管理
         ├── build_app(args)          # 3. 服务层：构建 FastAPI 应用
         └── serve_http()             # 启动 Uvicorn 服务

二、关键阶段

1. 配置构建

vLLM通过create_engine_config构建了一个庞大的配置树，核心任务是将CLI参数转化为vLLM内部可理解的配置对象，解决硬件与模型的兼容性问题。

# vllm/engine/arg_utils.py
engine_args.create_engine_config()
    ├── create_model_config()           # 解析 HuggingFace 模型配置
    ├── DeviceConfig()                  # 设备类型配置 (GPU/CPU/TPU)
    ├── CacheConfig()                   # KV Cache 配置
    ├── ParallelConfig()                # 并行策略配置 (TP/PP/DP)
    ├── create_speculative_config()     # 推测解码配置 (可选)
    ├── SchedulerConfig()               # 调度器配置
    ├── LoRAConfig()                    # LoRA 适配器配置 (可选)
    ├── AttentionConfig()               # 注意力后端配置
    ├── create_load_config()            # 模型加载策略配置
    ├── ObservabilityConfig()           # 可观测性配置
    ├── CompilationConfig()             # 编译优化配置
    └── VllmConfig()                    # 整合所有配置

2. 整体架构

vLLM在v1版本中引入了AsyncLLM和EngineCore ，采用类似Client-Server的架构来规避Python GIL锁，实现高并发，总体架构如下。

┌─────────────────────────────────────────────────────────────┐
│                   Frontend Process                          │
│                                                             │
│  AsyncLLM                                                   │
│      ├── InputProcessor                                     │
│      ├── OutputProcessor                                    │
│      └── AsyncMPClient                                      │
│              ├── input_socket (ZMQ ROUTER)                  │
│              └── output_socket (ZMQ PULL)                   │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           │ launch_core_engines()
                           │
            ┌──────────────┼──────────────┐
            │              │              │
            ▼              ▼              ▼
┌───────────────┐  ┌───────────────┐  ┌───────────────┐
│ Backend Proc 1│  │ Backend Proc 2│  │ Backend Proc N│
│               │  │               │  │               │
│ EngineCore    │  │ EngineCore    │  │ EngineCore    │
│   ├──Executor │  │   ├──Executor │  │   ├──Executor │
│   ├──Scheduler│  │   ├──Scheduler│  │   ├──Scheduler│
│   └──KV Cache │  │   └──KV Cache │  │   └──KV Cache │
└───────────────┘  └───────────────┘  └───────────────┘
     GPU 0              GPU 1              GPU N-1

核心组件

类	职责
`AsyncLLM`	异步引擎入口，处理并发请求
`EngineCore`	引擎核心，运行调度+执行循环
`EngineCoreClient`	IPC 客户端，与后台进程通信
`Executor`	执行器，管理 Worker 生命周期
`Worker`	GPU Worker，管理单设备
`GPUModelRunner`	模型运行器，执行前向传播
`Scheduler`	调度器，管理请求队列
`InputProcessor`	输入处理（分词）
`OutputProcessor`	输出处理（解码）

3. EngineCore启动流程

AsyncLLM.from_vllm_config()
    │
    ├── Executor.get_class(vllm_config)
    │
    └── AsyncLLM.__init__()
            │
            ├── InputProcessor(...)
            ├── OutputProcessor(...)
            │
            └── EngineCoreClient.make_async_mp_client()
                    │
                    ├── AsyncMPClient.__init__()
                    │       │
                    │       └── MPClient.__init__()
                    │               │
                    │               └── launch_core_engines()
                    │                       │
                    │                       ├── DPCoordinator
                    │                       │
                    │                       └── CoreEngineProcManager
                    │                               │
                    │                               └── context.Process(
                    │                                       target=EngineCoreProc.run_engine_core,
                    │                                       ...
                    │                                   )
                    │
                    └── wait_for_engine_startup()

4. EngineCore初始化

EngineCoreProc.run_engine_core()
    │
    ├── 信号处理器设置 (SIGTERM, SIGINT)
    │
    ├── set_process_title("EngineCore")
    │
    └── EngineCoreProc.__init__()
            │
            ├── _perform_handshakes()          # 与前端进程握手
            │       │
            │       ├── startup_handshake()    # 发送 HELLO，接收初始化信息
            │       │
            │       └── yield addresses        # 返回 ZMQ 地址
            │
            ├── _init_data_parallel()          # 初始化数据并行 (可选)
            │
            └── EngineCore.__init__()          # 核心初始化
                    │
                    ├── load_general_plugins()
                    │
                    ├── executor_class(vllm_config)    # 创建 Executor
                    │       │
                    │       └── Worker 初始化
                    │               ├── init_device()
                    │               └── load_model()    # 加载模型权重
                    │
                    ├── _initialize_kv_caches()         # 初始化 KV Cache
                    │       ├── get_kv_cache_specs()
                    │       ├── determine_available_memory()
                    │       ├── get_kv_cache_configs()
                    │       └── initialize_from_config()
                    │
                    ├── StructuredOutputManager()
                    │
                    ├── Scheduler = scheduler_cls()     # 创建调度器
                    │
                    └── batch_queue (可选)              # 流水线并行

4. Executor初始化

# vllm/v1/executor/uniproc_executor.py
UniProcExecutor._init_executor():
    └── Worker.init_device()
            ├── init_distributed_environment()  # 初始化分布式
            └── GPUModelRunner.load_model()     # 加载模型

5. 模型加载

# vllm/v1/worker/gpu_model_runner.py  
GPUModelRunner.load_model():
    └── get_model_loader().load_model()
            ├── initialize_model()        # 初始化模型结构
            ├── load_weights()            # 加载权重
            └── process_weights_after_loading()  # 量化处理

Last modified: 14 February 2026