Asm. js performance approaches native code

Asm. js is a high-performance subset of JavaScript, which simplifies features and facilitates optimization. Mozilla now announces that the performance of asm. js is further closer to that of native. The speed of asm. js has reached 2/3 of that of native code, and it can only reach 1/2 or even lower in the past. Mozilla improves the performance of asm. js by changing the processing method of floating point algorithms.

By default, JavaScript uses the float64 data type to provide the maximum data precision. However, compared with int, int32, float, and float32 data types with a smaller range, float64 is less efficient, mozilla SpiderMonkey engine in asm. the float32 data type is added to js, which allows direct translation of the float32 algorithm in the C/C ++ program to asm. js float32 algorithm.

Mozilla believes that the performance of asm. js can be further improved.

Asm. js is an underlying compiler optimized for the JavaScript subset. This is a Mozilla research project, similar to Emscripten, Mandreel, and LLJS.

Sample Code:

 
 

  
  
function mymodule(global, foreign, buffer) { 
  
  
    "use asm"; 
  
  
 
  
  
    // ------------------------------------------------------------------------- 
  
  
    // SECTION 1: imports 
  
  
 
  
  
    var H32 = new global.Int32Array(buffer); 
  
  
    var HU32 = new global.Uint32Array(buffer); 
  
  
    var log = foreign.consoleDotLog; 
  
  
 
  
  
    // ------------------------------------------------------------------------- 
  
  
    // SECTION 2: functions 
  
  
 
  
  
    function f(x, y, z, w) { 
  
  
        // SECTION A: parameter type declarations 
  
  
        x = x|0;      // int parameter 
  
  
        y = +y;       // double parameter 
  
  
 
  
  
        // SECTION B: function body 
  
  
        log(x|0);     // call into FFI -- must force the sign 
  
  
        log(y);       // call into FFI -- already know it's a double 
  
  
        x = (x+3)|0;  // signed addition 
  
  
 
  
  
        // SECTION C: unconditional return 
  
  
        return ((((x+1)|0)>>>0)/(x|0))>>>0; // compound expression 
  
  
    } 
  
  
 
  
  
    function g() { 
  
  
        g_f = +g_i; // read/write globals 
  
  
        return; 
  
  
    } 
  
  
 
  
  
    function g2() { 
  
  
        return; 
  
  
    } 
  
  
 
  
  
    function h(i, x) { 
  
  
        i = i|0; 
  
  
        x = x|0; 
  
  
        H32[(i&0xffffffff)>>4] = x; // masked by 2^k-1, shifted by byte count 
  
  
        ftable_2[(x-2)&2]();        // dynamic call of functions in table 2 
  
  
    } 
  
  
 
  
  
    // ------------------------------------------------------------------------- 
  
  
    // SECTION 3: function tables 
  
  
 
  
  
    var ftable_1 = [f]; 
  
  
    var ftable_2 = [g, g2]; // all of the same type 
  
  
 
  
  
    // ------------------------------------------------------------------------- 
  
  
    // SECTION 4: globals 
  
  
 
  
  
    var g_i = 0;   // int global 
  
  
    var g_f = 0.0; // double global 
  
  
 
  
  
    // ------------------------------------------------------------------------- 
  
  
    // SECTION 5: exports 
  
  
 
  
  
    return { f_export: f, goop: g }; 
  
  
}