webassembly 的那些事

（点击上方公众号，可快速关注）

作者：刘艳

https://mp.weixin.qq.com/s/lFqvdBvusCcndoBK0-U7kg

简介

JS于1995年问世，设计的初衷不是为了执行起来快。直到08年性能大战中，许多浏览器引入了即时编译 JIT(just-in-time编译器)，JavaScript 代码的运行渐渐变快。正是由于这些 JIT 的引入，使得 JavaScript 的性能达到了一个转折点，JS 代码执行速度快了 20 -- 50倍。

JIT 是使 JavaScript 运行更快的一种手段，通过监视代码的运行状态，把 hot 代码（重复执行多次的代码）进行优化。通过这种方式，可以使 JavaScript 应用的性能提升很多倍。

更多JIT工作原理，有兴趣请移步：https://zhuanlan.zhihu.com/p/25669120

随着性能的提升，JavaScript 可以应用到以前根本没有想到过的领域，比如用于后端开发的 Node.js。性能的提升使得 JavaScript 的应用范围得到很大的扩展。

JavaScript的无类型是JavaScript引擎的性能瓶颈之一，在过去几年，我们看到越来越多的项目问世，它们试图通过开发编译程序，将其他语言代码转化为 JavaScript，以此让开发者克服 JavaScript 自身存在的一些短板。其中一些项目专注于给编程语言增加新的功能，比如微软的 TypeScript 和 Google 的 Dart，【设计一门新的强类型语言并强制开发者进行类型指定】或是加快 JavaScript 的执行速度，例如 Mozilla 的 asm.js 项目和Google的PNaCI【给现有的JavaScript加上变量类型】。

现在通过 WebAssembly，我们很有可能正处于第二个拐点。

什么是webAssembly?

WebAssembly是一种新的适合于编译到Web的，可移植的，大小和加载时间高效的格式，是一种新的字节码格式。它的缩写是".wasm"，.wasm 为文件名后缀，是一种新的底层安全的“二进制”语法。它被定义为“精简、加载时间短的格式和执行模型”，并且被设计为Web 多编程语言目标文件格式。 这意味着浏览器端的性能会得到极大提升，它也使得我们能够实现一个底层构建模块的集合.

webAssembly的优势

webassembly相较于asm.js的优势主要是涉及到性能方面。根据WebAssembly FAQ的描述：在移动设备上，对于很大的代码库，asm.js仅仅解析就需要花费20-40秒，而实验显示WebAssembly的加载速度比asm.js快了20倍，这主要是因为相比解析 asm.js 代码，JavaScript 引擎破译二进制格式的速度要快得多。

主流的浏览器目前均支持webAssembly。

• Safari 支持 WebAssembly的第一个版本是11

• Edge 支持 WebAssembly的第一个版本是16

• Firefox 支持 WebAssembly的第一个版本是 52

• chrome 支持 WebAssembly的第一个版本是 57

使用WebAssembly，我们可以在浏览器中运行一些高性能、低级别的编程语言，可用它将大型的C和C++代码库比如游戏、物理引擎甚至是桌面应用程序导入Web平台。

开发前准备工作（MAC系统）

1.安装 cmake brew install cmake

2.安装 pyhton brew insatll python

3.安装 Emscripten (调整下电脑的休眠时间，不要让电脑进入休眠，安装时间较长)

安装步骤如下：

1. git clone https://github.com/juj/emsdk.git

2. cd emsdk

3. ./emsdk install --build=Release sdk-incoming-64bit binaryen-master-64bit

4. ./emsdk activate --global --build=Release sdk-incoming

5.    -64bit binaryen-master-64bit

执行 source ./emsdkenv.sh，并将shell中的内容添加到环境变量中(~/.bashprofile):

1. export PATH="/Users/liuyan/Work/emsdk:/Users/liuyan/Work/emsdk/clang/fastcomp/build_incoming_64/bin:/Users/liuyan/Work/emsdk/node/8.9.1_64bit/bin:/Users/liuyan/Work/emsdk/emscripten/incoming:/Users/liuyan/Work/emsdk/binaryen/master_64bit_binaryen/bin:/Library/Frameworks/Python.framework/Versions/2.7/bin:/Users/liuyan/.nvm/versions/node/v8.4.0/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/liuyan/Library/Android/sdk/tools:/Users/liuyan/Library/Android/sdk/platform-tools"

