vLLM 深度解析：高效 LLM 推理引擎的架构与实践

1. 引言：LLM 推理的挑战#

1.1 LLM 推理的两阶段#

大语言模型推理分为两个阶段：

1
┌─────────────────────────────────────────────────────────────┐
2
│                    LLM 推理两阶段                            │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  阶段 1：Prefill（填充）                                    │
6
│  ─────────────────────────────────────────────────────────  │
7
│  输入: [用户输入 tokens]                                     │
8
│  输出: [所有 token 的 hidden states + KV cache]             │
9
│  特点: 高度并行，适合 GPU 计算                              │
10
│  耗时: 与输入长度成正比                                     │
11
│                                                              │
12
│  阶段 2：Decode（解码）                                     │
13
│  ─────────────────────────────────────────────────────────  │
14
│  输入: [已生成 tokens + KV cache]                           │
15
│  输出: [下一个 token]                                        │
16
│  特点: 自回归，逐 token 生成                                 │
17
│  耗时: 与输出长度成正比（主要瓶颈）                         │
18
│                                                              │
19
└─────────────────────────────────────────────────────────────┘

1.2 传统推理的问题#

1
class TraditionalInferenceIssues:
2
    """
3
    传统推理的问题
4
    """
5

6
    def kv_cache_issues(self):
7
        """
8
        KV Cache 的问题
9
        """
10
        return {
11
            "memory_inefficiency": "预先分配大块连续内存，大量浪费",
12
            "fragmentation": "不同请求长度差异导致内存碎片",
13
            "no_sharing": "相同前缀的请求无法共享 KV cache",
14
            "oom": "长序列请求经常 OOM",
15
        }
16

17
    def batching_issues(self):
18
        """
19
        静态 Batching 的问题
20
        """
21
        return {
22
            "padding_waste": "短序列需要 padding 到最大长度",
23
            "waiting_time": "等待所有请求到达才能开始",
24
            "gpu_underutilization": "padding 浪费大量计算",
25
            "poor_tail_latency": "短请求被迫等待长请求",
26
        }
27

28
    def memory_size_estimate(self):
29
        """
30
        KV Cache 内存估算
31

32
        以 LLaMA-2 7B 为例：
33
        """
34
        return {
35
            "model_params": "7B params",
36
            "hidden_size": 4096,
37
            "num_layers": 32,
38
            "num_heads": 32,
39
            "head_dim": 128,
40

41
            "kv_cache_per_token_fp16": "2 × layers × 2 × hidden_size × bytes",
42
            "calculation": "2 × 32 × 2 × 4096 × 2 = 1 MB per token",
43

44
            "example": {
45
                "context_4k_tokens": "4 GB for KV cache",
46
                "context_8k_tokens": "8 GB for KV cache",
47
                "total_7b_model": "14 GB weights + 8 GB KV = 22 GB",
48
                "gpu_memory": "RTX 3090 has 24 GB total",
49
                "problem": "Barely fits, no room for others",
50
            },
51
        }

1.3 vLLM 的核心创新#

1
┌─────────────────────────────────────────────────────────────┐
2
│                   vLLM 核心创新                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  1. PagedAttention                                          │
6
│     → 受操作系统分页启发                                    │
7
│     → 动态管理 KV Cache 内存                               │
8
│     → 消除内存碎片                                         │
9
│                                                              │
10
│  2. Continuous Batching                                    │
11
│     → 动态添加新请求到批次                                  │
12
│     → 最大化 GPU 利用率                                     │
13
│     → 显著降低 latency                                     │
14
│                                                              │
15
│  3. 高效 CUDA Kernel                                        │
16
│     → 专为 PagedAttention 优化                             │
17
│     → FlashAttention 集成                                   │
18
│     → CUDA Graph 加速                                       │
19
│                                                              │
20
│  4. Tensor Parallelism                                      │
21
│     → 多 GPU 分布式推理                                      │
22
│     → 模型并行与服务并行                                    │
23
│                                                              │
24
│  性能提升（对比 HuggingFace）：                              │
25
│  → 吞吐量提升 24x                                          │
26
│  → 延迟降低 2.2x                                            │
27
│  → 显存占用降低 60%                                         │
28
│                                                              │
29
└─────────────────────────────────────────────────────────────┘

1.4 本系列文章关联#

文章	关联
模型量化深度解析	INT8/INT4 量化与压缩
推理时扩展	测试时计算与推理优化
后训练深度解析	SFT/RLHF 训练优化

2. PagedAttention 机制#

2.1 动机：操作系统的分页管理#

1
class PagedAttentionMotivation:
2
    """
3
    PagedAttention 的动机
4

5
    受操作系统虚拟内存分页启发
6
    """
7

8
    def os_paging_concept(self):
9
        """
10
        操作系统分页概念
11
        """
12
        return """
13
        OS 虚拟内存管理：
14

15
        物理内存：
16
        ┌──────┬──────┬──────┬──────┬──────┬──────┐
17
        │ Page │ Page │ Page │ Page │ Page │ ...  │
18
        │  0   │  1   │  2   │  3   │  4   │      │
19
        └──────┴──────┴──────┴──────┴──────┴──────┘
20

21
        虚拟内存到物理内存的映射（Page Table）：
22
        ┌────────────┬────────────┐
23
        │ Virtual    │ Physical   │
24
        ├────────────┼────────────┤
25
        │ Page 0     │ Page 2     │
26
        │ Page 1     │ Page 5     │
27
        │ Page 2     │ Page 0     │
28
        │ ...        │ ...        │
29
        └────────────┴────────────┘
30

31
        优势：
32
        → 物理内存可以非连续
33
        → 按需分配，按需加载
34
        → 共享内存（如 fork）
35
        → 虚拟内存大小可 > 物理内存
36
        """
37

38
    def llm_paging_analogy(self):
39
        """
40
        LLM 推理中的对应
41
        """
42
        return """
43
        vLLM 中的类比：
44

45
        KV Cache = OS 中的内存页
46
        Block Table = OS 中的页表
47

48
        OS:        进程虚拟地址 → 物理内存
49
        vLLM:      token 位置   → KV cache block
50

51
        Block 0: [token 0, token 1, ..., token 15]
52
        Block 1: [token 16, token 17, ..., token 31]
53
        ...
54
        """

2.2 PagedAttention 实现#

1
class PagedAttention:
2
    """
3
    PagedAttention 实现
4
    """
5

6
    def __init__(self, block_size=16):
7
        self.block_size = block_size
8
        self.block_tables = {}  # 存储每个序列的 block 映射
9

10
    def allocate_kv_blocks(self, max_blocks_per_seq):
11
        """
12
        分配 KV blocks
13

14
        类似于 OS 的物理页分配
15
        """
16
        # 从空闲池获取 blocks
17
        available_blocks = self.get_available_blocks()
18

19
        if len(available_blocks) < max_blocks_per_seq:
20
            # 需要 evict 某些序列的 blocks
21
            self.evict_least_recently_used()
22
            available_blocks = self.get_available_blocks()
23

