第一部分：项目概览与核心功能

一、项目简介：什么是 Mooncake？

Mooncake 是阿里巴巴 Moonshot AI 公司推出的 Kimi 大语言模型服务的底层推理平台。它采用了一种革命性的架构设计——以 KVCache 为中心的分离式架构（KVCache-centric Disaggregated Architecture），专门用于大规模 LLM 服务。

简单来说，Mooncake 解决了一个核心问题：如何在保证服务质量（延迟、吞吐量）的前提下，最大化 LLM 服务的资源利用率和处理能力。

什么是 KVCache？

在 LLM 推理过程中，模型需要计算和存储每一层的键值对（Key-Value pairs），这些键值对被称为 KVCache。KVCache 的作用是：

• 避免重复计算之前处理过的 token
• 加速生成过程
• 占用大量内存资源

什么是分离式架构？

传统架构中，预填充（Prefill，处理输入）和解码（Decode，生成输出）在同一个 GPU 上进行。Mooncake 将它们分离：

• Prefill 集群：专门处理输入，计算密集
• Decode 集群：专门生成输出，内存密集
• KVCache 池：存储和共享 KVCache，连接两个集群

核心创新：

Mooncake 不仅分离了 Prefill 和 Decode 集群，还充分利用了 GPU 集群中闲置的 CPU、DRAM、SSD 和 NIC 资源，构建了一个分布式的 KVCache 池。这种设计实现了"以存换算"——用更多的存储资源换取更少的计算资源消耗。

二、为什么需要 Mooncake？

在了解 Mooncake 之前，我们先看看当前 LLM 服务面临的挑战：

1. 资源利用率低

传统架构中：

• Prefill 阶段：GPU 计算密集，但内存利用率低
• Decode 阶段：GPU 内存密集，但计算利用率低
• 同一 GPU 上两种负载相互干扰，效率低下

2. KVCache 管理困难

• KVCache 占用大量 GPU 内存
• 不同请求之间无法共享 KVCache
• 长上下文场景下内存压力巨大

3. 服务质量难以保证

• Prefill 和 Decode 的延迟特性不同
• 难以同时满足吞吐量和延迟要求
• 过载情况下容易服务降级

4. 扩展性受限

• 单节点内存容量有限
• 难以支持超长上下文
• 多节点协同复杂

5. 成本高昂

• GPU 资源昂贵
• 需要大量 GPU 来应对峰值负载
• 资源浪费严重

Mooncake 通过创新的架构设计，系统性地解决了这些问题。

三、核心功能特性

3.1 KVCache-centric 分离架构

架构组成：

┌─────────────────────────────────────────┐
│          Prefill Cluster                │
│   (计算密集，处理输入)                    │
│   GPU: 高计算能力                        │
└─────────────────────────────────────────┘
                ↓ KVCache
┌─────────────────────────────────────────┐
│       Disaggregated KVCache Pool        │
│   (分布式 KVCache 存储)                   │
│   利用闲置的 CPU/DRAM/SSD/NIC            │
└─────────────────────────────────────────┘
                ↓ KVCache
┌─────────────────────────────────────────┐
│          Decode Cluster                 │
│   (内存密集，生成输出)                    │
│   GPU: 高内存容量                        │
└─────────────────────────────────────────┘

优势：

• Prefill 和 Decode 独立扩展
• 资源利用率最大化
• 延迟和吞吐量可独立优化

3.2 Transfer Engine：高效数据传输引擎

Transfer Engine 是 Mooncake 的核心组件，提供统一的数据传输接口：

支持的协议：

• TCP：基础网络协议
• RDMA：远程直接内存访问，零拷贝传输
• CXL/Shared-Memory：高速互联
• NVMe-oF：NVMe over Fabric，存储网络化

性能优势：

• 相比 Gloo（PyTorch 分布式）：延迟降低 50%+
• 相比传统 TCP：吞吐量提升 3-5 倍
• 零拷贝传输，CPU 开销极低

