asm.js

asm.js

Designed by	Mozilla
First appeared	21 March 2013(2013-03-21)
OS	Platform independent
Website	asmjs.org
Influenced by
JavaScript
Influenced
WebAssembly

asm.jsis asubsetofJavaScriptdesigned to allowcomputer softwarewritten in languages such asCto be run asweb applicationswhile maintaining performance characteristics considerably better than standardJavaScript,which is the typical language used for such applications.

asm.js consists of astrict subsetof JavaScript, to which code written instatically typedlanguages with manual memory management (such as C) is translated by asource-to-source compilersuch asEmscripten(based onLLVM).Performance is improved by limiting language features to those amenable toahead-of-time optimizationand other performance improvements.

Mozilla Firefoxwas the first web browser to implement asm.js-specific optimizations, starting with version 22.

asm.js is superseded byWebAssembly.

Design

asm.js enables significant performance improvements forweb applications,but does not aim to improve the performance of hand-written JavaScript code, nor does it enable anything other than enhanced performance.

It is intended to have performance characteristics closer to that of native code than standard JavaScript by limiting language features to those amenable toahead-of-time optimizationand other performance improvements.By using a subset of JavaScript, asm.js is largely supported by all majorweb browsers,unlike alternative approaches such asGoogle Native Client.

Code generation

asm.js is not typically written directly: instead, as an intermediate language, it is generated through the use of acompilerthat takes source code in a language such asC++and outputs asm.js.

For example, given the following C code:

intf(inti){
returni+1;
}

Emscripten would output the following JS code:

functionf(i){
i=i|0;
return(i+1)|0;
}

Note the addition of|0and the lack of type specifiers. In JavaScript, bitwise operators convert their operands to 32-bit signed integers and give integer results. This means that abitwise ORwith zero converts a value to an integer (a very simple "conceptual" presentation of bitwise operators may not deal with type conversion at all, but every programming language defines operators for its own convenience, as Javascript does here). By doing this for each parameter, this ensures that if the function is called from outside code, the value will be converted to the correct type. This is also used on the return value, in this case to ensure that the result of adding 1 to i will be an integer (as otherwise it could become too large), and to mark the return type of the function. These conversions are required by asm.js, so that an optimising compiler can produce highly efficient native code ahead-of-time. In such an optimising compiler, no conversions are performed when asm.js code calls other asm.js code, as the required type specifiers mean it is guaranteed that values will already have the correct type. Furthermore, rather than performing a floating-point addition and converting to an integer, it can simply do a native integer operation. Together, this leads to significant performance benefits.

Here is another example to calculate the length of a string:

size_tstrlen(char*ptr){
char*curr=ptr;
while(*curr!=0){
curr++;
}
return(curr-ptr);
}

This would result in the following asm.js code:

functionstrlen(ptr){
ptr=ptr|0;
varcurr=0;
curr=ptr;
while((MEM8[curr>>0]|0)!=0){
curr=(curr+1)|0;
}
return(curr-ptr)|0;
}

In the generated code, the variable MEM8 is actually a byte-by-byte "view" of a typed buffer, which serves as the "heap" of the asm.js code.

Performance

Since asm.js runs in a browser, the performance heavily depends on both the browser and hardware. Preliminary benchmarks of C programs compiled to asm.js are usually within a factor of 2 slower than native compilation withClang.

Much of this performance gain over normal JavaScript is due to 100%typeconsistency and virtually nogarbage collection(memory is manually managed in a large typed array). This simpler model with no dynamic behavior, no memory allocation or deallocation, just a narrow set of well-defined integer and floating point operations enables much greater performance and potential foroptimization.

Mozilla's benchmark from December 2013 showed significant improvements: "Firefox withfloat32optimizations can run all those benchmarks at around 1.5× slower than native, or better. "Mozilla points out that the performance of natively compiled code is not a single measure but rather a range, with different native compilers (in this caseClangandGCC) delivering code of differing performance. "In fact, on some benchmarks, likeBox2D,FASTAand copy, asm.js is as close or closer to Clang than Clang is to GCC. In one case, asm.js even beats Clang by a slight amount on Box2D. "