24
        allocated_blocks = available_blocks[:max_blocks_per_seq]
25

26
        return allocated_blocks
27

28
    def paged_attention_forward(
29
        self,
30
        query,           # (batch_size, num_heads, head_dim)
31
        key_cache,       # 存储在多个 blocks 中
32
        value_cache,
33
        block_tables,    # token_idx -> block_idx 映射
34
        seq_lens,
35
    ):
36
        """
37
        PagedAttention 前向传播
38

39
        核心思想：
40
        1. 将 KV cache 存储在非连续的 blocks 中
41
        2. 通过 block table 动态映射
42
        3. 注意力计算时按需获取
43
        """
44
        import torch
45

46
        batch_size, num_heads, head_dim = query.shape
47
        max_seq_len = seq_lens.max()
48

49
        # 输出
50
        output = torch.zeros_like(query)
51

52
        # 对每个 head 单独计算
53
        for head_idx in range(num_heads):
54
            q = query[:, head_idx, :]  # (batch_size, head_dim)
55

56
            # 分块计算 attention
57
            for block_idx in range(self.num_blocks):
58
                # 获取该 block 的 key 和 value
59
                k = self.get_key_block(head_idx, block_idx)
60
                v = self.get_value_block(head_idx, block_idx)
61

62
                # 计算 attention scores
63
                scores = q @ k.transpose(-2, -1)  # (batch_size, 1, block_size)
64
                scores = scores / (head_dim ** 0.5)
65
                scores = torch.softmax(scores, dim=-1)
66

67
                # 加权求和
68
                attn_out = scores @ v  # (batch_size, 1, head_dim)
69

70
                # 累加到输出
71
                output[:, head_idx, :] += attn_out.squeeze(1)
72

73
        return output

2.3 Block Table 管理#

1
class BlockTableManagement:
2
    """
3
    Block Table 管理
4
    """
5

6
    def block_table_structure(self):
7
        """
8
        Block Table 结构
9

10
        对于序列 [0, 1, 2, ..., 67]（68 tokens）
11
        block_size = 16
12
        """
13
        return {
14
            "num_tokens": 68,
15
            "num_blocks": 5,  # ceil(68/16) = 5
16
            "block_table": [
17
                # physical_block_id
18
                7,   # tokens [0-15]  -> physical block 7
19
                3,   # tokens [16-31] -> physical block 3
20
                9,   # tokens [32-47] -> physical block 9
21
                2,   # tokens [48-63] -> physical block 2
22
                12,  # tokens [64-67] -> physical block 12
23
            ],
24
            "metadata": {
25
                "num_full_blocks": 4,
26
                "num_partial_tokens": 4,
27
            },
28
        }
29

30
    def dynamic_allocation(self):
31
        """
32
        动态分配示例
33
        """
34
        return """
35
        请求 1: 生成 100 tokens
36
        Block Table 1: [0, 1, 2, 3, 4, 5, 6]
37

38
        请求 2: 生成 50 tokens
39
        Block Table 2: [7, 8, 9, 10, 11]
40

41
        请求 3: 生成 200 tokens (中途追加)
42
        Block Table 3: [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
43

44
        物理内存:
45
        Block 0-6: 请求 1
46
        Block 7-11: 请求 2
47
        Block 12-24: 请求 3
48

49
        关键点：
50
        → 请求可以随时扩展 blocks
51
        → 不同请求的 blocks 可以交错
52
        → 最大化内存利用率
53
        """
54

55
    def prefix_sharing(self):
56
        """
57
        前缀共享
58
        """
59
        return """
60
        场景：多个请求有相同的系统提示
61

62
        请求 1: [System Prompt] + [User Query 1]
63
        请求 2: [System Prompt] + [User Query 2]
64
        请求 3: [System Prompt] + [User Query 3]
65

66
        vLLM 优化：
67
        System Prompt 的 KV blocks 可以共享！
68

69
        Block Table 1: [prefix_blocks] + [0, 1, 2]  # 独有部分
70
        Block Table 2: [prefix_blocks] + [3, 4, 5]  # 独有部分
71
        Block Table 3: [prefix_blocks] + [6, 7, 8]  # 独有部分
72

73
        内存节省：
74
        → 原来：3 × len(System Prompt) × KV_size
75
        → 现在：1 × len(System Prompt) × KV_size + 3 × len(Unique) × KV_size
76

77
        实际效果：prefix 越长，节省越多
78
        """

3. KV Cache 管理#

3.1 传统 KV Cache 的问题#

1
class TraditionalKVCachingIssues:
2
    """
3
    传统 KV Cache 管理的问题
4
    """
5

6
    def preallocated_problem(self):
7
        """
8
        预分配的问题
9

10
        假设 max_seq_len = 8192, block_size = 16
11
        """
12
        return {
13
            "preallocated_blocks": "8192 / 16 = 512 blocks per sequence",
14
            "per_sequence_memory": "512 × 16 × 128 × 2 × 2 bytes ≈ 2.6 MB",
15
            "problem": "即使只生成 100 tokens，也浪费 412 blocks",
16
            "utilization": "100 tokens / 8192 max = 1.2% utilization",
17
        }
18

19
    def fragmentation_analysis(self):
20
        """
21
        内存碎片分析
22
        """
23
        return """
24
        场景：同时处理多个不同长度的请求
25

26
        请求 1: 需要 100 tokens  (预留 8192)
27
        请求 2: 需要 500 tokens  (预留 8192)
28
        请求 3: 需要 2000 tokens (预留 8192)
29
        请求 4: 需要 50 tokens   (预留 8192)
30

31
        总预留：4 × 8192 × 2 bytes = 64 KB per layer
32
        实际使用：2550 × 2 bytes = 5 KB per layer
33
        利用率：5 / 64 = 7.8%
34

35
        GPU 内存浪费：
36
        → Internal fragmentation: 预留但未使用
37
        → External fragmentation: 可用但不连续
38
        """

3.2 vLLM 的 KV Cache 管理#

1
class VLLMKVCaching:
2
    """
3
    vLLM 的 KV Cache 管理
4
    """
5

6
    def memory_pool(self):
7
        """
8
        内存池管理
9
        """
10
        return """
11
        vLLM 将 GPU 内存划分为：
12

13
        ┌──────────────────────────────────────────────────────────┐
14
        │                        GPU Memory                        │
15
        ├──────────────────────────────────────────────────────────┤
16
        │  Model Weights    │  KV Cache Pool   │  Free Space      │
17
        │  (固定大小)        │  (动态管理)       │                  │
18
        └──────────────────────────────────────────────────────────┘
19

20
        KV Cache Pool:
21
        ┌────────┬────────┬────────┬────────┬────────┬────────┐
22
        │ Block  │ Block  │ Block  │ Block  │ Block  │ ...    │
23
        │   0    │   1    │   2    │   3    │   4    │        │
24
        └────────┴────────┴────────┴────────┴────────┴────────┘
25

26
        特点：
27
        → 预先分配固定大小的 blocks
28
        → 按需分配给请求
29
        → 可以随时分配和释放
30
        """
