V8 引擎内部机制

V8 是 Chrome 和 Node.js 的 JavaScript 引擎，以高性能著称，其内部机制对 JS 性能优化至关重要。

V8 整体架构

┌────────────────────────────────────────────────┐
│                    V8 架构                       │
├────────────────────────────────────────────────┤
│  Source Code                                    │
│       ↓                                         │
│  Parser → AST (抽象语法树)                        │
│       ↓                                         │
│  Ignition → Bytecode (字节码)                    │
│       ↓                                         │
│  Execution + Feedback (类型反馈)                  │
│       ↓                                         │
│  TurboFan → Optimized Machine Code              │
│       ↓                                         │
│  Deoptimization (反优化)                         │
└────────────────────────────────────────────────┘

Ignition 解释器

字节码生成

Ignition 将 AST 转换为字节码，是一种基于寄存器的虚拟机。

// JavaScript 代码
function add(a, b) {
  return a + b;
}

// 对应字节码（简化）
Ldar a0       // 加载参数 a 到累加器
Add a1, [0]   // 加上参数 b
Return        // 返回结果

字节码特点

• 低内存占用（比 AST 紧凑）
• 快速生成和执行
• 收集类型反馈信息

字节码指令示例

// 变量操作
LdaGlobal [name]    // 加载全局变量
Star [reg]          // 存储到寄存器
LdaSmi [value]      // 加载小整数

// 运算
Add [value]         // 加法
Sub [value]         // 减法
Mul [value]         // 乘法

// 控制流
JumpIfTrue [offset] // 条件跳转
Jump [offset]       // 无条件跳转

Hidden Class（隐藏类）

概念

V8 通过 Hidden Class 实现对象的类型系统，优化属性访问。

// 创建对象时 V8 自动创建 Hidden Class
const point = { x: 1, y: 2 };

// Hidden Class 转换链
// empty → {x} → {x, y}

属性访问优化

// ✅ 相同 Hidden Class
const p1 = { x: 1, y: 2 };
const p2 = { x: 3, y: 4 };
// p1 和 p2 共享相同 Hidden Class，优化生效

// ❌ 不同 Hidden Class
const p3 = { x: 1, y: 2 };
const p4 = { y: 2, x: 1 }; // 属性顺序不同
// p3 和 p4 有不同 Hidden Class，优化失效

动态添加属性

function Point(x, y) {
  this.x = x;  // Class transition: empty → {x}
  this.y = y;  // Class transition: {x} → {x, y}
}

// ✅ 所有实例相同 Hidden Class
const a = new Point(1, 2);
const b = new Point(3, 4);

// ❌ 后续添加破坏优化
a.z = 5; // 新的 Class transition
// a 和 b 现在 Hidden Class 不同

Inline Cache（内联缓存）

工作原理

缓存属性访问路径，避免重复查找。

function getX(obj) {
  return obj.x;
}

const p1 = { x: 1 };
const p2 = { x: 2 };

getX(p1); // 第一次调用，缓存形状信息
getX(p2); // 相同形状，命中缓存，快速访问

const p3 = { x: 3, y: 4 };
getX(p3); // 不同形状，可能需要更新缓存

IC 状态

TurboFan 优化编译器

优化流程

字节码 → Sea of Nodes → 优化 Pass → 机器码

优化技术

// 内联优化
function add(a, b) {
  return a + b;
}
function calculate(x) {
  return add(x, 10);
}

// 优化后
function calculate(x) {
  return x + 10; // add 被内联
}

逃逸分析

function Point(x, y) {
  this.x = x;
  this.y = y;
}

function distance(p) {
  return Math.sqrt(p.x * p.x + p.y * p.y);
}

// 如果 Point 对象不逃逸，可以标量替换
function distanceOptimized(x, y) {
  return Math.sqrt(x * x + y * y);
}

垃圾回收机制

分代回收

┌─────────────────────────────────────────┐
│               V8 Heap                    │
├────────────────┬────────────────────────┤
│   New Space    │      Old Space         │
│   (新生代)      │      (老生代)           │
│   1-8MB        │      较大空间           │
├────────────────┼────────────────────────┤
│   Semi-space   │  Pointer Space         │
│   From | To    │  Data Space            │
│   (Scavenge)   │  (Mark-Sweep-Compact)  │
└────────────────┴────────────────────────┘

新生代（Scavenge）

// 新生代使用半空间复制算法
// From-Space → To-Space

// 对象晋升条件
// 1. 经历过一次 Scavenge
// 2. To-Space 使用超过 25%

老生代（Mark-Sweep-Compact）

// 标记-清除-整理
// 1. 标记活动对象
// 2. 清除未标记对象
// 3. 整理碎片（可选）

增量标记与并发回收

// Orinoco 项目特性
// - 增量标记：分批标记，减少停顿
// - 并发回收：主线程继续执行
// - 并行回收：多线程协作

内存快照分析

使用 d8 调试

# 生成堆快照
node --allow-natives-syntax -e "
  const v8 = require('v8');
  const fs = require('fs');
  const snapshot = v8.getHeapSnapshot();
  fs.writeFileSync('heap.heapsnapshot', snapshot);
"

查看优化状态

// 检查函数是否优化
function testOptimization() {
  return 1 + 1;
}

// V8 内部函数（仅调试用）
if (typeof %GetOptimizationStatus === 'function') {
  testOptimization();
  %OptimizeFunctionOnNextCall(testOptimization);
  testOptimization();
  console.log(%GetOptimizationStatus(testOptimization));
}

Chrome DevTools Memory 面板可以可视化分析堆内存和对象分布。

要点总结

• Hidden Class 决定对象优化程度
• IC 缓存属性访问路径
• TurboFan 基于类型反馈优化
• 新生代用 Scavenge，老生代用 Mark-Sweep