Implementations

TheEmscriptenproject provides tools that can be used to compile C and C++ codebases (or any other languages that can be converted toLLVMIR) into asm.js.

All browsers with support forECMAScript 6should be able to run asm.js code, as it is a subset of that specification. However, since features were added in that edition to enable full asm.js support (Math.fround()), older browsers lacking those features may encounter problems.

Some browser implementations are especially optimised for asm.js:

• Mozilla Firefoxwas the first web browser to implement asm.js-specific optimizations, starting with Firefox 22.OdinMonkey,Mozilla's asm.js ahead-of-time compiler used in Firefox, is a component ofIonMonkey,the JIT compiler ofSpiderMonkey.
• Microsoft was implementing support for asm.js inChakra,the JavaScript engine used byMicrosoft Edge Legacy,performing validation to produce highly optimised JIT code.
• The optimizations ofGoogle Chrome'sV8 JavaScript enginein Chrome 28 made asm.js benchmarks more than twice as fast as prior versions of Chrome,although Chrome's V8 does not use ahead-of-time compilation.

Adoption

Almost all of the current applications based on asm.js are C/C++ applications compiled to asm.js usingEmscriptenor Mandreel. With that in mind, the kind of applications that are going to target asm.js in the near future are those that will benefit from the portability of running in a browser but which have a level of complexity for which a direct port to JavaScript would be infeasible.

So far, a number ofprogramming languages,application frameworks,programs,libraries,games,game enginesand other software have already beenported.Some of them are given below.

Programming languages

• C/C++:ClangandLLVM
• Rust:targetsEmscripten
• Perl:port of (micro)perl-5.16.3
• Python– port ofCPython
• Ruby– port of Ruby

Application frameworks

• pepper.js: Ports of miscellaneousPNaClapps (earth, voronoi, bullet, etc.)
• Qt:ports of various Qt demos, plus KDE apps, such asKate

Programs and libraries

• OpenGL,SDL,andSDL2
• Vim(Vi IMproved)
• FreeType:TrueTypefont renderingin JavaScript, using FreeType
• SQLite
• GNU Privacy Guard
• ctags
• gnuplot
• Graphviz
• zlib

Game engines

• Unreal Engine 3:was ported in 4 days
• Unreal Engine 4
• Unity
• ScummVM,which supports numerous classic adventure games
• Godot

Games

• Doom:the open sourceFreedoomgame assets running onPrBoom,which is based on the open source Doom code
• SuperTux
• Dune IIvia OpenDune
• BananaBreadbased onCube 2
• Every game in theHumble Mozilla Bundle(Super Hexagon,AaAaAA! for the Awesome,Osmos,Zen Bound 2,Dustforce DX,Voxatron,FTL: Advanced EditionandDemocracy 3)

Emulators

• EM-DOSBox: an Emscripten port ofDOSBox
• Start9.io:a web emulation platform targeting multiple gaming architectures
• JSMESS: a port of theMESSemulator for many game consoles and computer systems

Mathematics

• HTML5 Fractal Playground– draws iterating-function generatedfractals,such as theMandelbrot set.

Deprecation

asm.js is mostly rendered obsolete with the introduction ofWebAssembly(wasm), which has a bytecode format that is faster to parse.Efforts to extend JavaScript with more low-level features like SIMD.js has also been suspended since 2017.

asm.js remains useful primarily as a "fallback" for wasm, through a program written by the WebAssembly organization that converts wasm to asm.js. There is no dedicated converter from asm.js to wasm, butTypeScript-to-wasm compilers can be partially used.The reference WebAssembly emitter binaryen used to contain anasm2wasmmodule, but it was removed after Emscripten stopped using it.

See also

• CrossBridge
• RPython
• AssemblyScript

External links

• Official website