应用场景：

• KVCache 在节点间传输
• 模型权重分发
• Checkpoint 存储

3.3 Mooncake Store：分布式 KVCache 存储

基于 Transfer Engine 构建的分布式 KVCache 存储系统：

特性：

• 分布式池化：跨节点的 KVCache 共享
• 分层存储：GPU VRAM → DRAM → SSD
• 智能调度：根据访问模式自动迁移
• 高效复用：相同前缀的请求共享 KVCache

存储层次：

Level 0: GPU VRAM (最快，容量小)
    ↓
Level 1: Host DRAM (快，容量中)
    ↓
Level 2: Remote DRAM (较快，容量大)
    ↓
Level 3: SSD/NVMe (慢，容量最大)

3.4 P2P Store：点对点对象存储

用于在集群节点间共享临时对象：

应用场景：

• 模型 Checkpoint 分发
• 训练中间结果共享
• 大文件传输

特性：

• 避免单点带宽饱和
• 支持 RDMA 加速
• 自动负载均衡

3.5 KVCache-centric 调度器

Mooncake 的核心调度器，负责：

调度策略：

• 全局视角：考虑所有集群的资源状态
• 预测性调度：预测请求的资源需求
• 早期拒绝：过载时提前拒绝，避免资源浪费
• SLO 感知：保证延迟相关的服务水平目标

优化目标：

• 最大化有效吞吐量（直接影响收入）
• 满足延迟 SLO（保证用户体验）
• 最小化资源浪费（降低成本）

3.6 弹性专家并行（Elastic Expert Parallelism）

为 MoE（Mixture of Experts）模型提供弹性和容错支持：

特性：

• 自动故障检测
• 动态路由到健康的 Expert
• 与 EPLB（Expert Parallel Load Balancer）集成
• 支持运行时扩缩容

应用：

• Kimi K2 模型（1T 参数）部署
• 千卡级分布式推理
• 故障自动恢复

3.7 广泛的生态系统集成

Mooncake 已被多个主流 LLM 推理系统集成：

vLLM：

• 官方支持 Mooncake Transfer Engine
• PD 分离式推理
• Mooncake Store 作为 KV Connector

SGLang：

• PD 分离支持
• HiCache（分层 KV 缓存）后端
• EPD（Encode-Prefill-Decode）分离

LMDeploy：

• PD 分离后端
• 高性能推理

TensorRT-LLM：

• KVCache 传输集成
• NVIDIA 官方支持

其他：

• LMCache：远程连接器
• vLLM-Ascend：华为昇腾支持
• xLLM：京东开源推理引擎

四、应用情况与成果

4.1 生产环境规模

Kimi 服务：

• 数千节点运行
• 日处理超过 1000 亿 token
• 支持超长上下文（200K+ tokens）

性能提升：

• NVIDIA A800 集群：处理能力提升 115%
• NVIDIA H800 集群：处理能力提升 107%
• 相比基线方法：吞吐量提升 59%~525%

4.2 Kimi K2 模型部署

规模：

• 128 张 H200 GPU
• 1T 参数模型
• 大规模专家并行

性能：

• Prefill 吞吐量：224k tokens/sec
• Decode 吞吐量：288k tokens/sec
• Checkpoint 更新：数千 GPU，约 20 秒

4.3 学术认可

FAST 2025 最佳论文奖：

• USENIX 文件与存储技术会议
• 存储领域顶级会议（CCF A 类）
• Erik Riedel Best Paper Award

论文发表：

• FAST 2025：Mooncake 架构论文
• arXiv：技术报告
• 多篇中文技术博客

4.4 开源生态

开源组件：

• Transfer Engine：核心传输引擎
• Mooncake Store：分布式 KVCache 存储
• P2P Store：点对点对象存储
• 真实工作负载数据

社区贡献：

• 加入 PyTorch 生态系统
• 多家厂商采用（阿里、蚂蚁等）
• 持续更新和优化

