wasi-threads: add an initial implementation

This change is a first step toward implementing `wasi-threads` in
Wasmtime. We may find that it has some missing pieces, but the core
functionality is there: when `wasi::thread_spawn` is called by a running
WebAssembly module, a function named `wasi_thread_start` is found in the
module's exports and called in a new instance. The shared memory of the
original instance is reused in the new instance.

This new WASI proposal is in its early stages and details are still
being hashed out in the [spec] and [wasi-libc] repositories. Due to its
experimental state, the `wasi-threads` functionality is hidden behind
both a compile-time and runtime flag: one must build with `--features
wasi-threads` but also run the Wasmtime CLI with `--wasm-features
threads` and `--wasi-modules experimental-wasi-threads`. One can
experiment with `wasi-threads` by running:

```console
$ cargo run --features wasi-threads -- \
    --wasm-features threads --wasi-modules experimental-wasi-threads \
    <a threads-enabled module>
```

Threads-enabled Wasm modules are not yet easy to build. Hopefully this
is resolved soon, but in the meantime see the use of
`THREAD_MODEL=posix` in the [wasi-libc] repository for some clues on
what is necessary. Wiggle complicates things by requiring the Wasm
memory to be exported with a certain name and `wasi-threads` also
expects that memory to be imported; this build-time obstacle can be
overcome with the `--import-memory --export-memory` flags only available
in the latest Clang tree. Due to all of this, the included tests are
written directly in WAT--run these with:

```console
$ cargo test --features wasi-threads -p wasmtime-cli -- cli_tests
```

[spec]: https://github.com/WebAssembly/wasi-threads
[wasi-libc]: https://github.com/WebAssembly/wasi-libc

This change does not protect the WASI implementations themselves from
concurrent access. This is already complete in previous commits or left
for future commits in certain cases (e.g., wasi-nn).

Author: abrown

Cargo.lock

@@ -31,6 +31,7 @@ wasmtime-wast = { workspace = true }
 wasmtime-wasi = { workspace = true }
 wasmtime-wasi-crypto = { workspace = true, optional = true }
 wasmtime-wasi-nn = { workspace = true, optional = true }
+wasmtime-wasi-threads = { workspace = true, optional = true }
 clap = { workspace = true, features = ["color", "suggestions", "derive"] }
 anyhow = { workspace = true }
 target-lexicon = { workspace = true }
@@ -87,6 +88,7 @@ members = [
   "crates/bench-api",
   "crates/c-api",
   "crates/cli-flags",
+  "crates/wasi-threads",
   "crates/environ/fuzz",
   "crates/jit-icache-coherence",
   "crates/winch",
@@ -123,6 +125,7 @@ wasmtime-wast = { path = "crates/wast", version = "=6.0.0" }
 wasmtime-wasi = { path = "crates/wasi", version = "6.0.0" }
 wasmtime-wasi-crypto = { path = "crates/wasi-crypto", version = "6.0.0" }
 wasmtime-wasi-nn = { path = "crates/wasi-nn", version = "6.0.0" }
+wasmtime-wasi-threads = { path = "crates/wasi-threads", version = "6.0.0" }
 wasmtime-component-util = { path = "crates/component-util", version = "=6.0.0" }
 wasmtime-component-macro = { path = "crates/component-macro", version = "=6.0.0" }
 wasmtime-asm-macros = { path = "crates/asm-macros", version = "=6.0.0" }
@@ -191,13 +194,13 @@ default = [
   "wasmtime/wat",
   "wasmtime/parallel-compilation",
   "vtune",
-  "wasi-nn",
   "pooling-allocator",
 ]
 jitdump = ["wasmtime/jitdump"]
 vtune = ["wasmtime/vtune"]
 wasi-crypto = ["dep:wasmtime-wasi-crypto"]
 wasi-nn = ["dep:wasmtime-wasi-nn"]
+wasi-threads = ["dep:wasmtime-wasi-threads"]
 pooling-allocator = ["wasmtime/pooling-allocator", "wasmtime-cli-flags/pooling-allocator"]
 all-arch = ["wasmtime/all-arch"]
 posix-signals-on-macos = ["wasmtime/posix-signals-on-macos"]

Cargo.toml

@@ -50,13 +50,17 @@ pub const SUPPORTED_WASI_MODULES: &[(&str, &str)] = &[
         "wasi-common",
         "enables support for the WASI common APIs, see https://github.com/WebAssembly/WASI",
     ),
+    (
+        "experimental-wasi-crypto",
+        "enables support for the WASI cryptography APIs (experimental), see https://github.com/WebAssembly/wasi-crypto",
+    ),
     (
         "experimental-wasi-nn",
         "enables support for the WASI neural network API (experimental), see https://github.com/WebAssembly/wasi-nn",
     ),
     (
-        "experimental-wasi-crypto",
-        "enables support for the WASI cryptography APIs (experimental), see https://github.com/WebAssembly/wasi-crypto",
+        "experimental-wasi-threads",
+        "enables support for the WASI threading API (experimental), see https://github.com/WebAssembly/wasi-threads",
     ),
 ];
 