31

32
    def eviction_policy(self):
33
        """
34
        驱逐策略
35
        """
36
        return {
37
            "lru": "Least Recently Used（最近最少使用）",
38
            "fifo": "First In First Out",
39
            "random": "随机驱逐",
40
            "recommendation": "LRU 通常效果最好",
41
            "lru_reason": "近期使用的序列可能还会继续生成",
42
        }
43

44
    def swap_strategy(self):
45
        """
46
        CPU-GPU Swap 策略
47

48
        当 GPU 内存不足时，将部分 KV cache 换出到 CPU
49
        """
50
        return """
51
        场景：处理超长序列
52

53
        1. GPU KV Cache 空间不足
54
        2. 将部分 older blocks 换出到 CPU RAM
55
        3. 继续处理新 tokens
56
        4. 需要时再换回 GPU
57

58
        权衡：
59
        → Swap 开销：PCIe 带宽
60
        → 但比 OOM 好得多
61
        → 可以处理超长序列
62

63
        配置：
64
        --gpu-memory-utilization 0.9  # 使用 90% GPU 内存
65
        --num-swap-blocks 1000       # 允许交换的 blocks 数
66
        """

3.3 内存计算#

1
class KVCacheMemoryCalculation:
2
    """
3
    KV Cache 内存计算
4
    """
5

6
    def per_layer_memory(self, model_config):
7
        """
8
        单层 KV Cache 内存
9

10
        对于 LLaMA-2 7B:
11
        """
12
        return {
13
            "layers": 32,
14
            "hidden_size": 4096,
15
            "num_kv_heads": 32,  # GQA: 8 query heads, 32 kv heads
16
            "head_dim": 128,
17
            "bytes_per_param": 2,  # FP16
18

19
            "per_token_kv": "2 × num_kv_heads × head_dim × bytes",
20
            "calculation": "2 × 32 × 128 × 2 = 16384 bytes = 16 KB",
21

22
            "per_token_total": "layers × per_token_kv",
23
            "total": "32 × 16 KB = 512 KB per token",
24

25
            "examples": {
26
                "1k_tokens": "512 MB",
27
                "4k_tokens": "2 GB",
28
                "8k_tokens": "4 GB",
29
                "32k_tokens": "16 GB",
30
            },
31
        }
32

33
    def total_inference_memory(self, model_size, kv_cache_tokens):
34
        """
35
        总推理内存
36
        """
37
        kv_memory = 512 * kv_cache_tokens  # KB, for 7B model
38

39
        return {
40
            "model_weights": f"{model_size} GB (FP16)",
41
            "kv_cache": f"{kv_memory / 1e6:.1f} GB ({kv_cache_tokens} tokens)",
42
            "activation_memory": "0.5-2 GB (取决于 batch size)",
43
            "overhead": "0.5 GB (框架开销)",
44

45
            "total_for_7b_8k": "14 + 4 + 1 + 0.5 = 19.5 GB",
46
        }

4. Continuous Batching#

4.1 静态 Batching 的问题#

1
class StaticBatchingProblems:
2
    """
3
    静态 Batching 的问题
4
    """
5

6
    def padded_batching(self):
7
        """
8
        Padding 导致的浪费
9
        """
10
        return """
11
        静态 Batching 示意：
12

13
        Batch of 4 requests:
14

15
        Request 1: [tok1, tok2, tok3, tok4, ...] (长度 50)
16
        Request 2: [tok1, tok2, ...]              (长度 10) ← PADDING
17
        Request 3: [tok1, tok2, tok3, ...]        (长度 30) ← PADDING
18
        Request 4: [tok1, tok2, tok3, tok4, tok5]  (长度 5)  ← PADDING
19

20
        最大长度: 50
21
        实际使用: 50 tokens
22
        浪费: 45 tokens worth of computation
23

24
        GPU 利用率: 50 / (50×4) = 12.5%
25
        """
26

27
    def waiting_problem(self):
28
        """
29
        等待问题
30
        """
31
        return """
32
        时间线示意：
33

34
        时间 →→→→
35

36
        Request 1: [████████████████████████████] (长请求)
37
        Request 2: [███] 等待...                   (短请求)
38
        Request 3: [████] 等待...                  (短请求)
39

40
        问题：
41
        → 短请求必须等待长请求完成
42
        → P99 latency 很高
43
        → GPU 资源被长请求阻塞
44
        """

4.2 Continuous Batching 实现#

1
class ContinuousBatching:
2
    """
3
    Continuous Batching 实现
4

5
    也称为 Dynamic Batching 或 Iteration-level Scheduling
6
    """
7

8
    def __init__(self, model, max_batch_size=32):
9
        self.model = model
10
        self.max_batch_size = max_batch_size
11
        self.waiting_requests = []  # 等待处理的请求
12
        self.running_requests = []  # 正在处理的请求
13

14
    def scheduling_loop(self):
15
        """
16
        调度循环
17

18
        每 iteration 执行一次
19
        """
20
        while True:
21
            # Step 1: 添加新请求到运行批次
22
            self._add_new_requests()
23

24
            # Step 2: 执行一次推理
25
            finished = self._run_step()
26

27
            # Step 3: 移除完成的请求
28
            self._remove_finished(finished)
29

30
            # Step 4: 分配资源
31
            self._allocate_kv_blocks()
32

33
            # 如果没有请求了，退出
34
            if len(self.running_requests) == 0 and len(self.waiting_requests) == 0:
35
                break
36

37
    def _add_new_requests(self):
38
        """
39
        添加新请求
40
        """
41
        # 从等待队列中取请求
42
        while (
43
            len(self.running_requests) < self.max_batch_size
44
            and len(self.waiting_requests) > 0
45
        ):
46
            new_request = self.waiting_requests.pop(0)
47
            self.running_requests.append(new_request)
48

49
            # 分配初始 KV blocks
50
            self._allocate_initial_blocks(new_request)
51

52
    def _run_step(self):
53
        """
54
        执行一步推理
55
        """
56
        # 批量执行
57
        batch_queries = [req.current_query for req in self.running_requests]
58
        batch_outputs = self.model.forward(batch_queries)
59

60
        finished = []
61

62
        for i, (req, output) in enumerate(zip(self.running_requests, batch_outputs)):
63
            # 更新请求状态
64
            req.append_token(output.token)
65
            req.current_query = output.token
66

67
            # 检查是否完成
68
            if self._is_finished(req):
69
                finished.append(req)
70

71
        return finished
72

73
    def _allocate_kv_blocks(self):
74
        """
75
        动态分配 KV blocks
76
        """
77
        for req in self.running_requests:
78
            if req.need_new_block():
79
                # 分配新 block
80
                block = self.memory_pool.allocate()
81
                req.block_table.append(block)

4.3 Continuous Batching 效果#

1
Continuous Batching vs 静态 Batching：
2

3
  静态 Batching（batch_size=4）：
4
  ┌─────────────────────────────────────────────────────────────┐
5
  │ Time →→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→│
6
  │                                                                 │