---

第二部分：技术原理与体系架构

五、核心架构设计

5.1 整体架构

Mooncake 采用分层架构设计：

┌──────────────────────────────────────────────┐
│           Application Layer                   │
│   (Kimi, vLLM, SGLang, LMDeploy...)          │
└──────────────────────────────────────────────┘
                      ↓
┌──────────────────────────────────────────────┐
│           Mooncake Backend                    │
│   - Scheduler (调度器)                        │
│   - KVCache Manager (缓存管理)                │
│   - EP Manager (专家并行管理)                 │
└──────────────────────────────────────────────┘
                      ↓
┌──────────────────────────────────────────────┐
│           Storage Layer                       │
│   - Mooncake Store (分布式 KVCache)          │
│   - P2P Store (点对点对象存储)                │
└──────────────────────────────────────────────┘
                      ↓
┌──────────────────────────────────────────────┐
│           Transfer Engine                     │
│   - RDMA / TCP / CXL / NVMe-oF               │
│   - Topology-aware routing                   │
└──────────────────────────────────────────────┘
                      ↓
┌──────────────────────────────────────────────┐
│           Hardware Layer                      │
│   - GPU / NPU (NVIDIA, AMD, Huawei...)       │
│   - NIC (RDMA, EFA, eRDMA...)                │
│   - Storage (NVMe, SSD, CXL...)              │
└──────────────────────────────────────────────┘

5.2 Prefill-Decode 分离原理

传统架构的问题：

传统方式（同一 GPU）：
┌─────────────────────────┐
│  GPU                    │
│  ┌─────────────────┐   │
│  │ Prefill (计算密集)│   │  ← GPU 利用率高
│  └─────────────────┘   │
│  ┌─────────────────┐   │
│  │ Decode (内存密集) │   │  ← 内存压力大
│  └─────────────────┘   │
│  资源竞争，效率低下      │
└─────────────────────────┘

Mooncake 分离架构：

分离方式：
┌──────────────────┐      ┌──────────────────┐
│  Prefill GPU     │      │  Decode GPU      │
│  - 高计算能力     │      │  - 高内存容量     │
│  - 低内存需求     │      │  - 低计算需求     │
│  - 批量处理      │ ───→ │  - 串行生成      │
└──────────────────┘      └──────────────────┘
       ↓                          ↑
       └──── KVCache Pool ────────┘

优势分析：

1. 资源解耦：

   • Prefill：需要高计算能力，低内存
   • Decode：需要高内存容量，低计算
   • 各自选择最优硬件配置

2. 独立扩展：

   • Prefill 集群：根据输入负载扩展
   • Decode 集群：根据输出负载扩展
   • 灵活应对不同负载模式

3. 延迟优化：

   • Prefill 延迟：与输入长度相关
   • Decode 延迟：与输出长度相关
   • 可独立优化

5.3 KVCache 池化原理

KVCache 的生命周期：

1. Prefill 阶段：
   输入 tokens → 计算 KVCache → 存储到池

2. 传输阶段：
   KVCache 从 Prefill 节点 → KVCache Pool → Decode 节点

3. Decode 阶段：
   从池加载 KVCache → 生成输出 tokens

4. 复用阶段：
   相同前缀的请求 → 复用已有 KVCache → 节省计算

KVCache 复用机制：

请求 1: "请介绍一下人工智能"
        ↓
        生成 KVCache_1

请求 2: "请介绍一下人工智能的发展历史"
        ↓
        前缀匹配："请介绍一下人工智能"
        ↓
        复用 KVCache_1，只计算新增部分
        ↓
        节省大量计算

分布式存储策略：

本地节点（GPU VRAM）：
- 最近使用的 KVCache
- 高频访问的数据
- 延迟最低

同机架节点（RDMA）：
- 较近的 KVCache
- 中频访问的数据
- 延迟中等

远程节点（TCP/RDMA）：
- 冷数据
- 大容量存储
- 延迟较高

