Pourquoi le nouveau est lent?

la principale différence entre le #4 et tous les autres cas est que la première fois que vous utilisez une fermeture comme constructeur est toujours très chère.

1. il est toujours manipulé dans V8 runtime (pas dans le code généré) et la transition entre le code JS compilé et C++ runtime est très chère. Les attributions subséquentes sont habituellement traitées en code généré. Vous pouvez prendre un coup d'oeil à Generate_JSConstructStubHelperbuiltins-ia32.cc et un avis qui passe à travers les Runtime_NewObject lors de la fermeture n'a pas de initiale de la carte. (voir http://code.google.com/p/v8/source/browse/trunk/src/ia32/builtins-ia32.cc#138)

2. lorsque closure est utilisé comme constructeur pour la première fois, V8 doit créer une nouvelle carte (alias hidden class) et l'assigner comme carte initiale pour cette fermeture. Voir http://code.google.com/p/v8/source/browse/trunk/src/heap.cc#3266. Ce qui est Important ici, c'est que les cartes sont attribuées dans un espace mémoire séparé. Cet espace ne peut pas être nettoyé par un jeûne partiel récupérer collecteur. Quand l'espace de carte déborde V8 doit effectuer relativement cher plein mark-sweep GC.

il y a quelques autres choses qui se produisent quand vous utilisez la fermeture comme constructeur pour la première fois mais 1 et 2 sont les principaux contributeurs à la lenteur du test case #4.

si nous comparons les expressions #1 et #4, alors les différences sont:

• #1 n'affecte pas une nouvelle fermeture de tous les temps;
• #1 n'entre pas l'exécution à chaque fois: après la fermeture obtient la construction de la carte initiale est traitée dans le chemin rapide du code généré. Gérer toute la construction en code généré est beaucoup plus rapide que de faire des allers - retours entre l'exécution et le code généré;
• #1 n'attribue pas de nouvelle carte initiale pour chaque nouvelle fermeture à chaque fois;
• #1 ne cause pas une marque de balayages par débordement de la carte de l'espace (seulement bon marché piège).

si nous comparons #3 et #4, alors les différences sont:

• #3 n'attribue pas de nouvelle carte initiale pour chaque nouvelle fermeture à chaque fois;
• n ° 3 n'entraîne pas une marque de balayages par débordement de la carte de l'espace (seulement bon marché, piège);
• #4 fait moins du côté de JS (aucune fonction.prototype.d'appel, pas d'Objet.créer, pas d'Objet.prototype lookup etc) plus sur le côté C++ (#3 entre aussi runtime chaque fois que vous faites objet.crée mais fait très peu y.)

en résumé, la première fois que vous utilisez closure en tant que constructeur est coûteuse par rapport aux appels de construction ultérieurs du fermeture parce que V8 doit installer de la plomberie. Si nous rejetons immédiatement la fermeture, nous rejetons en gros tout le travail que V8 a fait pour accélérer les appels subséquents du constructeur.

je suppose que les points suivants expliquent ce qui se passe en V8:

1. t(exp1) : t(Création de l'Objet)
2. t (exp2): t(création D'objet par objet.créer())
3. t (exp3): t(création D'objet par objet.créer()) + t(Fonction de Création de l'Objet)

4. t(exp4) : t(Création de l'Objet) + t(Fonction de Création de l'Objet) + t(Classe de Création de l'Objet)[Chrome]

   • pour les Classes cachées dans Chrome regardez : http://code.google.com/apis/v8/design.html.
   • quand un nouvel objet est créé par objet.créer aucun nouvel objet de classe ne doit être créé. Il y a déjà un qui est utilisé pour les Objets littéraux et pas besoin d'une nouvelle Classe.

Eh bien, ces deux appels ne font pas exactement la même chose. Considérons cet exemple:

var Thing = function () {
  this.hasMass = true;
};
Thing.prototype = { holy: 'object', batman: '!' };
Thing.prototype.constructor = Thing;

var Rock = function () {
  this.hard = 'very';
};
Rock.prototype = new Thing();
Rock.constructor = Rock;

var newRock = new Rock();
var otherRock = Object.create(Object.prototype);
Rock.call(otherRock);

newRock.hard // => 'very'
otherRock.hard // => 'very'
newRock.hasMass // => true
otherRock.hasMass // => undefined
newRock.holy // => 'object'
otherRock.holy // => undefined
newRock instanceof Thing // => true
otherRock instanceof Thing // => false

donc nous pouvons voir que l'appel Rock.call(otherRock) ne provoque pas de otherRock hériter du prototype. Cela doit expliquer au moins une partie de la lenteur ajoutée. Bien que dans mes tests, le new construction est presque 30 fois plus lente, même dans cet exemple simple.

new f;

1. prendre la fonction locale ' f '(accès par index dans le cadre local) - pas cher.
2. exécuter bytecode BC_NEW_OBJECT (ou quelque chose comme ça) - pas cher.
3. exécutez la fonction - cheap ici.

Maintenant ceci:

g.call(Object.create(Object.prototype));

1. trouver global var Object - pas cher?
2. Trouver la propriété prototype dans l'Objet - so-so
3. Trouver la propriété create dans l'Objet - so-so
4. trouver la var g locale; - pas cher
5. Trouver la propriété call - so-so
6. Appeler create fonction - so-so
7. Appeler call fonction - so-so

Et ça:

new (function() { })

1. créer un nouvel objet de fonction (fonction anonyme) - relativement cher.
2. exécuter bytecode BC_NEW_OBJECT - pas cher
3. exécutez la fonction - cheap ici.

comme vous le voyez, le cas n ° 1 est celui qui consomme le moins.