10 stable releases

1.3.4 Oct 12, 2021
1.3.3 Jul 15, 2021
1.3.1 Jun 28, 2021
1.3.0 Mar 26, 2021
1.0.2 Jan 14, 2021

#406 in WebAssembly

Download history 6/week @ 2021-07-03 40/week @ 2021-07-10 47/week @ 2021-07-17 103/week @ 2021-07-24 39/week @ 2021-07-31 95/week @ 2021-08-07 53/week @ 2021-08-14 27/week @ 2021-08-21 1/week @ 2021-08-28 9/week @ 2021-09-04 33/week @ 2021-09-11 4/week @ 2021-09-18 4/week @ 2021-09-25 13/week @ 2021-10-02 35/week @ 2021-10-09 37/week @ 2021-10-16

153 downloads per month

Apache-2.0 WITH LLVM-exception

10MB
3K SLoC

Wizer

The WebAssembly Pre-Initializer!

A Bytecode Alliance project

build status zulip chat Documentation Status

API Docs | Contributing | Chat

About

Don't wait for your Wasm module to initialize itself, pre-initialize it! Wizer instantiates your WebAssembly module, executes its initialization function, and then snapshots the initialized state out into a new WebAssembly module. Now you can use this new, pre-initialized WebAssembly module to hit the ground running, without making your users wait for that first-time set up code to complete.

The improvements to start up latency you can expect will depend on how much initialization work your WebAssembly module needs to do before it's ready. Some initial benchmarking shows between 1.35 to 6.00 times faster instantiation and initialization with Wizer, depending on the workload:

Program Without Wizer With Wizer Speedup
regex 248.85 us 183.99 us 1.35x faster
UAP 98.297 ms 16.385 ms 6.00x faster

Not every program will see an improvement to instantiation and start up latency. For example, Wizer will often increase the size of the Wasm module's Data section, which could negatively impact network transfer times on the Web. However, the best way to find out if your Wasm module will see an improvement is to try it out! Adding an initialization function isn't too hard.

Finally, you can likely see further improvements by running wasm-opt on the pre-initialized module. Beyond the usual benefits that wasm-opt brings, the module likely has a bunch of initialization-only code that is no longer needed now that the module is already initialized, and which wasm-opt can remove.

Install

Install via cargo:

$ cargo install wizer --all-features

Example Usage

First, make sure your Wasm module exports an initialization function named wizer.initialize. For example, in Rust you can export it like this:

#[export_name = "wizer.initialize"]
pub extern "C" fn init() {
    // Your initialization code goes here...
}

For a complete C++ example, see this.

Then, if your Wasm module is named input.wasm, run the wizer CLI:

$ wizer input.wasm -o initialized.wasm

Now you have a pre-initialized version of your Wasm module at initialized.wasm!

More details, flags, and options can be found via --help:

$ wizer --help

Caveats

  • The initialization function may not call any imported functions. Doing so will trigger a trap and wizer will exit. You can, however, allow WASI calls via the --allow-wasi flag.

  • The Wasm module may not import globals, tables, or memories.

  • Reference types are not supported yet. It isn't 100% clear yet what the best approach to snapshotting externref tables is.

Using Wizer as a Library

Add a dependency in your Cargo.toml:

# Cargo.toml

[dependencies]
wizer = "1"

And then use the wizer::Wizer builder to configure and run Wizer:

use wizer::Wizer;

let input_wasm = get_input_wasm_bytes();

let initialized_wasm_bytes = Wizer::new()
    .allow_wasi(true)
    .run(&input_wasm)?;

How Does it Work?

First we instantiate the input Wasm module with Wasmtime and run the initialization function. Then we record the Wasm instance's state:

  • What are the values of its globals?
  • What regions of memory are non-zero?

Then we rewrite the Wasm binary by intializing its globals directly to their recorded state, and removing the module's old data segments and replacing them with data segments for each of the non-zero regions of memory we recorded.

Want some more details? Check out the talk "Hit the Ground Running: Wasm Snapshots for Fast Start Up" from the 2021 WebAssembly Summit.

Dependencies

~15MB
~313K SLoC