标签: v8

这个问题是参考这个旧问题的，在哪里可以找到javascript-native-functions-source-code

该页面上的答案说，源代码在其中c，c++但我很好奇为什么源（定义）是这些语言的？我的意思是它们是JS函数的定义，例如toString()方法。这是一个JavaScript函数，因此必须使用Javascript语法编写其定义。

toString;在chrome控制台输出中function toString() { [native code] }。

如果它是用户定义的函数，那么您可以看到定义，但看不到它，toString()或者就此而言，其他内置函数毕竟只是函数/方法，必须用JavaScript语法定义，以便引擎正确解释它们。

希望您能理解我要提出的观点。

为了提高性能 JavaScript 引擎有时只在实际调用函数时才完全解析它们。

例如，来自Spidermonkey源代码：

检查函数的语法比执行完整解析/发出快几倍，当页面包含大量永远不会执行的代码（这种情况经常发生）时，延迟解析可以显着提高性能和内存使用率。

解析器可以跳过哪些步骤，同时仍然能够验证语法？

似乎在 Spidermonkey 中，一些节省来自不发出字节码，例如在完整解析之后。例如 V8 中的完整解析是否还包括生成机器代码？

你好V8程序员和节点gyp'ers.我跑OS X 10.12.6,Node v6.11.1有npm v3.10.10,nan v2.6.2,gcc为的XCode与此版本输出的一部分:

$ > gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 8.1.0 (clang-802.0.42)
Target: x86_64-apple-darwin16.7.0
Thread model: posix

请帮助我了解如何正确使用NewInstance方法和过程中消除警告npm install或node-gyp rebuild我的自定义程序包安装的过程吗？

> node-gyp rebuild

  CXX(target) Release/obj.target/cellcrypt/src/cellcrypt.o
  CC(target) Release/obj.target/cellcrypt/src/decode.o
  CXX(target) Release/obj.target/cellcrypt/src/DecryptionWrapper.o
../src/DecryptionWrapper.cpp:55:44: warning: 'NewInstance' is deprecated [-Wdeprecated-declarations]
    v8::Local<v8::Object> instance = cons->NewInstance();
                                       ^
/Users/sjcbsolo/.node-gyp/6.11.1/include/node/v8.h:3276:52: note: 'NewInstance' has been explicitly marked deprecated here
  V8_DEPRECATED("Use maybe version", Local<Object> NewInstance() const);
                                               ^
1 warning generated. …

我已经阅读了 V8 中的隐藏类，并在 d8 调试器 shell 中进行了一些测试。

function Vector(a, b) {
  this.a = a;
  this.b = b;
}

var x = new Vector(1, 2);
var y = new Vector(1, 3);
var z = new Vector(1, 'a');

print( %HaveSameMap( x, y ) ); //true
print( %HaveSameMap( x, z ) ); //false
x.b;
print( %HaveSameMap( x, z ) ); //true
print( %HaveSameMap( y, z ) ); //false
y.b;
print( %HaveSameMap( y, z ) ); //true

正如我们所看到的，如果对象属性类型不同，它们不会共享它们的隐藏类，直到我们尝试访问类型不同的 Elder 对象中的属性。任何人都可以清楚地解释“幕后”发生了什么，也许它与内联缓存有关。

我正在开发一款游戏，因此必须考虑小的性能提升和大的性能提升。

我正在阅读 V8 中的数组初始化，特别是这篇文章，它表明使用该格式var myArray = new Array(100)最终比var myArray = []使用小数组更快（作者建议使用少于 ~1000 个元素作为小数组的阈值）。

鉴于一些假设，不难看出原因。特别是，如果数组的元素在优化后都是相同类型的，比如都是整数，它们应该被预先分配在连续的内存中，并且不会导致 V8 改变它的数组内部表示，如这里所述。这也将允许编译器在其他地方使用元素时对形状进行假设。

然而，在我的情况下，我需要一个对象引用数组，并且我能够按顺序初始化它们。所以，继续我们从上面知道的，我想出了这个：

class A {
    constructor() {
        this.particles = new Array(60);
        for (var i = 0; i < particles.length; ++i) {
            this.particles[i] = new Particle();
        }
    }
}
class Particle {
    //...
}

正如第一篇文章所描述的，这是他操作数字类型的最快方法。因此，我假设 V8 假定每个数组的其中一种本机数字类型的大小并为其分配空间。但是，我不确定是哪个。我也不确定对象引用的大小与为每个元素分配的任何本机类型的大小相比如何。

一个较小的问题是，如果默认元素大小分配大于只包含对对象的引用（所有类型都相同，并且都假定在内存中连续）的数组所需的空间，那么每个数组会浪费空间具有此数组初始化策略的元素？有没有办法避免这种情况？如果是这样，是否可以保留访问速度的优化？

优化每个访问的速度，Particle上面的初始化可以改进吗？

我有一个看起来像这样的系统：

    interface Data {
        x: number;
        y: number;
        n: string;
    }

    const array = Array<Data>(100);

我读过在 Chrome 中，如果数组只包含相同的类型，V8 引擎会将对象分配为 C 数组，但是否可以实际检查我的“数组”对象是否将充当 C 数组或字典，例如内存是连续分配的？

如果这不能完成，我知道我可以使用像这样使用 TypedArrays 的 SoA 模型：

    interface Data {
        x: Float64Array;
        y: Float64Array;
        n: ????;
    }

    const dataArray = {
        x: new Float64Array(100),
        y: new Float64Array(100),
        n: ????????
    } as Data

但是我不知道如何将字符串存储在这样的数组中

所以我对以下代码进行了基准测试，试图找出哪个会更高效：

'use strict';

function addSetToArrayA(array, set) {
  for (const v of set) {
    array.push(v);
  }
}
function addSetToArrayB(array, set) {
  const origLength = array.length;
  const newLength = array.length + set.size;
  array.length = newLength;
  array[newLength - 1] = 0;
  let i = origLength;
  for (const v of set) {
    array[i++] = v;
  }
}

const set = new Set([1, 2, 3, 4, 5, 6]);

console.time('addSetToArrayA');
for (let i = 0;i<0xffffff;++i) {
  const base = [1, 2, 3, 4, 5, 6];
  addSetToArrayA(base, …

在阅读v8的源代码时，我有一个我不太了解的部分。

  v8::Isolate::CreateParams create_params;
  create_params.array_buffer_allocator =
      v8::ArrayBuffer::Allocator::NewDefaultAllocator();
  v8::Isolate* isolate = v8::Isolate::New(create_params);

我跟踪了v8 :: Isolate :: New的实现，然后发现以下代码：

// static
Isolate* Isolate::Allocate() {
  return reinterpret_cast<Isolate*>(i::Isolate::New());
}

因为我读了一些代码，所以我知道“ i”的意思是“内部的”，但是我不确定其余的内容。v8 :: Isolate和v8 :: internal :: Isolate是否兼容？

最近接触到 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 …

从这篇旧文章中阅读 V8（微）优化 并引用：

始终以相同的顺序初始化对象成员

问题：在下面的示例中，始终以相同顺序初始化对象成员是什么意思？

function Point(x, y) {
  this.x = x; // this.x = x line first because x is the first arg
  this.y = y; // this.y = y line second because y is the second arg
}

var p1 = new Point(11, 22);
var p2 = new Point(33, 44);
// At this point, p1 and p2 have a shared hidden class
p2.z = 55;
// warning! p1 and p2 now have different hidden …