这是《图解 Google V8》第二篇：编译流水线
学习下来最大的播种有两点：
-
V8如何晋升JavaScript执行速度- 晚期缓存机器码，之后重构为缓存字节码
-
在
JavaScript中拜访一个属性时，V8做了哪些优化- 暗藏类
- 内联缓存
特地是第二点，让我看到了应用 TypeScript 的益处，动静语言存在的问题，动态语言都能够解决
09 | 运行时环境：运行 JavaScript 代码的基石
运行时环境包含：堆空间和栈空间、全局执行上下文、全局作用域、内置的内建函数、宿主环境提供的扩大函数和对象，还有音讯循环系统
宿主
浏览器为 V8 提供根底的音讯循环系统、全局变量、Web API
V8 的外围是实现 ECMAScript 规范，比方：Object、Function、String，还提供垃圾回收、协程等
结构数据存储空间：堆空间和栈空间
在 Chrome 中，只有关上一个渲染过程，渲染过程便会初始化 V8，同时初始化堆空间和栈空间。
栈是内存中间断的一块空间，采纳“先进后出”的策略。
在函数调用过程中，波及到上下文相干的内容都会寄存在栈上，比方原生类型、援用的对象的地址、函数的执行状态、this 值等都会存在栈上
当一个函数执行完结，那么该函数的执行上下文便会被销毁掉。
堆空间是一种树形的存储构造，用来存储对象类型的离散的数据，比方：函数、数组，在浏览器中还有 window、document 等
全局执行上下文和全局作用域
执行上下文中次要蕴含三局部，变量环境、词法环境和 this 关键字
全局执行上下文在 V8 的生存周期内是不会被销毁的，它会始终保留在堆中
在 ES6 中，同一个全局执行上下文中，都能存在多个作用域：
var x = 5;
{
let y = 2;
const z = 3;
}结构事件循环系统
V8 须要一个主线程，用来执行 JavaScript 和执行垃圾回收等工作
V8 是寄生在宿主环境中的，V8 所执行的代码都是在宿主的主线程上执行的
如果主线程正在执行一个工作，这时候又来了一个新工作，把新工作放到音讯队列中，期待当前任务执行完结后，再从音讯队列中取出正在排列的工作，执行完这个工作之后，再反复这个过程
10 | 机器代码：二进制机器码到底是如何被 CPU 执行的？
将汇编语言转换为机器语言的过程称为“汇编”；反之，机器语言转化为汇编语言的过程称为“反汇编”
在程序执行之前，须要将程序装进内存中（内存中的每个存储空间都有举世无双的地址）
二进制代码被装载进内存后，CPU 便能够从内存中取出一条指令，而后剖析该指令，最初执行该指令。
把取出指令、剖析指令、执行指令这三个过程称为一个 CPU 时钟周期
CPU 中有一个 PC 寄存器，它保留了将要执行的指令地址，到下一个时钟周期时，CPU 便会依据 PC 寄存器中的地址，从内存中取出指令。
PC 寄存器中的指令取出来之后，零碎要做两件事：
- 将下一条指令的地址更新到
PC寄存器中 - 剖析该指令，辨认出不同类型的指令，以及各种获取操作数的办法
因为 CPU 拜访内存的速度很慢，所以须要通用寄存器，用来寄存 CPU 中数据的（通用寄存器容量小，读写速度快，内存容量大，读写速度慢。）
通用寄存器通常用来存放数据或者内存中某块数据的地址，咱们把这个地址又称为指针
ebp寄存器通常是用来寄存栈帧指针esp寄存器用来寄存栈顶指针PC寄存器用来寄存下一条要执行的指令
罕用的指令类型：
- 加载指令：从内存中复制指定长度的内容到通用寄存器中，并笼罩寄存器中原来的内容
- 存储指令：和加载类型的指令相同，作用是将寄存器中的内容复制到内存中的某个地位，并笼罩掉内存中的这个地位上原来的内容
- 更新指令：作用是复制两个寄存器中的内容到
ALU中 - 跳转指令：从指令自身抽取出一个字，这个字是下一条要执行的指令地址，并将该字复制到
PC寄存器中，并笼罩掉PC寄存器中原来的值
11 | 堆和栈：函数调用是如何影响到内存布局的？
函数有两个次要的个性：
- 能够被调用
- 具备作用域机制
所以：
- 函数调用者的生命周期比被调用者的长（后进），被调用者的生命周期先完结 (先出)
-
从函数资源分配和回收角度来看，
- 被调用函数的资源分配晚于调用函数 (后进)，
- 被调用函数资源的开释先于调用函数 (先出)
栈的状态从 add 中复原到 main 函数的上次执行时的状态，这个过程称为 复原现场
function main() {add();
}
function add(num1, num2) {return num1 + num2;}怎么复原 main 函数的执行现场呢：
-
在
esp寄存器中保留一个永远指向以后栈顶的指针- 通知你往哪个地位增加新元素
-
ebp寄存器，保留以后函数的起始地位（也叫 栈帧指针）- 通知
CPU挪动到这个地址
- 通知
栈帧：每个栈帧对应着一个未运行完的函数，栈帧中保留了该函数的返回地址和局部变量。
12 | 提早解析：V8 是如何实现闭包的？
在编译阶段，V8 不会对所有代码进行编译，采纳一种“惰性编译”或者“惰性解析”，也就是说 V8 默认不会对函数外部的代码进行编译，只有当函数被执行前，才会进行编译。
闭包的问题指的是：因为子函数应用到了父函数的变量，导致父函数在执行实现当前，它外部被子函数援用的变量无奈及时在内存中被开释。
而闭包问题产生的根本原因是 JavaScript 中自身的个性：
- 能够在函数外部定义新的函数
- 外部函数能够拜访父函数的变量
- 函数是一等公民，所以函数能够作为返回值
既然因为 JavaScript 的这种个性就会呈现闭包的问题，那么就须要解决闭包问题，“预编译“或者“预解析”就呈现了
预编译具体计划：在编译阶段，V8 会对函数函数进行预解析
- 判断函数内语法是否正确
-
子函数是否援用父函数中的变量，如果有的话，将这个变量复制一份到堆中，同时子函数自身也是一个对象，也会被放到堆中
- 父函数执行实现后，内存会被开释
- 子函数在执行时，仍然能够从堆内存中拜访复制过去的变量
13 | 字节码（一）：V8 为什么又从新引入字节码？
在 V8 中，字节码有两个作用：
- 解释器能够间接执行字节码
- 优化编译器能够将字节码编译为机器码，而后再执行机器码
晚期的 V8
V8 团队认为“学生成字节码再执行字节码”，会就义代码的执行速度，便间接将 JavaScript 代码编译成机器码
应用了两个编译器：
- 基线编译器：将
JavaScript代码编译为没有优化过的机器码 - 优化编译器：将一些热点代码（执行频繁的代码）优化为执行效率更高的机器码
执行 JavaScript：
- 将
JavaScript代码转换为形象语法树（AST） - 基线编译器将
AST编译为未优化过的机器码，而后V8执行这些未优化过的机器代码 - 在执行未优化的机器代码时，将一些热点代码优化为执行效率更高的机器代码，而后执行优化过的机器码
- 如果优化过的机器码不满足以后代码的执行，
V8会进行反优化操作
问题
1. 机器码缓存
V8 执行一段 JavaScript 代码，编译工夫和执行工夫差不多
如果再 JavaScript 没有扭转的状况下，每次都编译这段代码，就会节约 CPU 资源
所以 V8 引入机器码缓存：
- 将源代码编译成机器码后，放在内存中（内存缓存）
- 下次再执行这段代码，就先去内存中查找是否存在这段代码的机器码，有的话就执行这段机器码
- 将编译后的机器码存入硬盘中，敞开浏览器后，下次从新关上，能够间接用编译好的机器码
工夫缩短了 20% ~ 40%
这是用空间换工夫的策略，在挪动端十分吃内存
2. 惰性编译
V8 采纳惰性编译，只会编译全局执行上下文的代码
因为 ES6 之前，没有块级作用域，为了实现各模块之间的隔离，会采纳立刻执行函数
这会产生很多闭包，闭包模块中的代码不会被缓存，所以只缓存顶层代码是不完满的
所以 V8 就进行了大重构
当初的 V8
字节码 + 解释器 + 编译器
5K的源代码JavaScript->40K字节码 ->10M的机器码
字节码的体积远小于机器码，浏览器就能够实现缓存所有的字节码，而不仅仅是全局执行上下文的字节码
长处：
- 升高了内存
- 晋升代码启动速度
- 升高了代码的复杂度
毛病：
- 执行效率降落
解释器的作用是将源代码转换成字节码
V8 的解释器是：lgnition；V8 的编译器是：TurboFan
如何升高代码复杂度
机器码在不同 CPU 中是不一样的，间接将 AST 转换成不同的机器码，就须要基线编译器和优化编译器编写大量适配各 CPU 的代码
先将 AST 转换成字节码，再将字节码转换成机器码，因为字节码（打消了平台的差异性）和 CPU 执行机器码过程相似，将字节码转换成机器码就会容易很多
14 |字节码（二）：解释器是如何解释执行字节码的？
生成字节码
function add(x, y) {
var z = x + y;
return z;
}
console.log(add(1, 2));生成 AST
[generating bytecode for function: add]
--- AST ---
FUNC at 12
KIND 0
LITERAL ID 1
SUSPEND COUNT 0
NAME "add"
PARAMS
VAR (0x7fa7bf8048e8) (mode = VAR, assigned = false) "x"
VAR (0x7fa7bf804990) (mode = VAR, assigned = false) "y"
DECLS
VARIABLE (0x7fa7bf8048e8) (mode = VAR, assigned = false) "x"
VARIABLE (0x7fa7bf804990) (mode = VAR, assigned = false) "y"
VARIABLE (0x7fa7bf804a38) (mode = VAR, assigned = false) "z"
BLOCK NOCOMPLETIONS at -1
EXPRESSION STATEMENT at 31
INIT at 31
VAR PROXY local[0] (0x7fa7bf804a38) (mode = VAR, assigned = false) "z"
ADD at 32
VAR PROXY parameter[0] (0x7fa7bf8048e8) (mode = VAR, assigned = false) "x"
VAR PROXY parameter[1] (0x7fa7bf804990) (mode = VAR, assigned = false) "y"
RETURN at 37
VAR PROXY local[0] (0x7fa7bf804a38) (mode = VAR, assigned = false) "z"将 AST 图形化
将函数拆成了 4 局部
- 参数申明（
PARAMS）：包含申明中的所有参数，这里是x和y，也能够应用arguments - 变量申明节点（
DECLS）：呈现了3个变量：x、y、z，你会发现x和y的地址和PARAMS中是雷同的，阐明他们是同一块数据 - 表达式节点：
ADD节点下有VAR PROXY parameter[0]和VAR PROXY parameter[1] RETURN节点：指向了z的值，这里是local[0]
生成 AST 的同时，还生成了 add 函数的作用域
Global scope:
function add (x, y) {// (0x7f9ed7849468) (12, 47)
// will be compiled
// 1 stack slots
// local vars:
VAR y; // (0x7f9ed7849790) parameter[1], never assigned
VAR z; // (0x7f9ed7849838) local[0], never assigned
VAR x; // (0x7f9ed78496e8) parameter[0], never assigned
}在解析阶段，一般变量默认值是 undefined，函数申明指向理论的函数对象；执行阶段，变量会指向栈和堆相应的数据
AST 作为输出传到本人字节码生成器中（BytecodeGenerator），它是 lgnition 的一部分，生成以函数为单位的字节码
[generated bytecode for function: add (0x079e0824fdc1 <SharedFunctionInfo add>)]
Parameter count 3
Register count 2
Frame size 16
0x79e0824ff7a @ 0 : a7 StackCheck
0x79e0824ff7b @ 1 : 25 02 Ldar a1
0x79e0824ff7d @ 3 : 34 03 00 Add a0, [0]
0x79e0824ff80 @ 6 : 26 fb Star r0
0x79e0824ff82 @ 8 : 0c 02 LdaSmi [2]
0x79e0824ff84 @ 10 : 26 fa Star r1
0x79e0824ff86 @ 12 : 25 fb Ldar r0
0x79e0824ff88 @ 14 : ab Return
Constant pool (size = 0)
Handler Table (size = 0)
Source Position Table (size = 0)这里 Parameter count 3 示意显示的参数 x 和 y，及隐式参数 this
最终的字节码
StackCheck
Ldar a1
Add a0, [0]
Star r0
LdaSmi [2]
Star r1
Ldar r0
Return了解字节码
有两种解释器：
-
基于栈（
State-based）- 应用栈来保留函数参数、两头运算后果、变量
-
基于寄存器（
Register-based）- 反对寄存器的指令操作，应用寄存器保留参数、两头计算结果
基于栈的解释器：Java 虚拟机、.Net 虚拟机，晚期的 V8 虚拟机；长处：在解决函数调用、解决递归问题和切换上下文时简略疾速
当初的 V8 采纳了基于寄存器的设计
Ladr a1指令：将a1寄存器中的值加载到累加器中Star r0指令：把累加器中的值保留到r0寄存器中-
Add a0, [0]指令：- 从
a0寄存器加载值并与累加器中的值相加，再将后果放入累加器中 -
[0]：成为反馈向量槽（feedback vector slot），- 目标是了给优化编译器（
TurboFan）提供优化信息，它是一个数组，解释器将解释执行过程中的一些数据类型的剖析信息保留在反馈向量槽中
- 目标是了给优化编译器（
- 从
LadSmi [2]指令：将小整数（Smi）2加载到累加器中Return指令：完结以后函数的执行，并将控制权还给调用方，返回的值是累加器中的值StackCheck指令：查看是栈是否达到溢出的下限
15 | 暗藏类：如何在内存中疾速查找对象属性？
- 为了晋升对象属性访问速度，引入暗藏类
- 为了减速运算引入内联缓存
为什么动态语言效率高
JavaScript 在运行时，对象的属性能够被批改，所以 V8 在解析对象时，比方：解析 start.x 时，它不晓得 start 中是否有 x，也不晓得 x 绝对于 start 的偏移量是多少，简略说 V8 不晓得 start 对象的具体行状
所以当 JavaScript 查问 start.x 时，过程十分慢
动态语言，比方 C++ 在申明对象之前须要定义该对象的构造（行状），执行之前会被编译，编译的时候，行状是固定的，也就是说在执行过程中，对象的行政是无奈扭转的
所以当 C++ 查问 start.x 使，编译器在编译的时候，会间接将 x 绝对于 start 对象的地址写进汇编指令中，查问时间接读取 x 的地址，没有查找环节
暗藏类
V8 为了做到这点，做了两个假如：
- 对象创立好了之后不会增加新的属性
- 对象创立好了之后也不会删除属性
而后 V8 为每个对象创立一个暗藏类，记录根底的信息
- 对象中所蕴含的所有属性
- 每个属性绝对于对象的偏移量。
在 V8 中暗藏类有称为 map，即每个对象都有一个 map 属性，指向内存中的暗藏类
有了 map 之后，当拜访 start.x 时，V8 会先去 start.map 中查问 x 绝对 start 的偏移量，而后将 point 对象的地址加上偏移量就失去了 x 属性的值在内存中的地址了
如果两个对象行状雷同，V8 会为其复用同一个暗藏类：
- 缩小暗藏类的创立次数，也间接减速了代码的执行速度
- 缩小了暗藏类的存储空间
两个对象的形态雷同，要满足：
- 雷同的属性名称
- 雷同的属性程序
- 雷同的属性类型
- 相等的属性个数
如果动静扭转了对象的行状，V8 就会从新构建新的暗藏类
参考资料：
- 利用 V8 深刻了解 JavaScript 对象存储策略
16 | 答疑：V8 是怎么通过内联缓存来晋升函数执行效率的？
function loadX(o) {return o.x;}
var o = {x: 1, y: 3};
var o1 = {x: 3, y: 6};
for (var i = 0; i < 90000; i++) {loadX(o);
loadX(o1);
}V8 获取 o.x 的流程：查找对象 o 的暗藏类，再通过暗藏类查找 x 属性偏移量，而后依据偏移量获取属性值
这段代码里 o.x 会被重复执行，那么查找流程也会被重复执行，那么 V8 有没有做这优化呢
内联缓存（Inline Cache，简称 IC）
V8 在执行函数的过程中，会察看函数中的一些调用点（CallSite）上的要害数据（两头数据），而后将它们缓存起来，当下次再执行该函数时，V8 能够利用这些两头数据，节俭再次获取这些数据的过程
IC 会为每个函数保护一个反馈向量（FeedBack Vector），反馈向量记录了函数在执行过程中的一些要害的两头数据
反馈向量是一个表构造，有很多项，每一项称为一个插槽 (Slot)
function loadX(o) {
o.y = 4;
return o.x;
}当 V8 执行这段函数时，它判断 o.y = 4 和 return o.x 是调用点 (CallSite)，因为它们应用了对象和属性，那么 V8 会在 loadX 函数的反馈向量中为每个调用点调配一个插槽。
插槽中包含了：
- 插槽的索引 (
slot index) - 插槽的类型 (
type) - 插槽的状态 (
state) - 暗藏类 (
map) 的地址 - 属性的偏移量
function loadX(o) {return o.x;}
loadX({x: 1});
// 字节码
StackCheck // 查看是否溢出
LdaNamedProperty a0, [0], [0] // 取出参数 a0 的第一个属性值，并将属性值放到累加器中
Return // 返回累加器中的属性LdaNameProperty 有三个参数：
a0是loadX的第一参数- 第一个
[0]示意取出对象a0的第一个属性值 - 第二个
[0]和反馈向量无关，示意将LdaNameProperty操作的两头数据写到反馈向量中，这里0示意第一个插槽
map：缓存了o的暗藏类的地址offset：缓存了属性x的偏移量type：缓存了操作类型，这里是LOAD类型。在反馈向量中，咱们把这种通过o.x来拜访对象属性值的操作称为LOAD类型。
function foo() {}
function loadX(o) {
o.y = 4;
foo();
return o.x;
}
loadX({x: 1, y: 4});
// 字节码
StackCheck
// 上面两行是 o.y = 4，STORE 类型
LdaSmi [4]
StaNamedProperty a0, [0], [0]
// 上面三行是 调用 foo 函数，CALL
LdaGlobal [1], [2]
Star r0
CallUndefinedReceiver0 r0, [4]
// 上面一行是 o.x
LdaNamedProperty a0, [2], [6]
Return多态和超态
function loadX(o) {return o.x;}
// o 和 o1 行状不同
var o = {x: 1, y: 3};
var o1 = {x: 3, y: 6, z: 4};
for (var i = 0; i < 90000; i++) {loadX(o);
loadX(o1);
}- 第一次执行
loadX时，V8将o的暗藏类记录在反馈向量中，同时记录x的偏移量 - 第二次执行
loadX，V8先取出反馈向量中的暗藏类，和o1的暗藏类进行比拟，不是同一个暗藏类，那么就无奈应用反馈向量中缓存的偏移量了
- 一个插槽只有
1个暗藏类，称为单态 (monomorphic) - 一个插槽有
2 ～ 4个暗藏类，称为为多态 (polymorphic) - 一个插槽中超过
4个暗藏类，称为超态 (magamorphic)。
如果一个插槽中存在多态或者超态时，执行效率是低于单态的（多了比拟的过程）
参考资料：
- V8 中的多态内联缓存 PIC
《图解 Google V8》学习笔记系列
- 《图解 Google V8》设计思维篇——学习笔记（一）