Implement RFC 11: Redesigning Wasmtime's APIs

.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
@@ -295,7 +297,7 @@ jobs:
  # Build and test all features except for lightbeam
  - run: |
  cargo test \
- --features test-programs/test_programs \
+ --features "test-programs/test_programs wiggle/wasmtime_async wasmtime/wat" \
  --workspace \
  --exclude '*lightbeam*' \
  --exclude 'wasmtime-wasi-*' \

Cargo.toml

@@ -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",

benches/instantiation.rs

@@ -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");
  })
  })
  });

build.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")

ci/build-tarballs.sh

@@ -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

cranelift/interpreter/src/interpreter.rs

@@ -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):