7
  │ Iter 1:  [R1][R2][R3][R4]  (R2,R3,R4 padding)               │
8
  │ Iter 2:  [R1][   -   ][   -   ]  (R2,R3,R4 已完成)           │
9
  │ Iter 3:  [R1][R5][R6][   -   ]  (R5,R6 填补)                 │
10
  │ Iter 4:  [R1][R5][R6][   -   ]                               │
11
  │ ...                                                          │
12
  │                                                                 │
13
  │ 问题：GPU 利用率低，P99 延迟高                                  │
14
  └─────────────────────────────────────────────────────────────┘
15

16
  Continuous Batching：
17
  ┌─────────────────────────────────────────────────────────────┐
18
  │ Time →→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→→│
19
  │                                                                 │
20
  │ Iter 1:  [R1][R2][R3][R4]                                     │
21
  │ Iter 2:  [R1][R5][R6][R7]   ← R2,R3,R4 完成，R5,R6,R7 加入   │
22
  │ Iter 3:  [R1][R5][R6][R7]                                     │
23
  │ Iter 4:  [R1][R5][R8][R9]   ← R6,R7 完成，R8,R9 加入         │
24
  │ ...                                                          │
25
  │                                                                 │
26
  │ 优势：GPU 始终满载，P99 延迟低                                  │
27
  └─────────────────────────────────────────────────────────────┘
28

29
  性能提升：
30
  → 吞吐量提升 5-10x
31
  → P99 latency 降低 3-5x

5. Tensor Parallelism#

5.1 模型并行基础#

1
class TensorParallelism:
2
    """
3
    Tensor Parallelism 实现
4
    """
5

6
    def tensor_parallel_concept(self):
7
        """
8
        Tensor 并行概念
9

10
        将单层的权重矩阵切分到多个 GPU
11
        """
12
        return """
13
        示例：Matrix Multiplication Y = XW
14

15
        单 GPU:
16
        ┌─────────────────────┐
17
        │     X (b, d)       │
18
        │          ×          │
19
        │     W (d, d)       │
20
        │          =          │
21
        │     Y (b, d)       │
22
        └─────────────────────┘
23

24
        2-GPU Tensor Parallel:
25
        ┌──────────────┬──────────────┐
26
        │  GPU 0       │  GPU 1       │
27
        │  X (b, d)    │  X (b, d)    │ ← 复制输入
28
        │       ×      │       ×      │
29
        │  W0 (d, d/2) │  W1 (d, d/2) │ ← 切分权重
30
        │       =      │       =      │
31
        │  Y0 (b, d/2) │  Y1 (b, d/2) │ ← 部分结果
32
        │       ↓      │       ↓      │
33
        │       └── AllReduce ──┘    │
34
        │              ↓              │
35
        │     Y (b, d)               │
36
        └─────────────────────────────┘
37
        """
38

39
    def column_parallel(self):
40
        """
41
        Column Parallel (用于 QKV 投影)
42
        """
43
        return """
44
        QKV Linear Layer:
45

46
        W_qkv: (d_model, 3 * d_model)
47

48
        切分:
49
        GPU 0: W_q0, W_k0, W_v0  → 计算 Q0, K0, V0
50
        GPU 1: W_q1, W_k1, W_v1  → 计算 Q1, K1, V1
51

52
        输出拼接后正常
53
        """
54

55
    def row_parallel(self):
56
        """
57
        Row Parallel (用于输出投影)
58
        """
59
        return """
60
        Output Linear Layer:
61

62
        W_o: (d_model, d_model)
63

64
        切分:
65
        GPU 0: W_o0 (d/2, d)  → 计算 Y0 = X0 @ W_o0
66
        GPU 1: W_o1 (d/2, d)  → 计算 Y1 = X1 @ W_o1
67

68
        AllReduce 求和
69
        """

5.2 vLLM 的 Tensor Parallelism#

1
class VLLMTensorParallel:
2
    """
3
    vLLM Tensor Parallelism
4
    """
5

6
    def multi_gpu_setup(self):
7
        """
8
        多 GPU 设置
9
        """
10
        return """
11
        启动 4-GPU 推理:
12

13
        python -m vllm.entrypoints.openai.api_server \\
14
            --model meta-llama/Llama-2-70b-hf \\
15
            --tensor-parallel-size 4 \\
16
            --gpu-memory-utilization 0.9
17

18
        vLLM 会:
19
        1. 将模型权重切分到 4 个 GPU
20
        2. 使用 NCCL 进行 GPU 间通信
21
        3. 协调调度所有 GPU
22
        """
23

24
    def communication_pattern(self):
25
        """
26
        通信模式
27
        """
28
        return {
29
            "forward_pass": {
30
                "all_reduce": "拼接各 GPU 的部分结果",
31
                "collective": "NCCL AllReduce",
32
                "bandwidth": "NVLink (400+ GB/s)",
33
            },
34
            "attention": {
35
                "query_distribution": "Q 分布到各 GPU",
36
                "key_value_broadcast": "K,V 需要广播",
37
                "attention_output": "各 GPU 计算部分 attention",
38
            },
39
            "memory_bandwidth": "NVLink 带宽是关键瓶颈",
40
        }
41

42
    def memory_distribution(self):
43
        """
44
        内存分布
45
        """
46
        return {
47
            "single_gpu_70b": "140 GB (FP16)",
48
            "per_gpu_70b_tp4": "35 GB + KV cache",
49
            "kv_cache_per_gpu": "取决于 batch size",
50

51
            "nvlink_benefit": "4-GPU 比单 GPU 快 ~3.5x",
52
            "bandwidth_limitation": "超过 8-GPU，增益递减",
53
        }

5.3 Pipeline Parallelism 补充#

1
class PipelineParallelism:
2
    """
3
    Pipeline Parallelism（作为 Tensor Parallelism 的补充）
4
    """
5

6
    def layer_distribution(self):
7
        """
8
        按层分布
9

10
        适用于超大型模型（>100B）
11
        """
12
        return """
13
        8-GPU Pipeline Parallel 示例：
14

15
        GPU 0: Layers 0-9
16
        GPU 1: Layers 10-19
17
        GPU 2: Layers 20-29
18
        GPU 3: Layers 30-39
19
        GPU 4: Layers 40-49
20
        GPU 5: Layers 50-59
21
        GPU 6: Layers 60-69
22
        GPU 7: Layers 70-79
23

24
        前向: 数据流经所有 GPU
25
        反向: 梯度反向流回
26
        """
27

28
    def vllm_combined(self):
29
        """
30
        vLLM 组合并行
31
        """
32
        return """
33
        组合使用 Tensor + Pipeline Parallelism:
34

35
        Total GPUs: 16
36

37
        Tensor Parallelism: 4 (TP)
38
        Pipeline Parallelism: 4 (PP)
39

40
        模型:
41
        - 80 layers
42
        - 每 GPU: 80 / 4 = 20 layers
43
        - 每 layer: 4-way tensor parallel
44

45
        配置示例:
46
        --tensor-parallel-size 4 \\
47
        --pipeline-parallel-size 4
48
        """

