javascript - Firefox no parece ser más rápido usando el perfil asm.js, sin embargo, Chrome es

performance google-chrome

Question

Estoy tratando de entender cómo funciona exactamente ASM y cuándo funciona.

Tomé una pequeña función del sitio web asm.js. Lo envuelvo usando el patrón del módulo: una vez para asm, una con la misma sintaxis pero sin la anotación "use asm", y una vez como 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);
};
}())

Creé un jsperf pequeño: el código jsperf es ligeramente diferente al anterior, incorporando sugerencias del hilo de discusión a continuación http://jsperf.com/asm-simple/7

El rendimiento muestra que Firefox 22 es más lento con la sintaxis asm (con o sin la anotación "usar asm") y Chrome es más rápido en modo asm.

Entonces mi pregunta es: ¿cómo es esto posible? Esperaría que Firefox fuera el más rápido en modo asm. No esperaría ver una diferencia para Chrome. ¿Utilizo una sintaxis asm incorrecta? ¿Qué me estoy perdiendo?

Cualquier consejo o aclaración es muy apreciado. Gracias,

Answer 1

Cuando ejecuta el código en Firefox, a menudo puede ver una gran caída en la velocidad de las llamadas asm.js, que probablemente se deba a la compilación repetida (que es visible en la consola) o al costo de las llamadas js-asm. Esta hipótesis es fortalecida por Luke Wagner , implementador de asm.js:

un error de rendimiento que ya conocemos hace tropezar a las personas que intentan comparar asm.js es que llamar desde no-asm.js a asm.js y viceversa es mucho más lento que las llamadas normales debido a las rutinas de entrada / salida de propósito general . Planeamos solucionar esto en los próximos meses, pero, mientras tanto, para fines de evaluación comparativa, intente que toda la computación ocurra dentro de un único módulo asm.js, sin necesidad de invocaciones.

Para verlo usted mismo, mire el violín: http://jsperf.com/asm-simple/10

• Firefox 26: 22,600K ops / sec en caso de asm-asm contra 300 (!) En caso de asm-js.
• Chrome 28: 18K vs 13K
• IE11: ~ 7.5K para todas las pruebas, no se observa gran diferencia, excepto para la eliminación del código muerto, donde brilla ;)