🧬 Dart VM Kernel

📦 什么是 Kernel？

🎯 Kernel 设计目标

• ✅ 语言无关 - 支持多种前端语言
• ✅ 平台无关 - 可用于 AOT/JIT
• ✅ 紧凑高效 - 二进制格式体积小
• ✅ 完整类型 - 保留所有类型信息
• ✅ 可增量 - 支持热重载

📄 Kernel 文件结构

.dill 文件 (Kernel Binary)
│
├── Magic Number (0x90ABCDEF)
├── Version Information
│
├── String Table
│   └── 所有字符串常量
│
├── Canonical Name Table
│   └── 符号引用
│
├── Library List
│   ├── Library 1
│   │   ├── Class List
│   │   ├── Procedure List
│   │   └── Field List
│   └── Library 2 ...
│
├── Constant Pool
│   └── 所有常量值
│
└── Type Table
    └── 所有类型定义

🔢 Kernel 二进制格式

🌳 Kernel AST 节点

TreeNode (基类)
│
├── Library (库)
│   ├── Class (类)
│   │   ├── Constructor (构造函数)
│   │   ├── Procedure (方法)
│   │   └── Field (字段)
│   │
│   ├── Procedure (顶级函数)
│   └── Field (顶级变量)
│
├── Expression (表达式)
│   ├── VariableGet
│   ├── PropertyGet
│   ├── MethodInvocation
│   └── ...
│
└── Statement (语句)
    ├── Block
    ├── IfStatement
    ├── ForStatement
    └── ...

📚 Library 节点

class Library extends NamedNode {
  final StringReference importUri;
  final StringReference name;
  
  final List<Class> classes;
  final List<Field> fields;
  final List<Procedure> procedures;
  
  final List<LibraryDependency> dependencies;
  // 导入的其他库
}

📦 Class 节点

class Class extends NamedNode {
  final Library enclosingLibrary;
  final StringReference name;
  
  final List<TypeParameter> typeParameters;  // 泛型参数
  final Supertype? superType;                // 父类
  final List<Supertype> implementedTypes;    // 接口
  
  final List<Field> fields;
  final List<Constructor> constructors;
  final List<Procedure> procedures;
}

⚡ Procedure 节点

class Procedure extends NamedNode {
  final Name name;
  final ProcedureKind kind;
  // Method, Getter, Setter, Operator, Factory
  
  final FunctionNode function;
  // 函数体和参数
  
  final List<TypeParameter> typeParameters;
  // 泛型方法参数
}

🔤 类型表示

📊 常量池

• 数值常量：int, double
• 字符串常量：String
• 布尔常量：true, false
• 列表常量：const []
• Map 常量：const {}
• 对象常量：const MyClass()
• 类型常量：int, List<String>

📥 KernelLoader 概述

源码：runtime/vm/kernel_loader.cc

class KernelLoader {
  static ErrorPtr LoadProgram(
    const uint8_t* buffer,
    intptr_t buffer_size,
  );
  
  static ErrorPtr LoadLibrary(
    const Library& library,
  );
}

🔄 加载流程

.dill 文件
     │
     ▼
┌─────────────────┐
│  Read Header    │ 读取魔数和版本
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Read Strings   │ 加载字符串表
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Read Names     │ 加载符号表
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Read Libraries │ 加载所有库
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Link Types     │ 解析类型引用
└─────────────────┘

📖 ReadProgram

ErrorPtr KernelLoader::ReadProgram(
  const uint8_t* buffer,
  intptr_t size,
) {
  // 1. 解析 Header
  Reader reader(buffer, size);
  auto magic = reader.ReadUInt32();
  if (magic != kMagicNumber) {
    return ILLEGAL_ARGUMENT;
  }
  
  // 2. 读取字符串表
  reader.ReadStringTable();
  
  // 3. 读取库列表
  for (auto lib : libraries) {
    ReadLibrary(lib);
  }
}

📚 ReadLibrary

void ReadLibrary(const Library& lib) {
  // 1. 创建 VM Library 对象
  auto vm_lib = Library::Handle();
  vm_lib = Library::New(url, name);
  
  // 2. 加载类
  for (auto cls : lib.classes) {
    ReadClass(cls, vm_lib);
  }
  
  // 3. 加载顶级成员
  for (auto proc : lib.procedures) {
    ReadProcedure(proc, vm_lib);
  }
}

📦 ReadClass