5.4 Transfer Engine 设计

架构层次：

┌────────────────────────────────────┐
│    Application API                 │
│    - batch_transfer()              │
│    - register_segment()            │
└────────────────────────────────────┘
                ↓
┌────────────────────────────────────┐
│    Transfer Engine Core            │
│    - Topology Discovery            │
│    - Path Selection                │
│    - Batch Scheduling              │
└────────────────────────────────────┘
                ↓
┌────────────────────────────────────┐
│    Protocol Layer                  │
│    - RDMA Protocol                 │
│    - TCP Protocol                  │
│    - CXL Protocol                  │
│    - NVMe-oF Protocol              │
└────────────────────────────────────┘
                ↓
┌────────────────────────────────────┐
│    Hardware Abstraction            │
│    - NIC Abstraction               │
│    - Memory Abstraction            │
│    - Storage Abstraction           │
└────────────────────────────────────┘

关键特性：

1. 拓扑感知：

   • 自动发现网络拓扑
   • 选择最优传输路径
   • 避免 NUMA 冲突

2. 批量传输：

   • 合并多个小传输请求
   • 减少 API 调用开销
   • 提高带宽利用率

3. 零拷贝：

   • RDMA 直接内存访问
   • 避免 CPU 拷贝
   • 降低延迟

4. 多路径：

   • 同时使用多条网络路径
   • 负载均衡
   • 容错

性能对比：

传输方式	延迟	吞吐量	CPU 开销
TCP	高	低	高
Gloo	中	中	中
Mooncake RDMA	低	高	极低

5.5 调度器设计

调度目标：

最大化：有效吞吐量（直接影响收入）

约束条件：
1. 延迟 SLO：TTFT < SLO_ttft, TBT < SLO_tbt
2. 资源限制：GPU 内存、计算能力
3. 公平性：不同优先级请求的公平调度

调度策略：

1. 全局调度：

   • 考虑所有集群的资源状态
   • 全局最优决策
   • 避免局部最优陷阱

2. 预测性调度：

   • 预测请求的资源需求
   • 预测执行时间
   • 提前规划资源分配

3. 早期拒绝：

   • 检测过载情况
   • 提前拒绝无法满足 SLO 的请求
   • 避免资源浪费

4. KVCache 感知：

   • 优先调度可复用 KVCache 的请求
   • 减少重复计算
   • 提高效率

调度流程：

请求到达
    ↓
预测资源需求
    ↓
检查 KVCache 复用可能性
    ↓
评估能否满足 SLO
    ├─ 能 → 接受请求，分配资源
    └─ 不能 → 早期拒绝
    ↓
选择最优 Prefill 节点
    ↓
执行 Prefill，生成 KVCache
    ↓
传输 KVCache 到 Decode 节点
    ↓
执行 Decode，生成输出

六、关键技术实现

6.1 内存管理

分层内存池：

class MemoryPool {
    // Level 0: GPU VRAM
    GPUMemoryPool gpu_pool;

    // Level 1: Host DRAM
    HostMemoryPool host_pool;

    // Level 2: Remote DRAM
    RemoteMemoryPool remote_pool;

    // Level 3: SSD
    SSDPool ssd_pool;

    // 智能分配
    void* allocate(size_t size, AccessPattern pattern) {
        if (pattern == HOT) return gpu_pool.alloc(size);
        if (pattern == WARM) return host_pool.alloc(size);
        if (pattern == COLD) return remote_pool.alloc(size);
        return ssd_pool.alloc(size);
    }
};

内存复用策略：

• 引用计数管理
• LRU 淘汰
• 预取和预加载

6.2 网络优化

RDMA 传输：

