Enable async support in wast tests (bytecodealliance#10366)

alexcrichton · web-flow · commit 83575995d496 · 2025-03-11T15:20:53.000Z
* Enable async support in wast tests

This commit updates the `wasmtime-wast` crate to conditionally use the
`Config::async_support` mode of Wasmtime, notably executing
`instantiate_async` and `call_async`. At this time no actual concurrency
is supported and everything is immediately await'd on via `block_on` and
a local single-thread tokio runtime.

The motivation for this commit is that in the upcoming implementation of
WASIp3 async will effectively be the only way to invoke components.
Furthermore to test these components we're wanting to use async APIs as
the root of invocations for writing `*.wast` tests for testing
component-model async features.

In enabling this support this commit additionally updates the
`wast_tests` fuzzer to execute all tests both with and without async.
Effectively the async configuration is now a fuzz option, meaning that
all tests are being executed with async now as well to ensure that they
work (yay!).

The `--test wast` testing mode and `wasmtime wast` CLI command are both
updated to unconditionally use async. There should be no loss in test
coverage due to the fuzzer update, and right now knobs aren't provided
to conditionally use sync in these two modes, again because it's
currently expected that this won't be able to run component model async
tests, so the defaults are changing.

* Fix building wasmtime-wast in isolation
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/fuzzing/src/generators/config.rs b/crates/fuzzing/src/generators/config.rs
@@ -413,7 +413,7 @@ impl Config {
         }
 
         if self.wasmtime.async_config != AsyncConfig::Disabled {
-            log::debug!("async config in used {:?}", self.wasmtime.async_config);
+            log::debug!("async config in use {:?}", self.wasmtime.async_config);
             self.wasmtime.async_config.configure(&mut cfg);
         }
 
@@ -432,20 +432,25 @@ impl Config {
     /// Configures a store based on this configuration.
     pub fn configure_store(&self, store: &mut Store<StoreLimits>) {
         store.limiter(|s| s as &mut dyn wasmtime::ResourceLimiter);
+
+        // Configure the store to never abort by default, that is it'll have
+        // max fuel or otherwise trap on an epoch change but the epoch won't
+        // ever change.
+        //
+        // Afterwards though see what `AsyncConfig` is being used an further
+        // refine the store's configuration based on that.
+        if self.wasmtime.consume_fuel {
+            store.set_fuel(u64::MAX).unwrap();
+        }
+        if self.wasmtime.epoch_interruption {
+            store.epoch_deadline_trap();
+            store.set_epoch_deadline(1);
+        }
         match self.wasmtime.async_config {
-            AsyncConfig::Disabled => {
-                if self.wasmtime.consume_fuel {
-                    store.set_fuel(u64::MAX).unwrap();
-                }
-                if self.wasmtime.epoch_interruption {
-                    store.epoch_deadline_trap();
-                    store.set_epoch_deadline(1);
-                }
-            }
+            AsyncConfig::Disabled => {}
             AsyncConfig::YieldWithFuel(amt) => {
                 assert!(self.wasmtime.consume_fuel);
                 store.fuel_async_yield_interval(Some(amt)).unwrap();
-                store.set_fuel(amt).unwrap();
             }
             AsyncConfig::YieldWithEpochs { ticks, .. } => {
                 assert!(self.wasmtime.epoch_interruption);
diff --git a/crates/fuzzing/src/oracles.rs b/crates/fuzzing/src/oracles.rs
@@ -654,22 +654,29 @@ pub fn make_api_calls(api: generators::api::ApiCalls) {
 /// Executes the wast `test` with the `config` specified.
 ///
 /// Ensures that wast tests pass regardless of the `Config`.
-pub fn wast_test(mut fuzz_config: generators::Config, test: generators::WastTest) {
+pub fn wast_test(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<()> {
     crate::init_fuzzing();
+
+    let mut fuzz_config: generators::Config = u.arbitrary()?;
+    let test: generators::WastTest = u.arbitrary()?;
+    if u.arbitrary()? {
+        fuzz_config.enable_async(u)?;
+    }
+
     let test = &test.test;
 
     // Discard tests that allocate a lot of memory as we don't want to OOM the
     // fuzzer and we also limit memory growth which would cause the test to
     // fail.
     if test.config.hogs_memory.unwrap_or(false) {
-        return;
+        return Err(arbitrary::Error::IncorrectFormat);
     }
 
     // Transform `fuzz_config` to be valid for `test` and make sure that this
     // test is supposed to pass.
     let wast_config = fuzz_config.make_wast_test_compliant(test);
     if test.should_fail(&wast_config) {
-        return;
+        return Err(arbitrary::Error::IncorrectFormat);
     }
 
     // Winch requires AVX and AVX2 for SIMD tests to pass so don't run the test
@@ -688,19 +695,24 @@ pub fn wast_test(mut fuzz_config: generators::Config, test: generators::WastTest
         log::warn!(
             "Skipping Wast test because Winch doesn't support SIMD tests with AVX or AVX2 disabled"
         );
-        return;
+        return Err(arbitrary::Error::IncorrectFormat);
     }
 
     // Fuel and epochs don't play well with threads right now, so exclude any
     // thread-spawning test if it looks like threads are spawned in that case.
     if fuzz_config.wasmtime.consume_fuel || fuzz_config.wasmtime.epoch_interruption {
         if test.contents.contains("(thread") {
-            return;
+            return Err(arbitrary::Error::IncorrectFormat);
         }
     }
 
     log::debug!("running {:?}", test.path);
-    let mut wast_context = WastContext::new(fuzz_config.to_store());
+    let async_ = if fuzz_config.wasmtime.async_config == generators::AsyncConfig::Disabled {
+        wasmtime_wast::Async::No
+    } else {
+        wasmtime_wast::Async::Yes
+    };
+    let mut wast_context = WastContext::new(fuzz_config.to_store(), async_);
     wast_context
         .register_spectest(&wasmtime_wast::SpectestConfig {
             use_shared_memory: true,
@@ -710,6 +722,7 @@ pub fn wast_test(mut fuzz_config: generators::Config, test: generators::WastTest
     wast_context
         .run_buffer(test.path.to_str().unwrap(), test.contents.as_bytes())
         .unwrap();
+    Ok(())
 }
 
 /// Execute a series of `table.get` and `table.set` operations.
@@ -1268,6 +1281,22 @@ mod tests {
         false
     }
 
+    /// Runs `f` with random data until it returns `Ok(())` `iters` times.
+    fn test_n_times<T: for<'a> Arbitrary<'a>>(
+        iters: u32,
+        mut f: impl FnMut(T, &mut Unstructured<'_>) -> arbitrary::Result<()>,
+    ) {
+        let mut to_test = 0..iters;
+        let ok = gen_until_pass(|a, b| {
+            if f(a, b).is_ok() {
+                Ok(to_test.next().is_none())
+            } else {
+                Ok(false)
+            }
+        });
+        assert!(ok);
+    }
+
     // Test that the `table_ops` fuzzer eventually runs the gc function in the host.
     // We've historically had issues where this fuzzer accidentally wasn't fuzzing
     // anything for a long time so this is an attempt to prevent that from happening
@@ -1353,4 +1382,9 @@ mod tests {
             panic!("never generated wasm module using {expected:?}");
         }
     }
+
+    #[test]
+    fn wast_smoke_test() {
+        test_n_times(50, |(), u| super::wast_test(u));
+    }
 }
diff --git a/crates/wast/Cargo.toml b/crates/wast/Cargo.toml
@@ -15,9 +15,10 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-wasmtime = { workspace = true, features = ['cranelift', 'wat', 'runtime', 'gc'] }
+wasmtime = { workspace = true, features = ['cranelift', 'wat', 'runtime', 'gc', 'async'] }
 wast = { workspace = true }
 log = { workspace = true }
+tokio = { workspace = true, features = ['rt'] }
 
 [features]
 component-model = ['wasmtime/component-model', 'wasmtime/component-model-async']
diff --git a/crates/wast/src/lib.rs b/crates/wast/src/lib.rs
@@ -9,7 +9,7 @@ mod spectest;
 mod wast;
 
 pub use crate::spectest::{link_spectest, SpectestConfig};
-pub use crate::wast::WastContext;
+pub use crate::wast::{Async, WastContext};
 
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/crates/wast/src/wast.rs b/crates/wast/src/wast.rs
@@ -23,6 +23,7 @@ pub struct WastContext<T> {
     #[cfg(feature = "component-model")]
     component_linker: component::Linker<T>,
     store: Store<T>,
+    async_runtime: Option<tokio::runtime::Runtime>,
 }
 
 enum Outcome<T = Results> {
@@ -72,12 +73,26 @@ enum Export {
     Component(component::Func),
 }
 
+/// Whether or not to use async APIs when calling wasm during wast testing.
+///
+/// Passed to [`WastContext::new`].
+#[derive(Copy, Clone, PartialEq)]
+#[expect(missing_docs, reason = "self-describing variants")]
+pub enum Async {
+    Yes,
+    No,
+}
+
 impl<T> WastContext<T>
 where
     T: Clone + Send + 'static,
 {
     /// Construct a new instance of `WastContext`.
-    pub fn new(store: Store<T>) -> Self {
+    ///
+    /// Note that the provided `Store<T>` must have `Config::async_support`
+    /// enabled as all functions will be run with `call_async`. This is done to
+    /// support the component model async features that tests might use.
+    pub fn new(store: Store<T>, async_: Async) -> Self {
         // Spec tests will redefine the same module/name sometimes, so we need
         // to allow shadowing in the linker which picks the most recent
         // definition as what to link when linking.
@@ -94,6 +109,15 @@ where
             },
             store,
             modules: Default::default(),
+            async_runtime: if async_ == Async::Yes {
+                Some(
+                    tokio::runtime::Builder::new_current_thread()
+                        .build()
+                        .unwrap(),
+                )
+            } else {
+                None
+            },
         }
     }
 
@@ -124,28 +148,34 @@ where
     }
 
     fn instantiate_module(&mut self, module: &Module) -> Result<Outcome<Instance>> {
-        Ok(
-            match self.core_linker.instantiate(&mut self.store, &module) {
-                Ok(i) => Outcome::Ok(i),
-                Err(e) => Outcome::Trap(e),
-            },
-        )
+        let instance = match &self.async_runtime {
+            Some(rt) => rt.block_on(self.core_linker.instantiate_async(&mut self.store, &module)),
+            None => self.core_linker.instantiate(&mut self.store, &module),
+        };
+        Ok(match instance {
+            Ok(i) => Outcome::Ok(i),
+            Err(e) => Outcome::Trap(e),
+        })
     }
 
     #[cfg(feature = "component-model")]
     fn instantiate_component(
         &mut self,
         component: &component::Component,
     ) -> Result<Outcome<(component::Component, component::Instance)>> {
-        Ok(
-            match self
+        let instance = match &self.async_runtime {
+            Some(rt) => rt.block_on(
+                self.component_linker
+                    .instantiate_async(&mut self.store, &component),
+            ),
+            None => self
                 .component_linker
-                .instantiate(&mut self.store, &component)
-            {
-                Ok(i) => Outcome::Ok((component.clone(), i)),
-                Err(e) => Outcome::Trap(e),
-            },
-        )
+                .instantiate(&mut self.store, &component),
+        };
+        Ok(match instance {
+            Ok(i) => Outcome::Ok((component.clone(), i)),
+            Err(e) => Outcome::Trap(e),
+        })
     }
 
     /// Register "spectest" which is used by the spec testsuite.
@@ -191,7 +221,14 @@ where
                     .collect::<Result<Vec<_>>>()?;
 
                 let mut results = vec![Val::null_func_ref(); func.ty(&self.store).results().len()];
-                Ok(match func.call(&mut self.store, &values, &mut results) {
+                let result = match &self.async_runtime {
+                    Some(rt) => {
+                        rt.block_on(func.call_async(&mut self.store, &values, &mut results))
+                    }
+                    None => func.call(&mut self.store, &values, &mut results),
+                };
+
+                Ok(match result {
                     Ok(()) => Outcome::Ok(Results::Core(results.into())),
                     Err(e) => Outcome::Trap(e),
                 })
@@ -209,9 +246,19 @@ where
 
                 let mut results =
                     vec![component::Val::Bool(false); func.results(&self.store).len()];
-                Ok(match func.call(&mut self.store, &values, &mut results) {
+                let result = match &self.async_runtime {
+                    Some(rt) => {
+                        rt.block_on(func.call_async(&mut self.store, &values, &mut results))
+                    }
+                    None => func.call(&mut self.store, &values, &mut results),
+                };
+                Ok(match result {
                     Ok(()) => {
-                        func.post_return(&mut self.store)?;
+                        match &self.async_runtime {
+                            Some(rt) => rt.block_on(func.post_return_async(&mut self.store))?,
+                            None => func.post_return(&mut self.store)?,
+                        }
+
                         Outcome::Ok(Results::Component(results.into()))
                     }
                     Err(e) => Outcome::Trap(e),
@@ -580,6 +627,11 @@ where
                     component_linker: component::Linker::new(self.store.engine()),
                     store: Store::new(self.store.engine(), self.store.data().clone()),
                     modules: self.modules.clone(),
+                    async_runtime: self.async_runtime.as_ref().map(|_| {
+                        tokio::runtime::Builder::new_current_thread()
+                            .build()
+                            .unwrap()
+                    }),
                 };
                 let name = thread.name.name();
                 let child =
diff --git a/fuzz/fuzz_targets/wast_tests.rs b/fuzz/fuzz_targets/wast_tests.rs
@@ -1,9 +1,12 @@
 #![no_main]
 
+use libfuzzer_sys::arbitrary::Unstructured;
 use libfuzzer_sys::fuzz_target;
-use wasmtime_fuzzing::generators::{Config, WastTest};
 
-fuzz_target!(|pair: (Config, WastTest)| {
-    let (config, test) = pair;
-    wasmtime_fuzzing::oracles::wast_test(config, test);
+fuzz_target!(|data: &[u8]| {
+    // Errors in `wast_test` have to do with not enough input in `data` or the
+    // test case being thrown out, which we ignore here since it doesn't affect
+    // how we'd like to fuzz.
+    let mut u = Unstructured::new(data);
+    let _ = wasmtime_fuzzing::oracles::wast_test(&mut u);
 });
diff --git a/src/commands/wast.rs b/src/commands/wast.rs
@@ -23,12 +23,17 @@ impl WastCommand {
     pub fn execute(mut self) -> Result<()> {
         self.common.init_logging()?;
 
-        let config = self.common.config(None)?;
+        let mut config = self.common.config(None)?;
+        config.async_support(true);
         let mut store = Store::new(&Engine::new(&config)?, ());
         if let Some(fuel) = self.common.wasm.fuel {
             store.set_fuel(fuel)?;
         }
-        let mut wast_context = WastContext::new(store);
+        if let Some(true) = self.common.wasm.epoch_interruption {
+            store.epoch_deadline_trap();
+            store.set_epoch_deadline(1);
+        }
+        let mut wast_context = WastContext::new(store, wasmtime_wast::Async::Yes);
 
         wast_context
             .register_spectest(&SpectestConfig {
diff --git a/tests/wast.rs b/tests/wast.rs
@@ -4,7 +4,7 @@ use std::sync::{Condvar, LazyLock, Mutex};
 use wasmtime::{
     Config, Engine, InstanceAllocationStrategy, MpkEnabled, PoolingAllocationConfig, Store,
 };
-use wasmtime_wast::{SpectestConfig, WastContext};
+use wasmtime_wast::{Async, SpectestConfig, WastContext};
 use wasmtime_wast_util::{limits, Collector, Compiler, WastConfig, WastTest};
 
 fn main() {
@@ -123,6 +123,7 @@ fn run_wast(test: &WastTest, config: WastConfig) -> anyhow::Result<()> {
     };
 
     let mut cfg = Config::new();
+    cfg.async_support(true);
     component_test_util::apply_test_config(&mut cfg, &test_config);
     component_test_util::apply_wast_config(&mut cfg, &config);
 
@@ -229,7 +230,7 @@ fn run_wast(test: &WastTest, config: WastConfig) -> anyhow::Result<()> {
     for (engine, desc) in engines {
         let result = engine.and_then(|engine| {
             let store = Store::new(&engine, ());
-            let mut wast_context = WastContext::new(store);
+            let mut wast_context = WastContext::new(store, Async::Yes);
             wast_context.register_spectest(&SpectestConfig {
                 use_shared_memory: true,
                 suppress_prints: true,
