高层次理解 V8

December 25, 2024December 29, 2024

note

Prerequisites

本节用于快速说明理解程序执行所需的前置知识

简而言之：前端针对代码（语义），后端关注（物理）运行

single-pass compilers
tree-walk interpreter
transcompiler
just-in-time(JIT) compilation

根据局部性原理，树遍历解释器需要在树结构中（通过指针）来回跳转，造成缓存丢失。
字节码是一个理想化的幻想指令集。可以把字节码看作是AST的一种紧凑的序列化，它对CPU缓存更友好。

JavaScript

一个 v8 实例称为 Isolation，隔离js堆。
Isolate 对应于一个物理线程。Blink 中的 Isolate：物理线程 = 1：1。主线程有自己的 Isolate。工作线程有自己的 Isolate。
Context 对应于一个全局对象（在 Frame 的情况下，它是 Frame 的 window 对象）。由于每个框架都有自己的 window 对象，因此一个渲染器进程中有多个 Context。

ECMA262 规范中包含一个“执行上下文”的定义。和上述 Context 比较接近。
因此，每个上下文包含 Realm，所以自然每个上下文的内置对象都是不同的。

gin用于简化Chromium与v8交互，还用于 ChromeExtension/PAC/PDFium。
Blink Bindings 用于 WebIDL 自动生成 v8 bindings。
Node.js 则直接使用 v8。

v8 整体流程如下

解析

流式解析（后台线程）。字符流解析为 Token 流。

v8 使用手写递归下降解析，提供更好的错误处理。

另见：
https://v8.dev/blog/scanner

预解析

解析但不生成 AST。用于快速执行，跳过无需立即执行的内容（函数，因为可以惰性解析），从而加速和节约内存。
解析过程是必要的，因为语法检查是必要的。

另见：
https://v8.dev/blog/preparser

解析

为了实际执行，则必须生成 AST（注意解析是流式的）。

因为 js 变量的语义（例如变量可以在声明前就被引用），还需做范围分析（即：变量提升）。

那么 v8 解析器实现没有使用单遍算法，因此做范围分析则需要多扫描一遍，以确定变量引用。

另见：
https://v8.dev/blog/cost-of-javascript-2019

执行

Ignition

Ignition 生成 High-Level 字节码，其语义与 JavaScript 类似。

字节码生成器生成字节码流，该字节码可以直接解释。
采用线程解释器（Threaded Interpreter）实现方式，每条指令直接跳转到下一条指令的实现代码，减少了查表和分派的开销。

不基于栈式虚拟机，而是虚拟寄存器。其优势在于寄存器在字节码中可以是隐含的，因此能够减小字节码体积
注意 JS 是解释型的，因此所有 IR 都存在内存，因此减小 IR 体积就是减小内存占用。

下面以这个简单的代码为例：

function foo(a) {
    if (a === 0) {
        let b = 1;
        return a;
    }
}

// 让 foo 变成热函数，否则不会 jit
for (let i = 0; i < 1e6; i++) foo();

为了方便，使用 node.js 来输出函数 foo 的字节码。node --print-bytecode demo.js

a 表示隐式寄存器 accumulator。所以 Lda 表示 load accumulator

   22 S> 0x3810d58db0e8 @    0 : 0c                LdaZero
   28 E> 0x3810d58db0e9 @    1 : 6c 03 00          TestEqualStrict a0, [0]
         0x3810d58db0ec @    4 : 99 08             JumpIfFalse [8] (0x3810d58db0f4 @ 12)
   53 S> 0x3810d58db0ee @    6 : 0d 01             LdaSmi [1]
         0x3810d58db0f0 @    8 : c4                Star0
   63 S> 0x3810d58db0f1 @    9 : 0b 03             Ldar a0
   71 S> 0x3810d58db0f3 @   11 : a9                Return
         0x3810d58db0f4 @   12 : 0e                LdaUndefined
   78 S> 0x3810d58db0f5 @   13 : a9                Return

另见：
https://v8.dev/blog/ignition-interpreter

Hidden Classes (a.k.a. Maps)

使用隐藏类是因为它比哈希表更快。

隐藏类记录对象的形状（对象有哪些字段），并当形状变更时，过渡为新形状。

用于（字节码）内联缓存（IC）。在隐藏类中查询字段则只需查询偏移量，无需哈希函数开销。

TurboFan

基于 Sea of Nodes 基于图的优化编译器。

数据/控制流/副作用被表示为节点，用于其它节点的输入。
复用 Ignition 字节码，函数独立编译，目标也是编译热函数。

JIT，通过推断的类型反馈生成内联优化代码。生成低级 IR，并编译为平台相关机器码。
由于JS语义是动态的，类型不匹配时需降级为字节码解释。