2. export EMSDK="/Users/liuyan/Work/emsdk"

3. export EM_CONFIG="/Users/liuyan/.emscripten"

4. export EMSCRIPTEN="/Users/liuyan/Work/emsdk/emscripten/incoming"

5. export BINARYEN_ROOT="/Users/liuyan/Work/emsdk/binaryen/master_64bit_binaryen"

执行： source ~/.bash_profile

4.安装 WABT（将.wast文件转成 .wasm文件）

1. git clone https://github.com/WebAssembly/wabt.git

2. cd wabt

3. make install gcc-release

5.浏览器设置

1. Chrome: 打开 chrome://flags/#enable-webassembly，选择 enable。

2. Firefox: 打开 about:config 将 javascript.options.wasm 设置为 true。

如果浏览器太旧，请更新浏览器，或者安装激进版浏览器来体验新技术。

6.一个本地web服务器.

Emscripten，它基于 LLVM ，可以将 C/C++ 编译成 asm.js，使用 WASM 标志也可以直接生成 WebAssembly 二进制文件（后缀是 .wasm）

1.         Emscripten

2. source.c   ----->  target.js

3.     Emscripten (with flag)

4. source.c   ----->  target.wasm

注：emcc 在 1.37 以上版本才支持直接生成 wasm 文件

Binaryen 是一套更为全面的工具链，是用C++编写成用于WebAssembly的编译器和工具链基础结构库。WebAssembly是二进制格式（Binary Format）并且和Emscripten集成，因此该工具以Binary和Emscript-en的末尾合并命名为Binaryen。它旨在使编译WebAssembly容易、快速、有效。

• wasm-as：将WebAssembly由文本格式编译成二进制格式；

• wasm-dis：将二进制格式的WebAssembly反编译成文本格式；

• asm2wasm：将asm.js编译到WebAssembly文本格式，使用Emscripten的asm优化器；

• s2wasm：在LLVM中开发，由新WebAssembly后端产生的.s格式的编译器；

• wasm.js：包含编译为JavaScript的Binaryen组件，包括解释器、asm2wasm、S表达式解析器等。

WABT工具包支持将二进制WebAssembly格式转换为可读的文本格式。其中wasm2wast命令行工具可以将WebAssembly二进制文件转换为可读的S表达式文本文件。而wast2wasm命令行工具则执行完全相反的过程。

• wat2wasm: webAssembly文本格式转换为webAssembly二进制格式（.wast 到 .wasm）

• wasm2wat: 将WebAssembly二进制文件转换为可读的S表达式文本文件(.wat)

• wasm-objdump: print information about a wasm binary. Similiar to objdump.

• wasm-interp: 基于堆栈式解释器解码和运行webAssembly二进制文件

• wat-desugar: parse .wat text form as supported by the spec interpreter

• wasm-link: simple linker for merging multiple wasm files.

• wasm2c: 将webAssembly二进制文件转换为C的源文件

webAssembly的方法

webAssembly.validate

webAssembly.validate() 方法验证给定的二进制代码的 typed array 是否是合法的wasm module.返回布尔值。

1. WebAssembly.validate(bufferSource);

使用

1. javascript

2. fetch('xxx.wasm').then(response =>

3.  response.arrayBuffer()

4. ).then(function(bytes) {

5.  var valid = WebAssembly.validate(bytes); //true or false

6. });

webAssembly.Module

WebAssembly.Module() 构造函数可以用来同步编译给定的 WebAssembly 二进制代码。不过，获取 Module 对象的主要方法是通过异步编译函数，如 WebAssembly.compile()，或者是通过 IndexedDB 读取 Module 对象.

1. var myModule = new WebAssembly.Module(bufferSource);

参数： 一个包含你想编译的wasm模块二进制代码的 typed array(类型数组) or ArrayBuffer(数组缓冲区).

重要提示：由于大型模块的编译可能很消耗资源，开发人员只有在绝对需要同步编译时，才使用 Module() 构造函数；其他情况下，应该使用异步 WebAssembly.compile() 方法。