6. Prefix Caching#

6.1 共享前缀问题#

1
class PrefixCachingProblem:
2
    """
3
    共享前缀问题
4
    """
5

6
    def common_scenario(self):
7
        """
8
        常见场景
9
        """
10
        return """
11
        LLM 服务的常见模式：
12

13
        System Prompt:
14
        "你是一个有用的AI助手..."
15
        (500 tokens)
16

17
        用户请求:
18
        Request 1: [System] + [User Query 1]
19
        Request 2: [System] + [User Query 2]
20
        Request 3: [System] + [User Query 3]
21
        ...
22

23
        问题：
24
        → System Prompt 的 KV cache 需要重复计算 N 次
25
        → 浪费大量计算和内存
26
        → 在高并发服务中尤其严重
27
        """
28

29
    def traditional_waste(self):
30
        """
31
        传统方式浪费
32
        """
33
        return {
34
            "system_prompt_tokens": 500,
35
            "concurrent_requests": 100,
36
            "repeated_computation": "500 × 99 = 49,500 tokens",
37
            "kv_cache_waste": "49.5x memory usage for prefix",
38
        }

6.2 vLLM Prefix Caching#

1
class VLLMPrefixCaching:
2
    """
3
    vLLM Prefix Caching 实现
4
    """
5

6
    def hash_based_caching(self):
7
        """
8
        基于哈希的缓存
9
        """
10
        return """
11
        vLLM 的 Prefix Caching 策略：
12

13
        1. 计算 KV blocks 的哈希值
14
        ┌────────────┬────────────┐
15
        │ Block Hash│ KV Content │
16
        ├────────────┼────────────┤
17
        │ hash([0-15])│ tokens[0-15] │
18
        │ hash([16-31])│ tokens[16-31] │
19
        └────────────┴────────────┘
20

21
        2. 使用 hash 作为 cache key
22
        ┌────────────┬────────────┐
23
        │ Hash       │ Cached     │
24
        ├────────────┼────────────┤
25
        │ abc123     │ ✓          │
26
        │ def456     │ ✓          │
27
        │ ghi789     │ ✗          │
28
        └────────────┴────────────┘
29

30
        3. 新请求到来时：
31
        - 计算其前缀的哈希
32
        - 检查 cache 中是否存在
33
        - 命中则跳过计算
34
        """
35

36
    def block_table_with_hash(self):
37
        """
38
        带哈希的 Block Table
39
        """
40
        return """
41
        Block Table 结构：
42

43
        Sequence: [prefix] + [A] + [B] + [C]
44

45
        Block Table:
46
        ┌───────┬─────────────┬────────┐
47
        │Block #│ Physical ID │ Hash   │
48
        ├───────┼─────────────┼────────┤
49
        │  0    │ 7           │ abc123 │ ← prefix block
50
        │  1    │ 3           │ def456 │
51
        │  2    │ 9           │ ghi789 │
52
        │  3    │ 2           │ jkl012 │
53
        └───────┴─────────────┴────────┘
54

55
        缓存命中：
56
        - 如果新请求的前缀是 [prefix] + [A]
57
          → blocks 0, 1 命中，直接复用
58
          → 只需计算 [B] + [C]
59
        """
60

61
    def cache_key_calculation(self):
62
        """
63
        Cache Key 计算
64
        """
65
        return '''
66
        def compute_block_hash(tokens):
67
            """计算 block 的哈希值"""
68
            import hashlib
69

70
            # 使用 tokens 内容计算哈希
71
            content = str(tokens)
72
            hash_value = hashlib.sha256(content.encode()).hexdigest()[:16]
73

74
            return hash_value
75

76
        def check_cache(hashes):
77
            """检查缓存命中"""
78
            cached_blocks = {}
79

80
            for hash_value in hashes:
81
                if hash_value in cached_blocks:
82
                    # 命中
83
                    yield cached_blocks[hash_value]
84
                else:
85
                    # 未命中，需要计算
86
                    break
87
        '''

6.3 自动前缀识别#

1
class AutomaticPrefixDetection:
2
    """
3
    自动前缀检测
4
    """
5

6
    def prompt_identification(self):
7
        """
8
        Prompt 识别
9
        """
10
        return """
11
        vLLM 自动识别共享前缀：
12

13
        1. 系统 Prompt 识别
14
        ┌────────────────────────────────────────┐
15
        │ System: "你是AI助手..."                │
16
        │ User 1: "问题1"                       │
17
        │ User 2: "问题2"                       │
18
        │ User 3: "问题3"                       │
19
        └────────────────────────────────────────┘
20
        → System 部分的 KV 全部共享
21

22
        2. 对话历史识别
23
        ┌────────────────────────────────────────┐
24
        │ [History 1] + "回答1"                 │
25
        │ [History 1] + "回答2" + "问题3"       │
26
        └────────────────────────────────────────┘
27
        → History 1 共享
28

29
        3. Few-shot Examples 识别
30
        ┌────────────────────────────────────────┐
31
        │ Example 1: Q + A                      │
32
        │ Example 2: Q + A                      │
33
        │ Example 3: Q (待回答)                 │
34
        └────────────────────────────────────────┘
35
        → Examples 共享
36
        """
37

38
    def performance_impact(self):
39
        """
40
        性能影响
41
        """
42
        return {
43
            "system_prompt_500_tokens": {
44
                "without_cache": "500 tokens × 100 req = 50,000 compute",
45
                "with_cache": "500 tokens × 1 + 少量 = ~500 compute",
46
                "speedup": "100x",
47
            },
48
            "few_shot_1k_tokens": {
49
                "without_cache": "1000 tokens × 1000 req = 1M compute",
50
                "with_cache": "1000 tokens × 1 + 少量 = ~1K compute",
51
                "speedup": "1000x",
52
            },
53
        }

7. 高效 CUDA Kernels#

7.1 FlashAttention 集成#

1
class FlashAttentionIntegration:
2
    """
3
    FlashAttention 集成
4
    """
5

6
    def flash_attention_benefits(self):
7
        """
8
        FlashAttention 的优势
9
        """
10
        return {
11
            "memory_efficiency": "O(N) 而非 O(N²)",
12
            "speed": "2-4x faster than standard attention",
13
            "no_explicit_cache": "无需保存完整 attention matrix",
14
            "numerical_stability": "更好的数值稳定性",
15
        }
16

17
    def vllm_integration(self):
18
        """
19
        vLLM 集成
20
        """
21
        return """
22
        vLLM 的 attention 计算：
23

24
        1. 使用 FlashAttention 作为后端
25
        2. 结合 PagedAttention 的 block 管理
26
        3. 两者结合实现高效推理
27

28
        配置：
29
        --attention-backend FLASH_ATTN  # 或 FLASH_INFER
30

31
        内部实现：
32
        def paged_attention_with_flash(
33
            query, key_cache, value_cache, block_tables, ...
34
        ):
35
            # FlashAttention kernel
36
            # 但 key/value 来自分页的 cache blocks
37
            return flash_attn_varlen_func(
38
                q,  # (total_tokens, num_heads, head_dim)
39
                kv_cache,  # 来自 block table
40
                ...
41
            )
42
        """