void ReadClass(const Class& cls, Library& lib) {
  // 1. 创建 VM Class 对象
  auto vm_cls = Class::New(lib, name);
  
  // 2. 设置父类和接口
  vm_cls.set_super_type(ReadType(cls.superType));
  
  // 3. 加载字段
  for (auto field : cls.fields) {
    ReadField(field, vm_cls);
  }
  
  // 4. 加载方法
  for (auto proc : cls.procedures) {
    ReadProcedure(proc, vm_cls);
  }
}

⚡ ReadProcedure

void ReadProcedure(
  const Procedure& proc,
  Class& owner,
) {
  // 1. 创建 Function 对象
  auto func = Function::New(
    name,
    kind,  // Method, Getter, Setter
    owner,
  );
  
  // 2. 设置签名
  func.set_signature(ReadSignature(proc.function));
  
  // 3. 延迟加载函数体
  // 函数体在首次调用时编译
}

🔤 类型解析

TypePtr ReadType(const DartType& type) {
  switch (type.kind) {
    case Interface:
      return InterfaceType::New(
        klass,
        type_args,
      );
    case TypeParameter:
      return TypeParameterType::New(param);
    case Function:
      return FunctionType::New(signature);
  }
}

📤 增量加载

Hot Reload 使用增量 Kernel只加载修改的部分

ErrorPtr ReloadSources(
  IsolateGroup* group,
  const uint8_t* kernel_bytes,
  intptr_t kernel_size,
) {
  // 1. 加载增量 Kernel
  auto delta = ReadDelta(kernel_bytes);
  
  // 2. 更新修改的类
  for (auto cls : delta.modified_classes) {
    UpdateClass(cls);
  }
  
  // 3. 迁移现有实例
  MorphInstances();
}

🔄 热重载类型更新

增量 Kernel (.dill)
       │
       ▼
┌──────────────────┐
│  Parse Delta     │ 解析增量部分
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  Compare Classes │ 对比新旧类定义
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  Create Mapping  │ 创建字段映射
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  Morph Instances │ 变换现有实例
└──────────────────┘

🎭 InstanceMorpher 概述

源码：runtime/vm/instance_morpher.cc

• 遍历堆中所有旧类实例
• 调整内存布局
• 迁移字段值
• 更新类型指针

🔄 Become 机制

Become 是 Dart VM 的指针置换机制

// Become 核心操作
void Become::ElementsForward(
  const Array& old_arr,
  const Array& new_arr,
) {
  // 将所有指向 old_arr[i] 的指针
  // 替换为指向 new_arr[i]
  
  // 这包括：
  // - 堆中的引用
  // - 栈中的引用
  // - 全局变量
}

📋 字段迁移

✅ 类型兼容性

⚠️ 迁移限制

• ❌ 修改类的构造函数签名
• ❌ 添加/删除枚举值
• ❌ 修改泛型类型参数约束
• ❌ 修改 mixin 应用
• ❌ 修改 extension 定义

🔄 Isolate 与 Kernel

• Isolate 拥有独立的类表
• Isolate 拥有独立的常量池
• Hot Reload 需要更新所有 Isolate

👥 IsolateGroups

IsolateGroup 共享只读 Kernel 数据

┌─────────────────────────────────────┐
│          IsolateGroup               │
│  ┌─────────────────────────────┐   │
│  │  Shared Kernel Data         │   │
│  │  (classes, constants, ...)  │   │
│  └───────────┬─────────────────┘   │
│              │                      │
│   ┌──────────┴──────────┐          │
│   │                     │          │
│  ▼                     ▼          │
│ Isolate 1           Isolate 2     │
│ (独立堆)           (独立堆)        │
└─────────────────────────────────────┘

📦 共享 Kernel

// IsolateGroup 共享机制
class IsolateGroup {
  // 共享的 Kernel 程序
  Program* shared_program_;
  
  // 共享的类对象
  ClassTable* shared_class_table_;
  
  // 每个 Isolate 的独立数据
  void ForEachIsolate([&](Isolate* isolate) {
    // 处理独立堆
  });
}

💾 内存管理

🗃️ Kernel 缓存

VM 缓存已加载的 Kernel 减少重复解析

class KernelCache {
  // 缓存已加载的程序
  HashMap<String, Program*> programs_;
  
  // 缓存已解析的类
  HashMap<String, Class*> classes_;
  
  Program* GetOrLoad(String url) {
    if (programs_.contains(url)) {
      return programs_[url];
    }
    return LoadAndCache(url);
  }
}

🖥️ 前端编译器

CFE (Common Front End) 是 Dart 的统一前端编译器

• 解析 Dart 源代码
• 执行类型推断
• 生成 Kernel AST
• 序列化为 .dill 文件