webAssembly.compile

WebAssembly.compile() 方法编译WebAssembly二进制代码到一个WebAssembly.Module 对象。

1. Promise<WebAssembly.Module> WebAssembly.compile(bufferSource);

webAssembly.Instance

WebAssembly.Instance实例对象是有状态，可执行的 WebAssembly.Module实例。实例中包含了所有可以被 JavaScript调用的WebAssembly 代码导出的函数。

重要提示：由于大型模块的实例化可能很消耗资源，开发人员只有在绝对需要同步编译时，才使用 Instance() 构造函数；其他情况下，应该使用异步 WebAssembly.instantiate()方法。

1. var myInstance = new WebAssembly.Instance(module, importObject);

• module: 需要被实例化的webAssembly module

• importObject: 需要导入的变量

webAssembly.instantiate

1. Promise<WebAssembly.Instance> WebAssembly.instantiate(module, importObject);

webAssembly.Memory

当 WebAssembly 模块被实例化时，它需要一个 memory 对象。你可以创建一个新的WebAssembly.Memory并传递该对象。如果没有创建 memory 对象，在模块实例化的时候将会自动创建，并且传递给实例。

1. var myMemory = new WebAssembly.Memory(memoryDescriptor);

memoryDescriptor (object)

• initial

• maximum 可选

webAssembly.Table

1. var myTable = new WebAssembly.Table(tableDescriptor);

tableDescriptor (object)

• element，当前只支持一个值。 'anyfunc'

• initial, WebAssembly Table的初始元素数

• maximum(可选)， 允许的最大元素数

webAssembly使用

WebAssembly 与其他的汇编语言不一样，它不依赖于具体的物理机器。可以抽象地理解成它是概念机器的机器语言，而不是实际的物理机器的机器语言。浏览器把 WebAssembly 下载下来后，可以迅速地将其转换成机器汇编代码。

快速体验webAssembly

1. WebAssembly.compile(new Uint8Array(`

2.  00 61 73 6d   01 00 00 00   01 0c 02 60   02 7f 7f 01

3.  7f 60 01 7f   01 7f 03 03   02 00 01 07   10 02 03 61

4.  64 64 00 00   06 73 71 75   61 72 65 00   01 0a 13 02

5.  08 00 20 00   20 01 6a 0f   0b 08 00 20   00 20 00 6c

6.  0f 0b`.trim().split(/[\s\r\n]+/g).map(str => parseInt(str, 16))

7. )).then(module => {

8.  const instance = new WebAssembly.Instance(module)

9. //使用 WebAssembly.Instance 将模块对象转成 WebAssembly 实例

10.  const { add, square } = instance.exports

11. //通过 instance.exports 可以拿到 wasm 代码输出的接口

12.  console.log('2 + 4 =', add(2, 4))

13.  console.log('3^2 =', square(3))

14.  console.log('(2 + 5)^2 =', square(add(2 + 5)))

15. })

使用C/C++

hello.c

1. #include <stdio.h>

2. int main(int argc, char ** argv) {

3.  printf("Hello World\n");

4.  return 0;

5. }

编译：

1. emcc hello.c -s WASM=1 -o hello.html

• -s WASM=1 — 指定我们想要的wasm输出形式。如果我们不指定这个选项，Emscripten默认将只会生成asm.js。

• -o hello.html — 指定这个选项将会生成HTML页面来运行我们的代码，并且会生成wasm模块以及编译和实例化wasim模块所需要的“胶水”js代码，这样我们就可以直接在web环境中使用了。
  

编译后

1. 二进制的wasm模块代码 (hello.wasm)

2. 一个包含了用来在原生C函数和JavaScript/wasm之间转换的胶水代码的JavaScript文件 (hello.js)
   

3. 一个用来加载，编译，实例化你的wasm代码并且将它输出在浏览器显示上的一个HTML文件 (hello.html)
   

调用C++中的方法

hello.c

1. #include <emscripten/emscripten.h>

2. int main(int argc, char ** argv) {

3.  printf("Hello World\n");

4. }

5. #ifdef __cplusplus

