javascript - V8 如何使用隐藏类和内联缓存优化代码

Question

最近我遇到了 V8 用来优化 js 代码的隐藏类和内联缓存的概念。酷。

我知道对象在内部表示为隐藏类。两个对象可能具有相同的属性，但具有不同的隐藏类(取决于属性分配的顺序)。

V8还使用内联缓存概念直接检查偏移量来访问对象的属性，而不是使用对象的隐藏类来确定偏移量。

代码 -

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

function processPoint(point) {
    // console.log(point.x, point.y, point.a, point.b);
    // let x = point;
}

function main() {
    let p1 = new Point(1, 1);
    let p2 = new Point(1, 1);
    let p3 = new Point(1, 1);
    const N = 300000000;
    p1.a = 1;
    p1.b = 1;
    p2.b = 1;
    p2.a = 1;
    p3.a = 1;
    p3.b = 1;
    let start_1 = new Date();
    for(let i = 0; i< N; i++ ) {
        if (i%4 != 0) {
            processPoint(p1);
        } else {
            processPoint(p2)
        }
    }
    let end_1 = new Date();
    let t1 = (end_1 - start_1);
    let start_2 = new Date();
    for(let i = 0; i< N; i++ ) {
        if (i%4 != 0) {
            processPoint(p1);
        } else {
            processPoint(p1)
        }
    }
    let end_2 = new Date();
    let t2 = (end_2 - start_2);
    let start_3 = new Date();
    for(let i = 0; i< N; i++ ) {
        if (i%4 != 0) {
            processPoint(p1);
        } else {
            processPoint(p3)
        }
    }
    let end_3 = new Date();
    let t3 = (end_3 - start_3);
    console.log(t1, t2, t3);
}

(function(){
    main();
})();

我期望结果像 t1 > (t2 = t3) 因为:

第一次循环:V8在运行两次后会尝试优化，但很快就会遇到不同的隐藏类，因此会去优化。

第二个循环:始终调用同一个对象，因此可以使用内联缓存。

第三个循环:与第二个循环相同，因为隐藏类相同。

但结果并不令人满意。我得到了(并且一次又一次运行类似的结果) -

3553 4805 4556

问题:

1. 为什么结果不符合预期？我的假设哪里出了问题？

2. 如何更改此代码以演示隐藏类和内联缓存性能改进？

3. 我从一开始就全错了吗？

4. 隐藏类的存在只是为了通过让对象共享它们来提高内存效率吗？

5. 还有其他网站提供一些简单的性能改进示例吗？

我正在使用 Node 8.9.4 进行测试。提前致谢。

来源:

1. https://blog.sessionstack.com/how-javascript-works-inside-the-v8-engine-5-tips-on-how-to-write-optimized-code-ac089e62b12e

2. https://draft.li/blog/2016/12/22/javascript-engines-hidden-classes/

3. https://richardartoul.github.io/jekyll/update/2015/04/26/hidden-classes.html

还有更多..

Answer 1

V8 开发人员在这里。总结是:微基准测试很难，不要这样做。

首先，根据发布的代码，我看到 380 380 380 作为输出，这是预期的，因为 function processPoint 为空，因此所有循环无论您选择哪个点对象，都执行相同的工作(即不工作)。

测量单态和 2 路多态内联缓存之间的性能差异很困难，因为它并不大，因此您必须非常小心基准测试正在执行的其他操作。例如，console.log 速度太慢，以至于会掩盖其他所有内容。

您还必须小心内联的影响。当你的基准测试有多次迭代时，代码将得到优化(在运行 waaaay 两次以上之后)，并且优化编译器将(在某种程度上)内联函数，这可以允许后续优化(特别是:消除各种事情)，从而可以显着改变你正在测量的东西。编写有意义的微基准测试很困难；您将无法回避检查生成的程序集和/或了解大量有关您正在研究的 JavaScript 引擎的实现细节。

要记住的另一件事是内联缓存的位置以及随着时间的推移它们将具有什么状态。忽略内联，像 processPoint 这样的函数不知道也不关心它是从哪里调用的。一旦其内联缓存是多态的，它们将保持多态，即使稍后在基准测试中(在本例中，在第二个和第三个循环中)类型稳定下来。

在尝试隔离效果时要记住的另一件事是，长时间运行的函数将在运行时在后台进行编译，然后在某个时刻在堆栈上被替换(“OSR”)，这增加了您的测量中存在各种噪音。然而，当您使用不同的循环长度调用它们进行预热时，它们仍然会在后台进行编译，并且无法可靠地等待该后台作业。您可以诉诸用于开发的命令行标志，但随后您将不再测量常规行为。

无论如何，以下是尝试制作与您类似的测试，该测试会产生合理的结果(在我的机器上大约为 100 180 280):

function Point() {}

// These three functions are identical, but they will be called with different
// inputs and hence collect different type feedback:
function processPointMonomorphic(N, point) {
  let sum = 0;
  for (let i = 0; i < N; i++) {
    sum += point.a;
  }
  return sum;
}
function processPointPolymorphic(N, point) {
  let sum = 0;
  for (let i = 0; i < N; i++) {
    sum += point.a;
  }
  return sum;
}
function processPointGeneric(N, point) {
  let sum = 0;
  for (let i = 0; i < N; i++) {
    sum += point.a;
  }
  return sum;
}

let p1 = new Point();
let p2 = new Point();
let p3 = new Point();
let p4 = new Point();

const warmup = 12000;
const N = 100000000;
let sum = 0;
p1.a = 1;
p2.b = 1;
p2.a = 1;
p3.c = 1;
p3.b = 1;
p3.a = 1;
p4.d = 1;
p4.c = 1;
p4.b = 1;
p4.a = 1;
processPointMonomorphic(warmup, p1);
processPointMonomorphic(1, p1);
let start_1 = Date.now();
sum += processPointMonomorphic(N, p1);
let t1 = Date.now() - start_1;

processPointPolymorphic(2, p1);
processPointPolymorphic(2, p2);
processPointPolymorphic(2, p3);
processPointPolymorphic(warmup, p4);
processPointPolymorphic(1, p4);
let start_2 = Date.now();
sum += processPointPolymorphic(N, p1);
let t2 = Date.now() - start_2;

processPointGeneric(warmup, 1);
processPointGeneric(1, 1);
let start_3 = Date.now();
sum += processPointGeneric(N, p1);
let t3 = Date.now() - start_3;
console.log(t1, t2, t3);