// RDMA 写操作（零拷贝）
void rdma_write(void* local_addr, void* remote_addr, size_t size) {
    // 1. 注册内存区域
    ibv_mr* mr = ibv_reg_mr(pd, local_addr, size, IBV_ACCESS_LOCAL_WRITE);

    // 2. 创建工作请求
    ibv_send_wr wr;
    wr.opcode = IBV_WR_RDMA_WRITE;
    wr.send_flags = IBV_SEND_SIGNALED;

    // 3. 提交到发送队列
    ibv_post_send(qp, &wr, &bad_wr);

    // 4. 等待完成
    poll_cq(cq, 1, &wc);
}

拓扑感知路由：

// 选择最优 NIC
NIC* select_best_nic(Node* src, Node* dst) {
    // 1. 获取拓扑信息
    Topology topo = get_topology();

    // 2. 计算候选 NIC
    vector<NIC*> candidates = topo.get_nics(src);

    // 3. 评估每个 NIC
    NIC* best = nullptr;
    int min_hops = INT_MAX;

    for (NIC* nic : candidates) {
        int hops = topo.hops(nic, dst);
        if (hops < min_hops) {
            min_hops = hops;
            best = nic;
        }
    }

    return best;
}

6.3 KVCache 管理

KVCache 索引：

class KVCacheIndex {
    // 前缀树索引
    struct TrieNode {
        unordered_map<Token, TrieNode*> children;
        KVCache* cache;
        int ref_count;
    };

    TrieNode* root;

    // 查找最长匹配前缀
    KVCache* find_prefix(vector<Token>& tokens) {
        TrieNode* node = root;
        for (Token t : tokens) {
            if (node->children.count(t) == 0) break;
            node = node->children[t];
        }
        return node->cache;
    }

    // 插入新 KVCache
    void insert(vector<Token>& tokens, KVCache* cache) {
        TrieNode* node = root;
        for (Token t : tokens) {
            if (node->children.count(t) == 0) {
                node->children[t] = new TrieNode();
            }
            node = node->children[t];
        }
        node->cache = cache;
    }
};

KVCache 传输：

// 传输 KVCache 到 Decode 节点
void transfer_kvcache(KVCache* cache, Node* decode_node) {
    // 1. 序列化 KVCache
    Buffer* buf = serialize(cache);

    // 2. 使用 Transfer Engine 传输
    TransferEngine* te = get_transfer_engine();
    te->batch_transfer({
        .src = buf->addr,
        .dst = decode_node->kvcache_addr,
        .size = buf->size,
        .protocol = RDMA
    });

    // 3. 等待传输完成
    te->wait_completion();
}

---

第三部分：使用教程与部署指南

七、快速开始

7.1 环境要求

硬件要求：

• GPU：NVIDIA（CUDA）、AMD（ROCm）、华为昇腾等
• NIC：RDMA（InfiniBand/RoCE）、EFA、eRDMA 或 TCP
• 存储：NVMe SSD（可选）

软件要求：

• 操作系统：Linux（推荐 Ubuntu 20.04+）
• 编译器：GCC 9+ 或 Clang 10+
• CMake：3.18+
• CUDA：11.8+（如果使用 NVIDIA GPU）

7.2 编译安装

克隆代码：

git clone https://github.com/kvcache-ai/Mooncake.git
cd Mooncake

安装依赖：

# 基础依赖
sudo apt-get update
sudo apt-get install -y build-essential cmake git

# RDMA 依赖（如果使用 RDMA）
sudo apt-get install -y libibverbs-dev librdmacm-dev

# CUDA 依赖（如果使用 NVIDIA GPU）
# 确保 CUDA 已安装

编译 Transfer Engine：

mkdir build && cd build

# 基础编译
cmake .. -DUSE_CUDA=ON
make -j$(nproc)

# 如果使用 RDMA
cmake .. -DUSE_CUDA=ON -DUSE_RDMA=ON
make -j$(nproc)

# 如果使用昇腾 NPU
cmake .. -DUSE_ASCEND=ON
make -j$(nproc)

安装 Python 包：

pip install -e .

7.3 基本使用示例

Transfer Engine 示例：

from mooncake.transfer_engine import TransferEngine