@@ -466,8 +470,9 @@ fn parse_wasi_modules(modules: &str) -> Result<WasiModules> {
             let mut set = |module: &str, enable: bool| match module {
                 "" => Ok(()),
                 "wasi-common" => Ok(wasi_modules.wasi_common = enable),
-                "experimental-wasi-nn" => Ok(wasi_modules.wasi_nn = enable),
                 "experimental-wasi-crypto" => Ok(wasi_modules.wasi_crypto = enable),
+                "experimental-wasi-nn" => Ok(wasi_modules.wasi_nn = enable),
+                "experimental-wasi-threads" => Ok(wasi_modules.wasi_threads = enable),
                 "default" => bail!("'default' cannot be specified with other WASI modules"),
                 _ => bail!("unsupported WASI module '{}'", module),
             };
@@ -494,19 +499,23 @@ pub struct WasiModules {
     /// parts once the implementation allows for it (e.g. wasi-fs, wasi-clocks, etc.).
     pub wasi_common: bool,
 
-    /// Enable the experimental wasi-nn implementation
+    /// Enable the experimental wasi-crypto implementation.
+    pub wasi_crypto: bool,
+
+    /// Enable the experimental wasi-nn implementation.
     pub wasi_nn: bool,
 
-    /// Enable the experimental wasi-crypto implementation
-    pub wasi_crypto: bool,
+    /// Enable the experimental wasi-threads implementation.
+    pub wasi_threads: bool,
 }
 
 impl Default for WasiModules {
     fn default() -> Self {
         Self {
             wasi_common: true,
-            wasi_nn: false,
             wasi_crypto: false,
+            wasi_nn: false,
+            wasi_threads: false,
         }
     }
 }
@@ -518,6 +527,7 @@ impl WasiModules {
             wasi_common: false,
             wasi_nn: false,
             wasi_crypto: false,
+            wasi_threads: false,
         }
     }
 }
@@ -663,8 +673,9 @@ mod test {
             options.wasi_modules.unwrap(),
             WasiModules {
                 wasi_common: true,
+                wasi_crypto: false,
                 wasi_nn: false,
-                wasi_crypto: false
+                wasi_threads: false
             }
         );
     }
@@ -676,8 +687,9 @@ mod test {
             options.wasi_modules.unwrap(),
             WasiModules {
                 wasi_common: true,
+                wasi_crypto: false,
                 wasi_nn: false,
-                wasi_crypto: false
+                wasi_threads: false
             }
         );
     }
@@ -693,8 +705,9 @@ mod test {
             options.wasi_modules.unwrap(),
             WasiModules {
                 wasi_common: false,
+                wasi_crypto: false,
                 wasi_nn: true,
-                wasi_crypto: false
+                wasi_threads: false
             }
         );
     }
@@ -707,8 +720,9 @@ mod test {
             options.wasi_modules.unwrap(),
             WasiModules {
                 wasi_common: false,
+                wasi_crypto: false,
                 wasi_nn: false,
-                wasi_crypto: false
+                wasi_threads: false
             }
         );
     }

crates/cli-flags/src/lib.rs

@@ -0,0 +1,22 @@
+[package]
+name = "wasmtime-wasi-threads"
+version.workspace = true
+authors.workspace = true
+description = "Wasmtime implementation of the wasi-threads API"
+documentation = "https://docs.rs/wasmtime-wasi-nn"
+license = "Apache-2.0 WITH LLVM-exception"
+categories = ["wasm", "parallelism", "threads"]
+keywords = ["webassembly", "wasm", "neural-network"]
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+log = { workspace = true }
+rand = "0.8"
+wasi-common = { workspace = true }
+wasmtime = { workspace = true }
+
+[badges]
+maintenance = { status = "experimental" }