Firefox ne semble pas être plus rapide en utilisant le profil asm.js, mais Chrome l'est.

Question

J'essaie de comprendre comment fonctionne exactement l'ASM et quand il intervient.

J'ai pris une petite fonction du site asm.js. Je l'ai enveloppée en utilisant le modèle de module : une fois pour asm, une fois avec la même syntaxe mais sans l'annotation "use asm", et une fois comme vanilla-javascript.

 var add_asm = (function MyAOTMod(stdlib, foreign, heap) {
  "use asm";
  var sqrt = stdlib.Math.sqrt;

  function square(x) {
    x = +x;
    return +(x * x);
  }
  return function(x, y) {
    x = +x; // x has type double
    y = +y; // y has type double
    return +sqrt(square(x) + square(y));
  };
}(window));

var add_reg_asmstyle = (function MyAsmLikeRegularMod() {

  function square(x) {
    x = +x;
    return +(x * x);
  }
  return function(x, y) {
    x = +x; // x has type double
    y = +y; // y has type double
    return +Math.sqrt(square(x) + square(y));
  };
}());

var add_reg = (function MyStrictProfile() {
  "use strict";
  return function(x, y) {
    return Math.sqrt(x * x + y * y);
  };
}())

J'ai créé un petit jsperf : le code jsperf est légèrement différent du précédent, incorporant des astuces du fil de discussion ci-dessous http://jsperf.com/asm-simple/7

Les performances montrent que firefox 22 est le plus lent avec la syntaxe asm (avec ou sans l'annotation "use asm"), et que chrome est le plus rapide en mode asm.

Ma question est donc la suivante : comment cela est-il possible ? Je m'attendrais à ce que Firefox soit le plus rapide en mode asm. Je ne m'attendrais pas à voir une différence pour Chrome. Est-ce que j'utilise une mauvaise syntaxe asm ? Qu'est-ce qui me manque ?

Tout conseil ou éclaircissement est le bienvenu. Merci,

Answer 1

Lorsque vous exécutez du code dans Firefox, vous pouvez souvent constater une énorme baisse de vitesse pour les appels asm.js, qui est très probablement causée soit par la compilation répétée (qui est visible dans la console), soit par le coût des appels js-to-asm. Cette hypothèse est renforcée par les éléments suivants Luke Wagner , implémenteur de asm.js :

Un défaut de performance que nous connaissons déjà et qui gêne les personnes qui essaient d'évaluer asm.js est que L'appel de non-asm.js vers asm.js et vice versa est beaucoup plus lent que les appels normaux en raison de des routines d'entrée/sortie à usage général . Nous prévoyons de corriger ce problème dans les prochains mois à venir mais, en attendant, pour des raisons de benchmarking, essayez de de garder l'ensemble du calcul à l'intérieur d'un seul module asm.js, sans faire d'appels entrants et sortants.

Pour le voir par vous-même - regardez le violon : http://jsperf.com/asm-simple/10

• Firefox 26 : 22,600K ops/sec dans le cas de l'asm-asm contre 300 ( !) dans le cas de asm-js.
• Chrome 28 : 18K vs 13K
• IE11 : ~7.5K pour tous les tests, pas de grande différence observée, sauf pour l'élimination des codes morts, où il brille. ;)