# 创建 Transfer Engine
engine = TransferEngine(
    protocol="rdma",  # 或 "tcp"
    device_name="mlx5_0"  # RDMA 设备名
)

# 注册内存区域
src_buffer = engine.register_memory(src_addr, size)
dst_buffer = engine.register_memory(dst_addr, size)

# 传输数据
transfer_id = engine.transfer(
    src_buffer, dst_buffer, size
)

# 等待完成
engine.wait(transfer_id)

Mooncake Store 示例：

from mooncake.store import MooncakeStore

# 创建 Store
store = MooncakeStore(
    storage_backend="memory",  # 或 "ssd"
    transfer_engine=engine
)

# 存储 KVCache
key = "request_123_prefix"
value = kvcache_data
store.put(key, value)

# 读取 KVCache
cached = store.get(key)

# 检查是否存在
if store.exists(key):
    print("KVCache found!")

八、与推理系统集成

8.1 vLLM 集成

安装 vLLM：

pip install vllm

配置 Mooncake Transfer Engine：

from vllm import LLM, SamplingParams
from vllm.config import EngineConfig

# 配置 Mooncake
config = EngineConfig(
    model="meta-llama/Llama-2-70b-hf",
    kv_transfer_config={
        "connector": "MooncakeTransferEngineConnector",
        "protocol": "rdma",
        "device": "mlx5_0"
    }
)

# 创建 LLM
llm = LLM(**config)

# 生成
outputs = llm.generate(prompts, SamplingParams())

PD 分离部署：

# Prefill 节点
python -m vllm.entrypoints.api_server \
    --model meta-llama/Llama-2-70b-hf \
    --port 8000 \
    --role prefill \
    --kv-transfer-config '{"connector": "MooncakeTransferEngineConnector"}'

# Decode 节点
python -m vllm.entrypoints.api_server \
    --model meta-llama/Llama-2-70b-hf \
    --port 8001 \
    --role decode \
    --kv-transfer-config '{"connector": "MooncakeTransferEngineConnector"}'

8.2 SGLang 集成

安装 SGLang：

pip install sglang

使用 Mooncake 后端：

import sglang as sgl
from sglang import Runtime

# 配置 Mooncake
runtime = Runtime(
    model_path="meta-llama/Llama-2-70b-hf",
    kv_cache_config={
        "backend": "mooncake",
        "transfer_engine": {
            "protocol": "rdma",
            "device": "mlx5_0"
        }
    }
)

# 生成
@sgl.function
def generate(s, prompt):
    s += prompt
    s += sgl.gen("response", max_tokens=100)

result = generate.run(prompt="Hello, world!", runtime=runtime)

HiCache 配置：

from sglang import Runtime

runtime = Runtime(
    model_path="meta-llama/Llama-2-70b-hf",
    hicache_config={
        "enable": True,
        "backend": "mooncake",
        "storage_levels": ["gpu", "cpu", "remote"]
    }
)

8.3 LMDeploy 集成

安装 LMDeploy：

pip install lmdeploy

配置 Mooncake：

from lmdeploy import pipeline
from lmdeploy.config import BackendConfig

config = BackendConfig(
    kv_transfer_backend="mooncake",
    mooncake_config={
        "protocol": "rdma",
        "device": "mlx5_0"
    }
)

pipe = pipeline("meta-llama/Llama-2-70b-hf", backend_config=config)
response = pipe("Hello, world!")

九、高级配置

9.1 Transfer Engine 配置

RDMA 配置：

config = {
    "protocol": "rdma",
    "device": "mlx5_0",  # RDMA 设备
    "port": 1,           # 端口
    "gid_index": 0,      # GID 索引
    "max_wr": 1024,      # 最大工作请求数
    "cq_size": 1024,     # 完成队列大小
}

TCP 配置：

config = {
    "protocol": "tcp",
    "listen_port": 9999,
    "max_connections": 100,
}

CXL 配置：