7.2 CUDA Graphs#

1
class CUDAGraphs:
2
    """
3
    CUDA Graphs 优化
4
    """
5

6
    def what_is_cuda_graph(self):
7
        """
8
        CUDA Graphs 是什么
9
        """
10
        return """
11
        CUDA Graphs (CUDA 10+)：
12

13
        问题：
14
        CPU-GPU 通信开销大
15
        每个 kernel 启动有延迟
16
        小型 kernel 启动开销明显
17

18
        解决：
19
        将多个 kernel 打包成一个 "graph"
20
        一次性启动整个 graph
21
        减少 CPU-GPU 通信
22

23
        效果：
24
        → 减少 20-30% 的 kernel 启动开销
25
        → 对小 batch size 尤其有效
26
        → decode 阶段效果明显
27
        """
28

29
    def vllm_cuda_graph(self):
30
        """
31
        vLLM 中的 CUDA Graphs
32
        """
33
        return """
34
        vLLM 为不同的 prefill/decode 场景预编译 graphs:
35

36
        1. Prefill Graphs
37
           - 捕获 prefill 阶段的所有 kernel
38
           - 捕获不同输入长度的变体
39

40
        2. Decode Graphs
41
           - 捕获单步 decode 的所有 kernel
42
           - 对于 batch_size=1 优化
43

44
        3. Batch Decode Graphs
45
           - 捕获不同 batch_size 的 decode
46

47
        限制：
48
        → 输入 shape 必须固定
49
        → vLLM 使用 padding 和 reshape 来支持
50

51
        配置：
52
        --enforce-eager  # 禁用 CUDA graphs（调试用）
53
        """

7.3 其他优化#

1
class OtherOptimizations:
2
    """
3
    其他优化
4
    """
5

6
    def weight_only_quantization(self):
7
        """
8
        权重量化推理
9
        """
10
        return """
11
        Weight-Only Quantization：
12

13
        模型权重量化，激活值保持 FP16/BF16
14

15
        支持格式：
16
        - INT8 (W8A16)
17
        - INT4 (W4A16) - 显存减半
18

19
        效果：
20
        - 70B 模型: 140GB → 70GB
21
        - 性能损失 < 1%
22

23
        配置：
24
        --quantization awq  # 或 gptq, squeezellm
25
        """
26

27
    def speculative_decoding(self):
28
        """
29
        投机解码
30
        """
31
        return """
32
        Speculative Decoding:
33

34
        使用小模型生成多个候选 tokens
35
        大模型验证并修正
36

37
        流程：
38
        1. 小模型生成 k 个候选 token
39
        2. 大模型并行验证
40
        3. 接受所有一致的 tokens
41

42
        效果：
43
        → decode 加速 2-3x
44
        → 保持输出质量
45

46
        vLLM 支持：
47
        --speculative-model <model_name>
48
        --speculative-draft-tokens 5
49
        """
50

51
    def grouped_attention(self):
52
        """
53
        分组注意力（GQA/MQA）
54
        """
55
        return """
56
        Grouped Query Attention (GQA):
57

58
        减少 KV cache 大小
59

60
        MQA: 1 个 KV head
61
        GQA: 4-8 个 KV heads
62
        MHA: 32 个 KV heads
63

64
        vLLM 优化：
65
        - 高效实现 GQA
66
        - 减少内存访问
67
        - 加速 decode
68
        """

8. 实战部署#

8.1 快速启动#

1
class QuickStart:
2
    """
3
    快速启动 vLLM 服务
4
    """
5

6
    def basic_server(self):
7
        """
8
        基本服务器
9
        """
10
        return """
11
        # 安装
12
        pip install vllm
13

14
        # 启动 OpenAI 兼容 API
15
        python -m vllm.entrypoints.openai.api_server \\
16
            --model meta-llama/Llama-2-7b-hf \\
17
            --trust-remote-code \\
18
            --gpu-memory-utilization 0.9
19

20
        # 测试
21
        curl http://localhost:8000/v1/completions \\
22
            -H "Content-Type: application/json" \\
23
            -d '{
24
                "model": "meta-llama/Llama-2-7b-hf",
25
                "prompt": "The capital of France is",
26
                "max_tokens": 50
27
            }'
28
        """
29

30
    def hf_backend(self):
31
        """
32
        HuggingFace 模型
33
        """
34
        return """
35
        # 直接加载 HuggingFace 模型
36
        python -m vllm.entrypoints.openai.api_server \\
37
            --model mistralai/Mistral-7B-Instruct-v0.2 \\
38
            --tokenizer mistralai/Mistral-7B-Instruct-v0.2 \\
39
            --task auto
40

41
        # 支持的模型自动检测
42
        # 自动选择合适的 architecture
43
        """

8.2 性能调优#

1
class PerformanceTuning:
2
    """
3
    性能调优
4
    """
5

6
    def critical_params(self):
7
        """
8
        关键参数
9
        """
10
        return {
11
            "--tensor-parallel-size": {
12
                "description": "Tensor parallel GPU 数",
13
                "default": 1,
14
                "7b_model": "1 (单卡 24GB 足够)",
15
                "70b_model": "4 (需要多卡)",
16
                "70b_tp8": "8 (更快但需要更多卡)",
17
            },
18
            "--gpu-memory-utilization": {
19
                "description": "GPU 内存使用比例",
20
                "default": 0.9,
21
                "tuning": "0.85 for more KV cache headroom",
22
                "tradeoff": "高利用率 = 更多 batch，但可能 OOM",
23
            },
24
            "--max-model-len": {
25
                "description": "最大序列长度",
26
                "default": "模型预设",
27
                "increase": "支持更长上下文，但增加内存",
28
                "calculation": "max_len × kv_cache_per_token × layers",
29
            },
30
            "--block-size": {
31
                "description": "KV cache block 大小",
32
                "default": 16,
33
                "tuning": "16 是最佳平衡",
34
                "note": "过大增加碎片，过小增加管理开销",
35
            },
36
        }
37

38
    def advanced_config(self):
39
        """
40
        高级配置
41
        """
42
        return """
43
        # 高级配置示例
44

45
        python -m vllm.entrypoints.openai.api_server \\
46
            --model meta-llama/Llama-2-70b-hf \\
47
            \\
48
            # 并行配置
49
            --tensor-parallel-size 4 \\
50
            --pipeline-parallel-size 1 \\
51
            \\
52
            # 内存配置
53
            --gpu-memory-utilization 0.92 \\
54
            --max-model-len 8192 \\
55
            --max-num-batched-tokens 32768 \\
56
            --max-num-seqs 256 \\
57
            \\
58
            # 量化配置
59
            --quantization fp8 \\
60
            --enforce-eager \\
61
            \\
62
            # 其他
63
            --download-dir ./model_cache \\
64
            --dtype half \\
65
            --enforce-ranked-decoder
66

67
        # 监控
68
        # --metrics-backend prometheus
69
        """
