emscripten-fastcomp

It looks like the slowdown on wasm is related to the powi call in the distance function (which the benchmark page mentions as a likely suspect). Emscripten currently compiles @llvm.powi into a JS Math.pow call, however this powi call is just being used to multiply a number by itself. I filed this issue: https://github.com/kripken/emscripten-fastcomp/issues/171 to track this issue in Emscripten. In JS, the assumption is that code may be written by humans, so engines are expected to optimize things like Math.pow calls with small integer exponents implicitly, which is likely why this code is faster in JS. And in the asm.js case, the page mentions that it's using "almost asm", which is not actually asm.js, so it's using the JS optimizations. This is one of the characteristic differences between JS and WebAssembly: in WebAssembly, the compi

Today Rust only has a [few patches to LLVM](https://github.com/rust-lang/llvm/tree/rust). One is for Android stack overflow detection using a mechanism that upstream isn't fond of (split stacks), the other an optimization not required for correctness. The Android patch can be eliminated someday with stack probes (though it's not clear upstream wants those either). Emscripten support though - at least in the short term - is going to bring in the [emscripten LLVM 'fastcomp' backend](https://github.com/kripken/emscripten-fastcomp) that translates LLVM IR to JS. This patch has no hope of being upstreamed and will impose significant maintenance burden on both Rust and Emscripten as long as its in tree. This solution should be short-lived though as we will transition to either the upstream LLVM->wasm backend or a new Rust MIR->wasm backend. So

One option is the relooper [1][2] which is used in emscripten. It recreates high-level control structures as best it can, then falls back to a helper variable when it can't. Another option is node-splitting, where irreducible control flow is solved by duplicating code (but that has a bad worst-case code size increase). [1] http://dl.acm.org/citation.cfm?doid=2048147.2048224 [2] https://github.com/kripken/emscripten-fastcomp/blob/master/l...

A lot of Rust people are interested in Rust -> LLVM -> Emscripten -> JS, but there's still a lot of work to do. https://github.com/rust-lang/rust/issues/2235 - and integration is literally going on as we speak, https://github.com/kripken/emscripten-fastcomp/issues/51 . I'm also very excited about Rust - so many other languages that give its kind of safety guarantees are either horribly hard to performance-optimize, or very difficult for someone from a C/C++ background to reason about. As the ecosystem and availability of libraries improves, I see it becoming every bit as big as Go is.