config = {
    "protocol": "cxl",
    "memory_path": "/dev/cxlmem0",
}

9.2 Mooncake Store 配置

分层存储配置：

config = {
    "storage_levels": [
        {
            "name": "gpu",
            "type": "vram",
            "capacity": "80GB",
            "policy": "lru"
        },
        {
            "name": "cpu",
            "type": "dram",
            "capacity": "512GB",
            "policy": "lru"
        },
        {
            "name": "remote",
            "type": "remote_dram",
            "capacity": "2TB",
            "transfer": "rdma"
        },
        {
            "name": "ssd",
            "type": "nvme",
            "path": "/mnt/nvme",
            "capacity": "10TB"
        }
    ]
}

KVCache 复用配置：

config = {
    "enable_prefix_caching": True,
    "prefix_cache_size": "100GB",
    "eviction_policy": "lru",
    "match_threshold": 0.9,  # 前缀匹配阈值
}

9.3 调度器配置

SLO 配置：

config = {
    "slo": {
        "ttft": 5.0,     # Time to First Token (秒)
        "tbt": 0.1,      # Time Between Tokens (秒)
        "timeout": 60.0  # 总超时时间
    }
}

调度策略配置：

config = {
    "scheduler": {
        "strategy": "global_optimal",
        "enable_prediction": True,
        "enable_early_rejection": True,
        "rejection_threshold": 0.8,  # 负载阈值
    }
}

十、性能优化

10.1 网络优化

RDMA 调优：

# 增加 RDMA 缓冲区
echo 1048576 > /sys/class/infiniband/mlx5_0/attrs/max_cqe

# 启用 GPUDirect RDMA
export CUDA_VISIBLE_DEVICES=0
export RDMA_CORE_ENABLE_GPUDIRECT=1

拓扑优化：

# NUMA 感知配置
config = {
    "numa_aware": True,
    "preferred_numa_node": 0,
}

10.2 内存优化

内存池调优：

config = {
    "memory_pool": {
        "gpu_pool_size": "70GB",
        "host_pool_size": "400GB",
        "preallocate": True,
        "alignment": 4096,
    }
}

KVCache 淘汰策略：

config = {
    "eviction": {
        "policy": "lru",
        "watermark_low": 0.7,
        "watermark_high": 0.9,
    }
}

10.3 计算优化

批量大小调优：

config = {
    "prefill": {
        "max_batch_size": 32,
        "max_tokens_per_batch": 8192,
    },
    "decode": {
        "max_batch_size": 256,
        "max_tokens_per_batch": 1024,
    }
}

---

第四部分：应用场景与最佳实践

十一、典型应用场景

11.1 大规模 LLM 服务

场景：为百万级用户提供 LLM 服务

挑战：

• 高并发请求
• 多样化的请求长度
• 严格的延迟要求
• 成本控制

Mooncake 方案：

用户请求
    ↓
负载均衡器
    ↓
┌──────────────┬──────────────┐
│ Prefill 集群  │ Decode 集群  │
│ (100 节点)   │ (200 节点)   │
└──────────────┴──────────────┘
    ↓              ↓
  KVCache Pool (分布式)
    ↓
  SSD 存储 (持久化)

效果：

• 吞吐量提升 115%
• 延迟降低 30%
• 成本降低 40%

11.2 长上下文处理

场景：处理超长文档（200K+ tokens）

挑战：

• KVCache 占用巨大内存
• 单节点内存不足
• Prefill 时间长

Mooncake 方案：

# 配置分层存储
config = {
    "max_context_length": 200000,
    "storage_levels": ["gpu", "cpu", "remote", "ssd"],
    "offload_policy": "auto",
}

# 启用前缀缓存
config["prefix_cache"] = {
    "enable": True,
    "max_prefix_length": 100000,
}

效果：

• 支持 200K+ 上下文
• 内存占用降低 60%
• 相同前缀请求提速 5 倍

11.3 MoE 模型服务

场景：服务 Kimi K2（1T 参数 MoE 模型）

