Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread.

Author: alexcrichton

.github/workflows/main.yml

@@ -61,7 +61,9 @@ jobs:
         toolchain: nightly-2021-04-11
 
     # Build C API documentation
-    - run: sudo apt-get update && sudo apt-get install -y doxygen git
+    - run: sudo apt-get update -y && sudo apt-get install -y libclang1-9 libclang-cpp9
+    - run: curl -L https://doxygen.nl/files/doxygen-1.9.1.linux.bin.tar.gz | tar xzf -
+    - run: echo "`pwd`/doxygen-1.9.1/bin" >> $GITHUB_PATH
     - run: cd crates/c-api && doxygen doxygen.conf
 
     # install mdbook, build the docs, and test the docs
@@ -73,7 +75,7 @@ jobs:
         echo "${{ runner.tool_cache }}/mdbook/bin" >> $GITHUB_PATH
         cargo install --root ${{ runner.tool_cache }}/mdbook --version ${{ env.CARGO_MDBOOK_VERSION }} mdbook
     - run: (cd docs && mdbook build)
-    - run: cargo build -p wasmtime
+    - run: cargo build -p wasmtime-wasi --features wasmtime/wat
     - run: (cd docs && mdbook test -L ../target/debug/deps)
 
     # Build Rust API documentation

Cargo.lock

@@ -77,7 +77,6 @@ members = [
   "crates/wiggle",
   "crates/wiggle/generate",
   "crates/wiggle/macro",
-  "crates/wiggle/wasmtime",
   "crates/wasi-common",
   "crates/wasi-common/cap-std-sync",
   "crates/wasi-common/tokio",

Cargo.toml

@@ -3,21 +3,14 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use rayon::{prelude::*, ThreadPoolBuilder};
 use std::{path::PathBuf, process::Command};
 use wasmtime::*;
-use wasmtime_wasi::{sync::WasiCtxBuilder, Wasi};
+use wasmtime_wasi::{sync::WasiCtxBuilder, WasiCtx};
 
-fn instantiate(module: &Module) -> Result<Instance> {
-    let store = Store::new(&module.engine());
+fn instantiate(linker: &Linker<WasiCtx>, module: &Module) -> Result<()> {
+    let wasi = WasiCtxBuilder::new().build();
+    let mut store = Store::new(module.engine(), wasi);
+    let _instance = linker.instantiate(&mut store, module)?;
 
-    // As we don't actually invoke Wasm code in this benchmark, we still add
-    // the WASI context to the store as it is considered part of getting a
-    // module that depends on WASI "ready to run".
-    Wasi::set_context(&store, WasiCtxBuilder::new().build())
-        .map_err(|_| anyhow::anyhow!("wasi set_context failed"))?;
-
-    let linker = Linker::new(&store);
-    let instance = linker.instantiate(module)?;
-
-    Ok(instance)
+    Ok(())
 }
 
 fn benchmark_name<'a>(strategy: &InstanceAllocationStrategy) -> &'static str {
@@ -46,15 +39,16 @@ fn bench_sequential(c: &mut Criterion, modules: &[&str]) {
             path.push(file_name);
 
             let mut config = Config::default();
-            Wasi::add_to_config(&mut config);
             config.allocation_strategy(strategy.clone());
 
             let engine = Engine::new(&config).expect("failed to create engine");
             let module = Module::from_file(&engine, &path)
                 .expect(&format!("failed to load benchmark `{}`", path.display()));
+            let mut linker = Linker::new(&engine);
+            wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
 
             group.bench_function(BenchmarkId::new(benchmark_name(strategy), file_name), |b| {
-                b.iter(|| instantiate(&module).expect("failed to instantiate module"));
+                b.iter(|| instantiate(&linker, &module).expect("failed to instantiate module"));
             });
         }
     }
@@ -74,12 +68,13 @@ fn bench_parallel(c: &mut Criterion) {
         InstanceAllocationStrategy::pooling(),
     ] {
         let mut config = Config::default();
-        Wasi::add_to_config(&mut config);
         config.allocation_strategy(strategy.clone());
 
         let engine = Engine::new(&config).expect("failed to create engine");
         let module = Module::from_file(&engine, "benches/instantiation/wasi.wasm")
             .expect("failed to load WASI example module");
+        let mut linker = Linker::new(&engine);
+        wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
 
         for threads in 1..=num_cpus::get_physical() {
             let pool = ThreadPoolBuilder::new()
@@ -101,7 +96,8 @@ fn bench_parallel(c: &mut Criterion) {
                     b.iter(|| {
                         pool.install(|| {
                             (0..PARALLEL_INSTANCES).into_par_iter().for_each(|_| {
-                                instantiate(&module).expect("failed to instantiate module");
+                                instantiate(&linker, &module)
+                                    .expect("failed to instantiate module");
                             })
                         })
                     });

benches/instantiation.rs

@@ -218,10 +218,17 @@ fn ignore(testsuite: &str, testname: &str, strategy: &str) -> bool {
             _ => (),
         },
         "Cranelift" => match (testsuite, testname) {
+            // Skip all reference types tests on the old backend. The modern
+            // implementation of reference types uses atomic instructions
+            // for reference counts on `externref`, but the old backend does not
+            // implement atomic instructions.
+            ("reference_types", _) if cfg!(feature = "old-x86-backend") => return true,
+            // Skip all SIMD tests on old backend, there are instructions not
+            // implemented there and support is generally not maintained.
+            ("simd", _) if cfg!(feature = "old-x86-backend") => return true,
             // No simd support yet for s390x.
             ("simd", _) if platform_is_s390x() => return true,
 
-            ("simd", _) if cfg!(feature = "old-x86-backend") => return true, // skip all SIMD tests on old backend.
             // These are new instructions that are not really implemented in any backend.
             ("simd", "simd_i8x16_arith2")
             | ("simd", "simd_conversions")

build.rs

@@ -34,8 +34,8 @@ mkdir tmp/$api_pkgname/include
 mkdir tmp/$bin_pkgname
 cp LICENSE README.md tmp/$api_pkgname
 cp LICENSE README.md tmp/$bin_pkgname
+cp -r crates/c-api/include tmp/$api_pkgname
 cp crates/c-api/wasm-c-api/include/wasm.h tmp/$api_pkgname/include
-cp crates/c-api/include/{wasmtime,wasi}.h tmp/$api_pkgname/include
 
 fmt=tar
 if [ "$platform" = "x86_64-windows" ]; then

ci/build-tarballs.sh

@@ -42,7 +42,8 @@ impl<'a> Interpreter<'a> {
         self.call_by_index(index, arguments)
     }
 
-    /// Call a function by its index in the [FunctionStore]; this is a proxy for [Interpreter::call].
+    /// Call a function by its index in the [FunctionStore]; this is a proxy for
+    /// `Interpreter::call`.
     pub fn call_by_index(
         &mut self,
         index: FuncIndex,
@@ -287,7 +288,7 @@ mod tests {
             v1 = iadd_imm v0, -1
             return v1
         }
-        
+
         function %parent(i32) -> i32 {
             fn42 = %child(i32) -> i32
         block0(v0: i32):