6. extern "C" {

7. #endif

8. int EMSCRIPTEN_KEEPALIVE myFunction(int argc, char ** argv) {

9.  printf("MyFunction Called\n");

10. }

11. #ifdef __cplusplus

12. }

13. #endif

如果想调用hello2.c中的myFunction方法，则需要将ccall方法从Moudule导出。使用下面的编译命令：

1. emcc -o hello2.html hello2.c -O3 -s

2. 'EXTRA_EXPORTED_RUNTIME_METHODS=["ccall"]'  

3. -s WASM=1 --shell-file html_template/shell_minimal.html

• htmltemplate/shellminimal.html 指定为HTML模板。

• -s 'EXTRAEXPORTEDRUNTIME_METHODS=["ccall"]' 从Module中导出 ccall

将 ccall 方法导出之后，就可以使用 Module.ccall来调用C++中的函数了。

1. var result = Module.ccall(

2.    'funcName',     // 函数名

3.    'number',        // 返回类型

4.    ['number'],      // 参数类型

5.    [42]);            // 参数

更直观的例子

上面的例子中，编译后即可直接运行。但是生成的代码体积较大，不容易看懂具体做了什么。因此下面提供一个更直观的例子。

math.c

1. int add (int x, int y) {

2.  return x + y;

3. }

4. int square (int x) {

5.  return x * x;

6. }

编译：

emcc math.c-Os-s WASM=1-s SIDE_MODULE=1-o math.wasm

-s SIDE_MODULE=1 直接由C生成wasm文件

目前只有一种方式能调用 wasm 里的提供接口，那就是：用 javascript ！

编写加载函数(loader)

1. function loadWebAssembly (path) {

2.  return fetch(path)                   // 加载文件        

3.    .then(res => res.arrayBuffer())    // 转成 ArrayBuffer

4.    .then(WebAssembly.instantiate)     // 编译 + 实例化

5.    .then(mod => mod.instance)         // 提取生成都模块

6. }

完成了上边的操作，就可以直接使用 loadWebAssembly 这个方法加载 wasm 文件了，它相当于是一个 wasm-loader ；返回值是一个 Promise.

1. loadWebAssembly('path/to/math.wasm')

2.  .then(instance => {

3.    const { add, square } = instance.exports

4.    // ...

5. })

更完善的loader

1. function loadWebAssembly(filename, imports = {}) {

2. return fetch(filename)

3.    .then(response => response.arrayBuffer())

4.    .then(buffer => WebAssembly.compile(buffer))

5.    //WebAssembly.compile 可以用来编译 wasm 的二进制源码，

6.    //它接受 BufferSource 格式的参数，返回一个 Promise。

7.    .then(module => {            

8.           imports.env = imports.env || {};

9.        // 开辟内存空间 && 创建变量映射表

10.        Object.assign(imports.env, {

11.            memoryBase: 0,

12.            tableBase: 0,

13.            memory: new WebAssembly.Memory({ initial: 256, maximum: 256 }),

14.            table: new WebAssembly.Table({ initial: 0, maximum: 0,

15.                    element: 'anyfunc' })

16.        })

17.        // 创建 WebAssembly 实例

18.        return new WebAssembly.instantiate(module, imports)

19.    })

20. }

ArrayBuffer 做了两件事情，一件是做 WebAssembly 的内存，另外一件是做 JavaScript 的对象。

1. 它使 JS 和 WebAssembly 之间传递内容更方便。

2. 使内存管理更安全。

这个 loadWebAssembly 函数还接受第二个参数，表示要传递给 wasm 的变量，在初始化 WebAssembly 实例的时候，可以把一些接口传递给 wasm 代码。

asm.js

asm.js 是 javascript 的子集，是一种语法。用了很多底层语法来标注数据类型，目的是提高 javascript 的运行效率，本身就是作为 C/C++ 编译的目标设计的（不是给人写的）。 WebAssembly 借鉴了这个思路，做的更彻底一些，直接跳过 javascript ，设计了一套新的平台指令。

目前只有 asm.js 才能转成 wasm，普通 javascript 是不行的。虽然 Emscripten 能生成 asm.js 和 wasm ，但是却不能把 asm.js 转成 wasm 。想要把 asm.js 编译成 WebAssembly，就要用到他们官方提供的 Binaryen 和 WABT (WebAssembly Binary Toolkit) 工具。