🏗️ CFE 架构

Dart Source (.dart)
       │
       ▼
┌─────────────────┐
│  Parser         │ 词法/语法分析
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Body Builder   │ 构建 AST
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Type Inference │ 类型推断
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Kernel Writer  │ 序列化
└────────┬────────┘
         │
         ▼
    Kernel (.dill)

📤 增量编译

class IncrementalCompiler {
  // 之前编译的状态
  Program* previous_program_;
  
  // 增量编译
  Future<Program> compile(
    List<Uri> modified_files,
  ) async {
    // 1. 复用之前的 AST
    // 2. 只重新编译修改的文件
    // 3. 生成增量 Kernel
  }
}

🔀 混合编译

• 核心库：AOT 预编译
• 应用代码：JIT 动态编译
• 热重载：增量 JIT 编译

⚙️ AOT vs JIT

📦 AOT 编译流程

Kernel (.dill)
       │
       ▼
┌─────────────────┐
│  IL Generator   │ 生成中间语言
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  IL Optimizer   │ 优化
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Code Generator │ 生成机器码
└────────┬────────┘
         │
         ▼
   Snapshot (.snapshot)

⚡ JIT 执行流程

Kernel (.dill)
       │
       ▼
┌─────────────────┐
│  KernelLoader   │ 加载到内存
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Interpreter    │ 解释执行
│  (首次调用)      │
└────────┬────────┘
         │ 热点检测
         ▼
┌─────────────────┐
│  JIT Compiler   │ 编译为机器码
└─────────────────┘

📸 快照机制

🔵 Core Snapshot

// Core Snapshot 包含
class CoreSnapshot {
  // 核心库对象
  Library dart_core;
  Library dart_async;
  Library dart_collection;
  ...
  
  // 预创建的对象
  Object* true_value;
  Object* false_value;
  Object* null_value;
}

🟢 App Snapshot

// App Snapshot 包含
class AppSnapshot {
  // 所有应用代码
  List<Library> libraries;
  
  // 编译后的代码
  List<Code> compiled_code;
  
  // 常量对象
  List<Object> constants;
  
  // 对象堆快照
  HeapSnapshot heap;
}

🐛 调试支持

• 文件名和行号
• 列号信息
• 变量名映射
• 类型信息

📍 源码映射

class SourceLocation {
  final Uri fileUri;       // 文件路径
  final int line;           // 行号
  final int column;         // 列号
  final int tokenPosition;   // Token 位置
}

// 每个 AST 节点都有位置信息
node.location.fileUri
node.location.line

⚡ 性能优化

📁 源码结构

dart-sdk/runtime/vm/
├── kernel_loader.cc         # Kernel 加载
├── kernel_loader.h
├── kernel_binary_flowgraph.cc
├── instance_morpher.cc      # 实例变形
├── become.cc                # 指针置换
├── object.cc                # VM 对象
├── isolate.cc               # Isolate
└── snapshot.cc              # 快照

dart-sdk/pkg/kernel/
├── lib/                     # Kernel AST 定义
└── binary/                  # 二进制格式

📄 关键类

🔧 调试技巧

# 查看 .dill 文件内容
dart kernel-service.dart temp.dill

# 打印 Kernel AST
dart pkg/kernel/tool/dump.dart app.dill

# VM 调试输出
dart --print-flow-graph script.dart

❓ 常见问题

📝 总结

🔄 核心流程

1. 前端编译
   └─▶ CFE 编译 Dart → Kernel (.dill)

2. 加载解析
   └─▶ KernelLoader 解析二进制 → VM 对象

3. 热重载更新
   └─▶ 加载增量 Kernel → InstanceMorpher 变形

4. 指针置换
   └─▶ Become 替换旧对象指针

🎯 关键要点

• 📦 Kernel 是 Dart 的中间表示
• 📥 KernelLoader 解析二进制创建 VM 对象
• 🎭 InstanceMorpher 实现热重载实例变形
• 🔄 Become 机制实现指针原子替换
• 👥 IsolateGroup 共享只读 Kernel 数据
• 📸 快照机制加速启动

📚 参考资料

• 🔗 Dart Kernel: github.com/dart-lang/kernel
• 🔗 Dart VM: github.com/dart-lang/sdk/tree/main/runtime/vm
• 🔗 CFE: github.com/dart-lang/sdk/tree/main/pkg/front_end
• 🔗 Kernel Binary Format: github.com/dart-lang/kernel/blob/master/docs/Kernel-Binary-Format.md

🧬 Happy Coding!