第9章虚拟机（Virtual Machine: Executing Bytecode）

一、导读

虚拟机负责执行编译生成的字节码指令。本章介绍栈式虚拟机的架构设计，包括操作数栈的管理、栈帧的组织、函数调用的实现以及垃圾回收的基本原理，完成 Lox 语言的完整实现。

学习目标：掌握虚拟机执行循环的实现，理解栈帧的组织和函数调用约定，学会管理变量的局部存储，了解垃圾回收的基本原理和实现方法。

重要性：虚拟机是字节码得以运行的基础设施，它的性能直接决定了语言的整体执行效率。理解虚拟机的内部工作机制，对于语言开发者优化性能、调试问题至关重要。对于应用开发者，理解虚拟机也有助于编写更高效的代码，避免不必要的性能陷阱。

核心问题：虚拟机的执行循环如何工作？栈帧如何组织以支持函数调用和局部变量？闭包在字节码层面如何实现？垃圾回收如何自动管理内存？如何平衡执行性能和实现复杂度？

二、核心概念详解

2.1 操作数栈的执行模型

栈式虚拟机的核心是一个操作数栈（Operand Stack）和一个指令指针（Instruction Pointer, IP）。执行循环（Dispatch Loop）不断读取 IP 指向的操作码，根据操作码执行对应的操作，然后推进 IP 到下一条指令。大部分指令从栈顶弹出操作数，执行运算后将结果压回栈。这种模型简洁统一，所有表达式求值都转化为栈操作的序列。

void interpret() {
  uint8_t instruction;
  do {
    instruction = NEXT();  // 读取下一条指令
    switch (instruction) {
      case OP_CONSTANT: {
        Value constant = READ_CONSTANT();
        push(constant);
        break;
      }
      case OP_ADD: {
        double b = pop();
        double a = pop();
        push(a + b);
        break;
      }
      case OP_RETURN: {
        printValue(pop());
        printf("\n");
        return;
      }
    }
  } while (true);
}

2.2 栈帧的调用管理

每个函数调用创建一个栈帧（Stack Frame），也称为调用帧（Call Frame）。栈帧包含三个关键信息：函数对象的引用（用于获取字节码）、IP 的值（记录函数执行到哪个位置）、以及栈底指针（标记该帧局部变量在值栈中的起始位置）。虚拟机维护一个栈帧数组（Call Frame Stack），函数调用时压入新帧，函数返回时弹出当前帧并恢复调用者的 IP。

typedef struct {
  ObjClosure* closure;
  uint8_t* ip;
  Value* slots;  // 指向值栈中该帧的起始位置
} CallFrame;

typedef struct {
  CallFrame frames[FRAMES_MAX];
  int frameCount;
  Value stack[STACK_MAX];
  Value* stackTop;
} VM;

2.3 局部变量的栈上存储

在字节码虚拟机中，局部变量直接存储在值栈（Value Stack）上，而非单独的数据结构。每个栈帧的 slots 指向值栈中该帧的起始位置，局部变量通过相对于 slots 的偏移量（slot index）来访问。这种设计的优势是内存分配高效（只需移动栈指针），缓存友好（所有数据连续存储），且简化了垃圾回收（只需扫描值栈）。

值栈布局:
[frame0 slot0] [frame0 slot1] ... [frame1 slot0] [frame1 slot1] ...
 ^-- globals     ^-- param1         ^-- param1       ^-- local1

2.4 闭包的字节码实现

在字节码层面，闭包通过 OP_CLOSURE 指令实现。该指令首先引用一个函数原型（ObjFunction），然后为每个被捕获的上值（Upvalue）生成一对操作数（标识是局部变量还是上值、以及对应的索引）。虚拟机在执行 OP_CLOSURE 时创建 ObjClosure 对象，并为每个上值创建 ObjUpvalue 节点，将捕获的变量链接起来。

case OP_CLOSURE: {
  ObjFunction* function = READ_FUNCTION();
  ObjClosure* closure = newClosure(function);
  push(OBJ_VAL(closure));
  for (int i = 0; i < closure->upvalueCount; i++) {
    uint8_t isLocal = READ_BYTE();
    uint8_t index = READ_BYTE();
    if (isLocal) {
      closure->upvalues[i] = captureUpvalue(currentFrame->slots + index);
    } else {
      closure->upvalues[i] = currentClosure->upvalues[index];
    }
  }
  break;
}

2.5 垃圾回收的内存管理

虚拟机需要自动管理堆内存，当对象不再被引用时回收其占用的空间。本书实现了一个标记-清除（Mark-Sweep）垃圾回收器。回收过程分为两个阶段：标记阶段从根集合（值栈、全局变量、打开的上值等）出发，递归标记所有可达对象；清除阶段遍历所有已分配的对象，释放未被标记的对象。回收器在分配内存超过阈值时自动触发，并在回收后调整阈值以避免频繁触发。

typedef struct Obj {
  ObjType type;
  bool isMarked;         // GC 标记
  struct Obj* next;      // 对象链表
} Obj;

typedef struct {
  Obj* objects;          // 所有已分配对象的链表头
  size_t bytesAllocated; // 已分配字节数
  size_t nextGC;         // 下次 GC 的触发阈值
  // ...
} VM;

三、深入分析

3.1 指令分发策略的性能影响