70

71
    def batch_size_tuning(self):
72
        """
73
        Batch Size 调优
74
        """
75
        return {
76
            "max_num_seqs": "同时处理的最大请求数",
77
            "max_num_batched_tokens": "batch 中总 token 数上限",
78

79
            "throughput_mode": {
80
                "max_num_seqs": 256,
81
                "max_num_batched_tokens": 8192,
82
                "适合": "高吞吐场景",
83
            },
84
            "latency_mode": {
85
                "max_num_seqs": 32,
86
                "max_num_batched_tokens": 2048,
87
                "适合": "低延迟场景",
88
            },
89
        }

8.3 监控与调试#

1
class MonitoringDebugging:
2
    """
3
    监控与调试
4
    """
5

6
    def metrics(self):
7
        """
8
        可用指标
9
        """
10
        return """
11
        vLLM 暴露 Prometheus 指标:
12

13
        # 服务指标
14
        vllm:num_requests_total
15
        vllm:num_requests_succeeded
16
        vllm:num_requests_failed
17

18
        # 延迟指标
19
        vllm:request_latency_seconds
20
        vllm:prefill_latency_seconds
21
        vllm:decode_latency_seconds
22

23
        # 吞吐指标
24
        vllm:generated_tokens_total
25
        vllm:input_tokens_total
26

27
        # GPU 指标
28
        vllm:gpu_cache_usage
29
        vllm:num_available_blocks
30

31
        访问：
32
        http://localhost:8000/metrics
33
        """
34

35
    def debugging_commands(self):
36
        """
37
        调试命令
38
        """
39
        return """
40
        # 查看 GPU 利用率
41
        nvidia-smi -l 1
42

43
        # 查看 vLLM 日志
44
        # vLLM 输出详细日志
45

46
        # 禁用 CUDA graphs（更容易调试）
47
        --enforce-eager
48

49
        # 禁用 prefix caching（测试缓存效果）
50
        --disable-preemption
51

52
        # 使用 eager 模式（不使用 CUDA graphs）
53
        --enforce-eager
54
        """

9. OpenAI 兼容 API#

9.1 Chat Completions API#

1
class OpenAIAPI:
2
    """
3
    OpenAI 兼容 API
4
    """
5

6
    def chat_completions(self):
7
        """
8
        Chat Completions
9
        """
10
        return '''
11
        # Python client
12
        from openai import OpenAI
13

14
        client = OpenAI(
15
            api_key="EMPTY",
16
            base_url="http://localhost:8000/v1",
17
        )
18

19
        response = client.chat.completions.create(
20
            model="meta-llama/Llama-2-7b-hf",
21
            messages=[
22
                {"role": "system", "content": "你是AI助手。"},
23
                {"role": "user", "content": "解释量子计算。"},
24
            ],
25
            temperature=0.7,
26
            max_tokens=500,
27
        )
28

29
        print(response.choices[0].message.content)
30
        '''
31

32
    def completions_api(self):
33
        """
34
        Completions API
35
        """
36
        return '''
37
        # 直接补全
38
        response = client.completions.create(
39
            model="meta-llama/Llama-2-7b-hf",
40
            prompt="量子计算是一种",
41
            max_tokens=100,
42
            temperature=0.8,
43
        )
44

45
        print(response.choices[0].text)
46
        '''
47

48
    def embedding_api(self):
49
        """
50
        Embedding API
51
        """
52
        return '''
53
        # 嵌入向量（如果模型支持）
54
        response = client.embeddings.create(
55
            model="sentence-transformers/all-MiniLM-L6-v2",
56
            input="Hello, world!",
57
        )
58

59
        print(response.data[0].embedding)
60
        '''

9.2 Streaming#

1
class StreamingAPI:
2
    """
3
    Streaming 支持
4
    """
5

6
    def streaming_chat(self):
7
        """
8
        流式聊天
9
        """
10
        return '''
11
        # 流式响应
12
        stream = client.chat.completions.create(
13
            model="meta-llama/Llama-2-7b-hf",
14
            messages=[{"role": "user", "content": "写一首诗"}],
15
            stream=True,
16
            max_tokens=200,
17
        )
18

19
        for chunk in stream:
20
            if chunk.choices[0].delta.content:
21
                print(chunk.choices[0].delta.content, end="", flush=True)
22
        '''
23

24
    def use_cases(self):
25
        """
26
        Streaming 适用场景
27
        """
28
        return {
29
            "chatbot": "实时显示 AI 响应",
30
            "long_content": "减少等待感知时间",
31
            "real_time": "需要实时反馈的应用",
32
        }

10. 生产环境最佳实践#

10.1 部署架构#

1
class DeploymentArchitecture:
2
    """
3
    生产部署架构
4
    """
5

6
    def single_node(self):
7
        """
8
        单节点部署
9
        """
10
        return """
11
        单节点 4-GPU 部署：
12

13
        ┌─────────────────────────────────────────────┐
14
        │              Load Balancer                   │
15
        │           (nginx / traefik)                  │
16
        └──────────┬──────────┬──────────┬────────────┘
17
                   │          │          │
18
              ┌────▼───┐ ┌────▼───┐ ┌────▼───┐ ┌────▼───┐
19
              │ vLLM   │ │ vLLM   │ │ vLLM   │ │ vLLM   │
20
              │ GPU 0  │ │ GPU 1  │ │ GPU 2  │ │ GPU 3  │
21
              │ :8000  │ │ :8001  │ │ :8002  │ │ :8003  │
22
              └────────┘ └────────┘ └────────┘ └────────┘
23

24
        vLLM 内部已经处理多 GPU
25
        每个实例只用 1 个 GPU
26
        """
27

28
    def multi_node(self):
29
        """
30
        多节点部署
31
        """
32
        return """
33
        多节点部署：
34

35
        Node 0 (4x A100): vLLM TP=4
36
        Node 1 (4x A100): vLLM TP=4
37
        Node 2 (4x A100): vLLM TP=4
38
        Node 3 (4x A100): vLLM TP=4
39

40
        使用 Ray 作为协调器：
41
        ray start --head
42
        ray start --node-ip-address=<node_ip>
43

44
        vLLM 自动管理多节点分布式推理
45
        """
46

47
    def kubernetes(self):
48
        """
49
        Kubernetes 部署
50
        """
51
        return """
52
        # Deployment.yaml
53
        apiVersion: apps/v1
54
        kind: Deployment
55
        metadata:
56
          name: vllm-server
57
        spec:
58
          replicas: 2
59
          template:
60
            spec:
61
              containers:
62
              - name: vllm
63
                image: vllm/vllm-openai:latest
64
                resources:
65
                  limits:
66
                    nvidia.com/gpu: 4
67
                args:
68
                - --model=meta-llama/Llama-2-70b-hf
69
                - --tensor-parallel-size=4
70
                - --gpu-memory-utilization=0.9
71
                ports:
72
                - containerPort: 8000
73
        """

10.2 高可用配置#