1.            Binaryen                WABT

2. math.js   -------->   math.wast   ------->   math.wasm

Rust编译为webAssembly

1.安装Rustup

Rustup是一个命令行应用，能够下载并在不同版本的Rust工具链中进行切换

1. brew install cargo

2. curl https://sh.rustup.rs -sSf | sh

3. source $HOME/.cargo/env

4. source  ~/.bash_profile

5. rustup target add wasm32-unknown-unknown --toolchain nightly

6. cargo install --git https://github.com/alexcrichton/wasm-gc

7. //减小wasm的size

cargo可以将整个工程编译为wasm，首先使用cargo创建工程：

cargonewproject

下一步，把下面的代码加到 Cargo.toml 中

1. [lib]

2. path = "src/lib.rs"

3. crate-type = ["cdylib"]

2.demo：https://github.com/jakedeichert/wasm-astar

编译:

cargo+nightly build--target wasm32-unknown-unknown--release

编译出来的wasm大小为82Kb,使用wasm-gc压缩 small-wasm_astar.wasm 的大小为 67Kb

wasm-gc wasm_astar.wasm small-wasm_astar.wasm

为什么WebAssembly更快

JS 引擎在图中各个部分所花的时间取决于页面所用的 JavaScript 代码。图表中的比例并不代表真实情况下的确切比例情况。

• Parse: 把源代码变成解释器可以运行的代码所花的时间；

• Compiling + optimizing: 基线编译器和优化编译器花的时间;

• Re-optimize: 当 JIT 发现优化假设错误，丢弃优化代码所花的时间。

• Execut：执行代码的时间

• Garbage collection： 垃圾回收，清理内存的时间

文件获取：

WebAssembly比JS的压缩了更高，所以文件获取更快。

解析：

到达浏览器时，JS源代码被解析成了抽象语法树，浏览器采用懒加载的方式进行，只解析真正需要的部分，，而对于浏览器暂时不需要的函数只保留它的桩，解析过后 AST （抽象语法树）就变成了中间代码（叫做字节码），提供给 JS 引擎编译。

而WebAssembly不需要这种转换，因为它本身就是中间代码，它要做的只是解码并且检查确认代码没有错误即可。

编译和优化

JavaScript 是在代码的执行阶段编译的。因为它是弱类型语言，当变量类型发生变化时，同样的代码会被编译成不同版本。

不同浏览器处理 WebAssembly 的编译过程也不同。不论哪种方式，WebAssembly 都更贴近机器码，所以它更快.

1. 在编译优化代码之前，它不需要提前运行代码以知道变量都是什么类型。

2. 编译器不需要对同样的代码做不同版本的编译。

3. 很多优化在 LLVM 阶段就已经做完了，所以在编译和优化的时候没有太多的优化需要做。

重优化

JS的代码由于类型的不确定性，有些情况下，JIT会返回进行 “抛弃优化代码<->重优化”过程。

而WebAssembly中，类型都是确定了的，因为没有重优化阶段。

执行

WebAssembly 就是为了编译器而设计的，开发人员不直接对其进行编程，这样就使得 WebAssembly 专注于提供更加理想的指令给机器。

执行效率方面，不同的代码功能有不同的效果，一般来讲执行效率会提高 10% - 800%。

垃圾回收

WebAssembly不支持垃圾回收，内存操作需要手动控制，因此WebAssembly没有垃圾回收。

应用

WebAssembly 更适合用于写模块，承接各种复杂的计算，如图像处理、3D运算、语音识别、视音频编码解码这种工作，主体程序还是要用 javascript 来写的。

未来功能

• 直接操作DOM

• 支持多数据（SIMD）：SIMD的使用可以获取大的数据结构，例如不同数目的向量，并且同时将相同的指令应用于不同的部分。这样，它可以大大加快各种复杂计算的游戏或VR的运行速度。

• ES6模块集成：浏览器目前正在添加对使用script标签加载JavaScript模块的支持。 添加此功能后，即使URL指向WebAssembly模块，

觉得本文对你有帮助？请分享给更多人

关注「前端大全」，提升前端技能