Javascript V8如何使用隐藏类和内联缓存优化代码
最近我遇到了V8用来优化js代码的隐藏类和内联缓存的概念。酷 我知道对象在内部表示为隐藏类。两个对象可能具有相同的特性,但隐藏类不同(取决于特性的指定顺序) 另外,V8使用内联缓存概念直接检查偏移量以访问对象的属性,而不是使用对象的隐藏类来确定偏移量 代码-Javascript V8如何使用隐藏类和内联缓存优化代码,javascript,node.js,v8,Javascript,Node.js,V8,最近我遇到了V8用来优化js代码的隐藏类和内联缓存的概念。酷 我知道对象在内部表示为隐藏类。两个对象可能具有相同的特性,但隐藏类不同(取决于特性的指定顺序) 另外,V8使用内联缓存概念直接检查偏移量以访问对象的属性,而不是使用对象的隐藏类来确定偏移量 代码- function Point(x, y) { this.x = x; this.y = y; } function processPoint(point) { // console.log(point.x, poi
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();
})();
问题:
还有更多..这里是V8开发者。总结是:微标记很难,不要这样做。 首先,在代码已发布的情况下,我将
380
作为输出,这是预期的,因为函数processPoint
为空,所以无论选择哪个点对象,所有循环都做相同的工作(即不工作)
测量单态和双向多态内联缓存之间的性能差异是困难的,因为它不是很大,所以您必须非常小心您的基准测试正在做什么<例如,code>console.log,速度非常慢,它会影响其他所有内容
您还必须小心内联的影响。当您的基准测试有很多次迭代时,代码将得到优化(在运行waaaay两次以上之后),优化编译器将(在某种程度上)内联函数,这可以允许后续优化(特别是:消除各种因素),从而显著改变您正在测量的内容。编写有意义的微基准很难;您将无法绕过检查生成的程序集和/或了解正在研究的JavaScript引擎的实现细节
另一件需要记住的事情是内联缓存的位置,以及随着时间的推移它们将处于什么状态。忽略内联,像processPoint
这样的函数不知道或不关心从何处调用它。一旦其内联缓存是多态的,它们将保持多态性,即使稍后在您的基准测试中(在本例中,在第二和第三个循环中)类型稳定
在尝试隔离效果时,另一件要记住的事情是,长时间运行的函数将在运行时在后台编译,然后在某个时候在堆栈(“OSR”)上被替换,这会给您的测量添加各种噪声。当您使用不同的循环长度调用它们进行预热时,它们仍然会在后台编译,并且无法可靠地等待后台作业。您可以求助于用于开发的命令行标志,但这样您就不再测量常规行为了
无论如何,下面是一个与您的测试类似的尝试,可以产生合理的结果(在我的机器上大约100 180 280
):
函数点(){}
//这三个函数是相同的,但它们的调用方式不同
//输入,从而收集不同类型的反馈:
函数processPointMonomorphic(N,point){
设和=0;
for(设i=0;i
这里是V8开发者。总结是:微标记很难,不要这样做。
首先,在代码已发布的情况下,我将380
作为输出,这是预期的,因为函数processPoint
为空,所以无论选择哪个点对象,所有循环都做相同的工作(即不工作)
测量单态和双向多态内联缓存之间的性能差异是困难的,因为它不是很大,所以您必须非常小心您的基准测试正在做什么<例如,code>console.log,速度非常慢,它会影响其他所有内容
您还必须小心内联的影响。当您的基准测试有很多次迭代时,代码将得到优化(在运行waaaay两次以上之后),优化编译器将(在某种程度上)内联函数,这可以允许后续优化(特别是:消除各种因素),从而显著改变您正在测量的内容。写有意义的微博客
3553 4805 4556
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);