1
class HighAvailability:
2
    """
3
    高可用配置
4
    """
5

6
    def health_check(self):
7
        """
8
        健康检查
9
        """
10
        return """
11
        # Liveness Probe
12
        livenessProbe:
13
          httpGet:
14
            path: /health
15
            port: 8000
16
          initialDelaySeconds: 30
17
          periodSeconds: 10
18

19
        # Readiness Probe
20
        readinessProbe:
21
          httpGet:
22
            path: /health
23
            port: 8000
24
          initialDelaySeconds: 10
25
          periodSeconds: 5
26

27
        # 健康检查端点
28
        GET /health
29
        Response: {"status": "ok", "model": "..."}
30
        """
31

32
    def rate_limiting(self):
33
        """
34
        速率限制
35
        """
36
        return """
37
        # 使用 nginx 限流
38
        limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
39

40
        server {
41
            location /v1/completions {
42
                limit_req zone=api burst=20;
43
            }
44
        }
45
        """
46

47
    def autoscaling(self):
48
        """
49
        自动扩缩容
50
        """
51
        return """
52
        # KEDA + 自定义指标
53

54
        # 扩缩容规则
55
        triggers:
56
        - type: prometheus
57
          metadata:
58
            metricName: vllm_pending_requests
59
            query: sum(vllm:num_requests_waiting)
60
            threshold: "10"
61
        """

10.3 成本优化#

1
class CostOptimization:
2
    """
3
    成本优化
4
    """
5

6
    def instance_selection(self):
7
        """
8
        实例选择
9
        """
10
        return {
11
            "7b_model": {
12
                "min_gpu": "RTX 3090 24GB, A10G 24GB",
13
                "recommended": "A10G or L4",
14
                "price_per_hour": "$1.5-2.5",
15
            },
16
            "13b_model": {
17
                "min_gpu": "A100 40GB, A6000 48GB",
18
                "recommended": "A100 40GB",
19
                "price_per_hour": "$3-4",
20
            },
21
            "70b_model": {
22
                "min_gpu": "A100 80GB × 4",
23
                "recommended": "A100 80GB × 4",
24
                "price_per_hour": "$12-15",
25
            },
26
        }
27

28
    def quantization_savings(self):
29
        """
30
        量化节省
31
        """
32
        return {
33
            "fp16_70b": "140 GB GPU memory",
34
            "int8_70b": "70 GB GPU memory",
35
            "int4_70b": "35 GB GPU memory",
36

37
            "fp16_to_int8": "50% memory reduction",
38
            "int8_to_int4": "50% memory reduction",
39

40
            "inference_savings": "可以用更少的 GPU",
41
        }

11. 核心公式汇总#

11.1 KV Cache 内存#

M_{\text{KV}} = 2 \times L \times N_{\text{kv}} \times D \times B \times S

其中 $L$ 是层数， $N_{\text{kv}}$ 是 KV head 数， $D$ 是 head 维度， $B$ 是字节数， $S$ 是序列长度。

11.2 Attention 计算（FlashAttention）#

\text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V})_i = \frac{\sum_{j=1}^{N} \exp\left(\frac{\mathbf{q}_i \mathbf{k}_j^T}{\sqrt{d}}\right) \mathbf{v}_j}{\sum_{j=1}^{N} \exp\left(\frac{\mathbf{q}_i \mathbf{k}_j^T}{\sqrt{d}}\right)}

FlashAttention 通过分块计算和在线 softmax 归一化，将内存复杂度从 $O(N^2)$ 降低到 $O(N)$ 。

11.3 Batch 吞吐量#

T_{\text{batch}} = \frac{B \times S_{\text{avg}}}{\text{Latency}_{\text{per\_iter}}}

其中 $B$ 是 batch size， $S_{\text{avg}}$ 是平均生成长度。

12. 总结#

12.1 vLLM 核心优势#

1
┌─────────────────────────────────────────────────────────────┐
2
│                   vLLM 核心优势                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  1. PagedAttention                                          │
6
│     → 消除 KV Cache 内存碎片                                 │
7
│     → 显存利用率提升 60%                                     │
8
│     → 支持超长上下文                                         │
9
│                                                              │
10
│  2. Continuous Batching                                     │
11
│     → GPU 利用率最大化                                       │
12
│     → 吞吐量提升 10-24x                                      │
13
│     → P99 延迟显著降低                                       │
14
│                                                              │
15
│  3. Prefix Caching                                          │
16
│     → 共享系统提示的计算                                     │
17
│     → 高并发场景效果显著                                     │
18
│                                                              │
19
│  4. 高效 CUDA Kernels                                        │
20
│     → FlashAttention 集成                                    │
21
│     → CUDA Graphs 加速                                       │
22
│     → 多 GPU Tensor Parallelism                              │
23
│                                                              │
24
└─────────────────────────────────────────────────────────────┘

12.2 选型指南#

1
vLLM vs 其他推理引擎：
2

3
  vLLM：
4
    ✓ 最高吞吐量
5
    ✓ PagedAttention 内存优化
6
    ✓ OpenAI 兼容 API
7
    ✓ 活跃社区
8
    ✗ 仅 GPU
9
    ✗ 部分模型支持有限
10

11
  Text Generation Inference (TGI)：
12
    ✓ 优秀的长序列支持
13
    ✓ FlashDecoding 优化
14
    ✓ HuggingFace 深度集成
15
    ✗ 吞吐量略低
16

17
  lmdeploy (TurboMind)：
18
    ✓ 中国团队优化
19
    ✓ 高并发
20
    ✓ 量化优化好
21

22
  选择建议：
23
    → 高吞吐场景: vLLM
24
    → 长序列场景: TGI
25
    → 中国生态: lmdeploy

12.3 性能对比#

1
性能对比（7B 模型，RTX 3090）：
2

3
  指标              HF Transformers    vLLM
4
  ─────────────────────────────────────────────────
5
  吞吐量 (tok/s)    ~30               ~800
6
  P50 latency (ms)  ~150              ~50
7
  P99 latency (ms)  ~500              ~120
8
  显存占用 (GB)     ~20               ~12
9
  Max batch size    4                 64
10
  ─────────────────────────────────────────────────
11

12
  vLLM 吞吐量提升: ~26x
13
  显存节省: ~40%

参考资料#

Kwon, W., et al. (2023). “Efficient Memory Management for Large Language Model Serving with PagedAttention.” SOSP.
Dao, T., et al. (2022). “FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness.” NeurIPS.
Yu, G. I., et al. (2022). “Orca: A Distributed Serving System for Transformer-Based Generative Models.” OSDI.
vLLM Team. “vLLM: Easy, Fast, and Cheap LLM Serving with PagedAttention.” GitHub.
Chen, L., et al. (2023). “FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning.” ICLR.
Shah, A., et al. (2023). “Efficiently Serving Large Language Models.” Blog.
NVIDIA. “CUDA Graphs Documentation.” NVIDIA Developer.
Huang, Y., et al. (2024). “Tensor Parallelism in Large Language Model Inference.” arXiv.