虚拟机的指令分发策略对性能有显著影响。最简单的实现使用 switch 语句分发指令，但每次分发都需要多次条件判断。线程化代码（Threaded Code）技术将每条指令的执行代码地址存储在数组中，通过函数指针间接跳转，减少了分发开销。GCC 的 computed goto 扩展可以进一步优化这一过程。不同的分发策略可以带来 20%-50% 的性能差异。

3.2 上值的打开与关闭

上值（Upvalue）在对应的局部变量还在栈上时是"打开的"（Open），此时它直接引用栈上的位置。当函数返回、局部变量离开栈后，上值被"关闭"（Closed），此时它将变量的值复制到自身内部，不再引用栈上的位置。这种打开/关闭的转换确保了闭包在函数返回后仍然能正确访问捕获的变量。上值的链表管理是虚拟机实现中最精妙的部分之一。

3.3 垃圾回收的调优策略

垃圾回收的性能取决于触发频率和每次回收的耗时。阈值设置过低会导致频繁回收，浪费 CPU 时间；阈值过高会导致内存占用过大。实际的语言实现通常采用自适应策略：根据回收效率（回收的内存量/耗时）动态调整阈值。更先进的实现使用分代回收（Generational GC），将对象分为新生代和老年代，对不同代采用不同的回收策略。

四、实践案例

4.1 案例一：函数调用的完整执行流程

考虑以下 Lox 代码的执行过程：

lox

fun add(a, b) {
  return a + b;
}
print add(3, 4);

字节码执行过程：

编译阶段：fun add 生成 OP_CLOSURE 指令创建闭包，OP_DEFINE_GLOBAL 将其绑定到名称 add

执行 add(3, 4)：先压入实参 3 和 4，然后执行 OP_CALL 2

OP_CALL：创建新栈帧，slots 指向第一个参数，IP 指向函数体的字节码

函数体内：LOAD_LOCAL 0（加载 a=3），LOAD_LOCAL 1（加载 b=4），OP_ADD（3+4=7）

OP_RETURN：弹出结果 7，弹出栈帧，恢复调用者 IP，将 7 压入调用者的栈

OP_PRINT：弹出并打印 7

4.2 案例二：垃圾回收的触发过程

考虑以下创建大量临时对象的代码：

lox

for (var i = 0; i < 10000; i = i + 1) {
  var s = "temp" + i;
}

执行过程中：

每次循环迭代创建一个字符串对象 "temp" + i，分配在堆上

循环变量 s 在每次迭代结束时不再引用旧的字符串

当 bytesAllocated 超过 nextGC 阈值时，触发垃圾回收

标记阶段：从栈上的变量（i、s）出发，标记当前可达的字符串对象

清除阶段：释放所有未被标记的字符串对象（之前迭代创建的临时字符串）

回收后调整 nextGC 阈值，继续执行

五、常见误区

5.1 误区一：虚拟机的栈和系统的调用栈是同一个

虚拟机的操作数栈是虚拟机自己管理的数据结构，通常是一个数组，与操作系统的调用栈无关。虚拟机的栈帧存储在帧数组中，而非系统调用栈上。这种设计使得虚拟机可以精确控制内存使用，不受系统栈大小的限制。

5.2 误区二：垃圾回收可以回收所有不可达对象

标记-清除 GC 只能回收从根集合不可达的对象。但某些对象虽然"逻辑上"不再需要，却因为被根集合间接引用而无法回收（逻辑内存泄漏）。例如，一个全局 Map 不断添加条目但从不删除，其中的对象虽然不再被程序使用，但仍然是可达的。

5.3 误区三：字节码虚拟机不需要关心内存对齐

虽然字节码是紧凑的二进制格式，但对象在堆上的分配仍然需要考虑内存对齐。未对齐的内存访问在某些架构上会导致性能下降甚至硬件异常。对象头的大小和字段的排列顺序应该考虑对齐要求，以平衡紧凑性和访问效率。

5.4 误区四：栈式虚拟机的栈深度不受限制

虚拟机的值栈和帧栈都有预设的最大容量（如 STACK_MAX 和 FRAMES_MAX）。过深的递归或过大的表达式可能导致栈溢出。实际的语言实现需要检测栈溢出并报告有意义的错误信息，而非让程序崩溃。

六、本章小结

本章讲解了字节码虚拟机的实现细节。执行循环通过指令指针顺序读取并执行字节码指令。操作数栈提供了简洁的执行模型，所有运算都转化为栈操作。栈帧管理了函数调用的状态，包括 IP、局部变量和参数。局部变量直接存储在值栈上，通过偏移量访问，高效且缓存友好。闭包通过上值机制在字节码层面实现，支持打开和关闭两种状态。标记-清除垃圾回收器自动管理堆内存，从根集合出发标记可达对象并释放不可达对象。通过这些组件的协同工作，Lox 语言的字节码虚拟机能够高效地执行程序。

七、思考题

请实现一个基于 computed goto 的指令分发机制，与 switch 分发进行性能对比测试。

如果将垃圾回收算法从标记-清除改为引用计数，需要修改虚拟机的哪些部分？分析引用计数在处理循环引用时的问题。

设计一个栈溢出检测机制，在函数调用和表达式求值时检查栈是否已满，并报告有意义的错误信息。

请实现一个简单的内联缓存（Inline Cache）来优化方法调用的性能，说明缓存的存储位置和失效策略。

分析以下场景的垃圾回收行为：一个闭包捕获了外部函数的局部变量，外部函数返回后，闭包仍然被全局变量引用。描述标记阶段如何遍历到这个闭包及其捕获的变量。

第9章 虚拟机（Virtual Machine: Executing Bytecode）