挑战：

• Expert 数量巨大
• Expert 负载不均
• 故障恢复复杂

Mooncake 方案：

# 配置弹性 Expert 并行
config = {
    "ep": {
        "enable": True,
        "num_experts": 256,
        "num_experts_per_node": 8,
        "elastic": True,
        "fault_tolerance": True,
    }
}

# 配置 Expert 负载均衡
config["eplb"] = {
    "strategy": "dynamic",
    "rebalance_interval": 1000,
}

效果：

• 128 H200 GPU 部署
• 224k tokens/sec prefill
• 288k tokens/sec decode
• 故障自动恢复

11.4 多模态模型服务

场景：服务多模态模型（文本+图像）

挑战：

• 图像编码计算密集
• 编码结果缓存
• 编码器和解码器分离

Mooncake 方案：

# EPD 分离配置
config = {
    "epd": {
        "enable": True,
        "encoder": {
            "nodes": ["encoder-0", "encoder-1"],
            "cache_backend": "mooncake",
        },
        "prefill": {
            "nodes": ["prefill-0", "prefill-1"],
        },
        "decode": {
            "nodes": ["decode-0", ..., "decode-7"],
        }
    }
}

效果：

• 编码器独立扩展
• 编码结果跨实例共享
• 避免重复计算

十二、最佳实践

12.1 集群规划

Prefill 集群：

• 选择高计算能力 GPU（如 H100）
• 较少内存容量即可
• 数量根据输入负载确定

Decode 集群：

• 选择高内存容量 GPU（如 H200）
• 计算能力要求较低
• 数量根据输出负载确定

KVCache Pool：

• 利用闲置资源
• DRAM：高频访问数据
• SSD：冷数据存储
• 网络：RDMA 互联

12.2 网络配置

推荐配置：

• 机内：NVLink 或 CXL
• 机间：InfiniBand 或 RoCE
• 跨机房：TCP（降级）

拓扑优化：

• 同机架优先
• NUMA 感知
• 多路径负载均衡

12.3 监控与调优

关键指标：

• TTFT（Time to First Token）
• TBT（Time Between Tokens）
• KVCache 命中率
• 内存利用率
• 网络吞吐量

调优建议：

• 监控 SLO 达成率
• 动态调整批量大小
• 定期清理冷数据
• 优化前缀缓存策略

---

结语

Mooncake 是一个革命性的 LLM 服务架构，它通过 KVCache-centric 的分离式设计，系统性地解决了大规模 LLM 服务面临的资源利用率、服务质量、扩展性和成本问题。

核心创新：

1. 分离式架构：Prefill 和 Decode 独立扩展，资源利用率最大化
2. KVCache 池化：分布式存储和共享，支持超长上下文
3. Transfer Engine：高效数据传输，支持多种协议
4. 智能调度：全局优化，预测性调度，早期拒绝
5. 弹性支持：MoE 模型的弹性 Expert 并行

生产验证：

• Kimi 服务：数千节点，日处理 1000 亿 token
• 性能提升：吞吐量提升 59%~525%
• 学术认可：FAST 2025 最佳论文奖
• 生态集成：vLLM、SGLang、LMDeploy 等

未来展望：

随着 LLM 模型规模的持续增长和应用场景的多样化，Mooncake 的设计理念将越来越重要。它代表了 LLM 服务架构的发展方向：以存储为中心，计算存储分离，资源池化共享。

希望这篇文章能帮助你全面理解 Mooncake，并在实际应用中发挥其价值。

---

参考资源

• GitHub 仓库：https://github.com/kvcache-ai/Mooncake
• 论文：https://www.usenix.org/system/files/fast25-qin.pdf
• 技术报告：https://arxiv.org/abs/2407.00079
• 博客：https://kvcache-ai.github.io/Mooncake/
• Kimi 服务：https://kimi.ai/
• Moonshot AI：https://www.moonshot.cn/

---

• 作者：GYF