为了方便，使用 node.js 来输出函数 foo 的机器码。node --print-opt-code demo.js
注意只有热函数代码才会 JIT（下例为 ARM64 平台）

0x1086cb700     0  f85c0050       ldur x16, [x2, #-64]
0x1086cb704     4  b840f210       ldur w16, [x16, #15]
0x1086cb708     8  36000070       tbz w16, #0, #+0xc (addr 0x1086cb714)
0x1086cb70c     c  580006b1       ldr x17, pc+212 (addr 0x00000001086cb7e0)
0x1086cb710    10  d61f0220       br x17
0x1086cb714    14  a9bf7bfd       stp fp, lr, [sp, #-16]!
0x1086cb718    18  910003fd       mov fp, sp
0x1086cb71c    1c  a9be03ff       stp xzr, x0, [sp, #-32]!
0x1086cb720    20  a9016fe1       stp x1, cp, [sp, #16]
0x1086cb724    24  f8520344       ldur x4, [x26, #-224]
0x1086cb728    28  eb2463ff       cmp sp, x4
0x1086cb72c    2c  54000309       b.ls #+0x60 (addr 0x1086cb78c)
0x1086cb730    30  d2800001       movz x1, #0x0
0x1086cb734    34  580004e3       ldr x3, pc+156 (addr 0x00000001086cb7d0)    ;; object: 0x011791a5b131 <FeedbackVector[1]>
0x1086cb738    38  d280001b       movz cp, #0x0
0x1086cb73c    3c  f9401fe0       ldr x0, [sp, #56]
0x1086cb740    40  aa0103e2       mov x2, x1
0x1086cb744    44  58000530       ldr x16, pc+164 (addr 0x00000001086cb7e8)
0x1086cb748    48  d63f0200       blr x16
0x1086cb74c    4c  f9402f44       ldr x4, [x26, #88]
0x1086cb750    50  eb04001f       cmp x0, x4
0x1086cb754    54  54000180       b.eq #+0x30 (addr 0x1086cb784)
0x1086cb758    58  f9402340       ldr x0, [x26, #64]
0x1086cb75c    5c  f85e83a3       ldur x3, [fp, #-24]
0x1086cb760    60  910003bf       mov sp, fp
0x1086cb764    64  a8c17bfd       ldp fp, lr, [sp], #16
0x1086cb768    68  f100087f       cmp x3, #0x2 (2)
0x1086cb76c    6c  5400004a       b.ge #+0x8 (addr 0x1086cb774)
0x1086cb770    70  d2800043       movz x3, #0x2
0x1086cb774    74  91000470       add x16, x3, #0x1 (1)
0x1086cb778    78  927ffa10       and x16, x16, #0xfffffffffffffffe
0x1086cb77c    7c  8b306fff       add sp, sp, x16, lsl #3
0x1086cb780    80  d65f03c0       ret
0x1086cb784    84  f9401fe0       ldr x0, [sp, #56]
0x1086cb788    88  17fffff5       b #-0x2c (addr 0x1086cb75c)
0x1086cb78c    8c  d2c00604       movz x4, #0x3000000000
0x1086cb790    90  d10043ff       sub sp, sp, #0x10 (16)
0x1086cb794    94  f90007ff       str xzr, [sp, #8]
0x1086cb798    98  f90003e4       str x4, [sp]
0x1086cb79c    9c  f9000bfb       str cp, [sp, #16]
0x1086cb7a0    a0  d297c101       movz x1, #0xbe08
0x1086cb7a4    a4  f2a06bc1       movk x1, #0x35e, lsl #16
0x1086cb7a8    a8  f2c00021       movk x1, #0x1, lsl #32
0x1086cb7ac    ac  d2800020       movz x0, #0x1
0x1086cb7b0    b0  58000144       ldr x4, pc+40 (addr 0x00000001086cb7d8)    ;; object: 0x1bd96a0c1151 <NativeContext[271]>
0x1086cb7b4    b4  aa0403fb       mov cp, x4
0x1086cb7b8    b8  580001d0       ldr x16, pc+56 (addr 0x00000001086cb7f0)
0x1086cb7bc    bc  d63f0200       blr x16
0x1086cb7c0    c0  17ffffdc       b #-0x90 (addr 0x1086cb730)
0x1086cb7c4    c4  d503201f       nop
0x1086cb7c8    c8  5800017f       constant pool begin (num_const = 11)    ;; constant pool
0x1086cb7cc    cc  d63f03e0       constant
0x1086cb7d0    d0  91a5b131       constant
0x1086cb7d4    d4  00000117       constant
0x1086cb7d8    d8  6a0c1151       constant
0x1086cb7dc    dc  00001bd9       constant
0x1086cb7e0    e0  038c55e0       constant
0x1086cb7e4    e4  00000001       constant
0x1086cb7e8    e8  0391a0e0       constant
0x1086cb7ec    ec  00000001       constant
0x1086cb7f0    f0  039390a0       constant
0x1086cb7f4    f4  00000001       constant
0x1086cb7f8    f8  f8548350       ldur x16, [x26, #-184]
0x1086cb7fc    fc  d61f0200       br x16
0x1086cb800   100  97fffffe       bl #-0x8 (addr 0x1086cb7f8)    ;; debug: deopt position, script offset 'c'
                                                             ;; debug: deopt position, inlining id 'ffffffff'
                                                             ;; debug: deopt reason '(unknown)'
                                                             ;; debug: deopt index 0

另见：
https://v8.dev/blog/turbofan-jit
https://v8.dev/blog/launching-ignition-and-turbofan

内存管理

Orinoco

跟踪式GC，分代堆布局。基于块的增量式、并发回收。

new-space (up to 32MB) for freshly allocated objects
old-space (up to 2048MB) for long-lived objects
separate code-space (executable)

"Minor GC": only new-space

Move live objects to other semi-space
Promote objects to old-space when surviving twice
Typical pause time: ≤ 1 ms

"Major GC": all spaces

Mark: find live objects (incremental + concurrent + parallel)
Compact: evacuate almost-free pages (parallel)
Update references
Sweep: add non-live areas to free list (concurrent + parallel)
Runs Blink's Oilpan GC
Typical pause time: ≤ 10 ms

另见：
https://v8.dev/blog/free-garbage-collection
https://v8.dev/blog/orinoco
https://v8.dev/blog/orinoco-parallel-scavenger
https://v8.dev/blog/concurrent-marking
https://v8.dev/blog/trash-talk

Oilpan

与 blink 垃圾回收配合，可以处理 Oilpan 对象和 v8 对象的循环引用。

实现跨 js 和 c++ 边界回收（可达性分析）

另见：
https://v8.dev/blog/tracing-js-dom

语言实现

值的表示，装箱

小整数（Smi）内联表示，其它值装箱，通过指针引用。

64位指针压缩

Many tagged values in a typical JS heap (70%!)
Don't need full 64bit address space per heap
Build-time option compresses JS heap pointers to 32bit on 64bit archs
Turned on in Chrome

区分 Pointer 和 Smi

Pointer:
[offset (30 bits)][01]

Small integer (Smi):
[int31 value (31 bits)][0]

Recall each Isolate has a separate heap
...so each Isolate can have its own base

                   V8 instance data     Allocated memory chunks
                          ↓                     ↓
┌───┬──┬────────────────────────┬──┬───┬──┬───┬──┐
│   │  │                        │  │   │  │   │  │
└───┴──┴────────────────────────┴──┴───┴──┴───┴──┘
    ←―――――― ~2GB ――――――→        ↑    ←―― ~2GB ――→
                            base (4GB aligned)

Note: The diagram shows the memory layout with V8 instance data and allocated memory chunks distributed across a 4GB-aligned base, with approximately 2GB regions on each side.

另见：
https://v8.dev/blog/pointer-compression
https://v8.dev/blog/oilpan-pointer-compression

Torque

Torque 是一种语言，目标是实现 v8 内置函数。Torque 编译器使用 CodeStubAssembler 将这些片段转换为高效的汇编代码。

下面举 Reflect.get 实现为例子：

namespace Reflect {
// ES6 section 26.1.6 Reflect.get
transitioning javascript builtin
ReflectGet(js-implicit context: NativeContext)(...arguments): JSAny {
  const object: JSAny = arguments[0];
  const objectJSReceiver = Cast<JSReceiver>(object)
      otherwise ThrowTypeError(MessageTemplate::kCalledOnNonObject, 'Reflect.get');
  const propertyKey: JSAny = arguments[1];
  const name: AnyName = ToName(propertyKey);
  const receiver: JSAny =
      arguments.length > 2 ? arguments[2] : objectJSReceiver;
  return GetPropertyWithReceiver(
      objectJSReceiver, name, receiver, SmiConstant(kReturnUndefined));
  }
}

WebAssembly

栈式虚拟机，一种架构无关的低级编译目标（但也不那么低层，因为基于抽象堆栈而非寄存器）。
数据类型很简单：i32/i64/f32/f64/v128（128位SIMD）

WASM 文件都是模块，包含头（function types, imports, function declaration, tables, memories, global varaiables, exports, start function and elements for table initialization），代码段和数据段

特点在于，（wasm）内存，表，全局变量都可通过外部控制。