Add async to the component_api fuzzer (#12047)

This commit extends the preexisting `component_api` fuzzer in Wasmtime
to support `async`. This required a fair bit of refactoring to how the
fuzzer worked but the basic idea remains the same. This fuzzer
generates:

* An arbitrary component-model type signature (minus
  resources/futures/streams)
* A component which imports a function of this signature from the host
  and exports a function of this signature to the host.
* Internally the export is implemented with a component `caller` that
  imports/exports this function signature.
* The `caller` component is instantiated with a `callee` component that
  imports/exports this function signature.
* The `callee` component is instantiated with the host.

In essence a component model value is threaded into a component, to
another composed component, then back out to the host. The return value
then makes its way back through the same channel. The fuzz test ensures
that the parameters received in the host import are the same as those
passed to the export. Additionally the return value of the export is
ensured to be the same as the one that the host import returned. In
essence this is testing ABI handling in Wasmtime to ensure that
composition works correctly in addition to lifting/lowering code.

This fuzzer additionally has a "static" and "dynamic" mode where, at
compile time, N components are generated with different signatures and
use the "typed" APIs of Wasmtime. For "dynamic" `Val` is used to test
and arbitrary components are generated at fuzz-time. The fuzzer finally
executes this roundtrip in a loop multiple times in one fuzz test case
to test different runtime-shapes of values in addition to
compile-time-shapes of values.

The main addition in this commit is to extend all of this with the async
ABI. The following knobs were added and implemented:

* The function type used for the root component export, the function
  between the composed components, and the function imported from the
  host all have the ability to be an `async` function type now.

* The lifts/lowers, in all locations, can be configured with the various
  ABIs supported (e.g. sync, async-callback, or async-stackful for
  lifts, and sync/async for lowers).

* Like before the string encoding can be varied between the components
  as well.

This is intended to stress combining different flavors of ABI with
different behaviors to ensure that all the various paths throughout
Wasmtime and such are hit. The goal of this fuzzer is to stress ABI
lifting/lowering, so this is not handling much related to async event
scheduling (that's for a future fuzzer).

In a follow-up commit I hope to extend this fuzzer with some async event
scheduling nonetheless. For example the fuzzer will generate an async
yield point before/after calling `task.return` or before/after calling
the host import. That is intended to stress `first_poll`-vs-not behavior
as it relates to ABI handling. None of that is yet implemented and for
this fuzzer async calls are assumed to always succeed immediately for now.

Author: alexcrichton

Cargo.lock

@@ -15,7 +15,6 @@ use wasmtime_environ::{ScopeVec, Tunables, component::*};
 use wasmtime_test_util::component_fuzz::{MAX_TYPE_DEPTH, TestCase, Type};
 
 const TYPE_COUNT: usize = 50;
-const MAX_ARITY: u32 = 5;
 
 #[derive(Debug)]
 struct GenAdapter<'a> {
@@ -48,21 +47,7 @@ fn target(data: &[u8]) -> arbitrary::Result<()> {
     }
 
     // Next generate a static API test case driven by the above types.
-    let mut params = Vec::new();
-    let mut result = None;
-    for _ in 0..u.int_in_range(0..=MAX_ARITY)? {
-        params.push(u.choose(&types)?);
-    }
-    if u.arbitrary()? {
-        result = Some(u.choose(&types)?);
-    }
-
-    let test = TestCase {
-        params,
-        result,
-        encoding1: u.arbitrary()?,
-        encoding2: u.arbitrary()?,
-    };
+    let test = TestCase::generate(&types, &mut u)?;
     let adapter = GenAdapter { test };
 
     let wat_decls = adapter.test.declarations();

crates/environ/fuzz/fuzz_targets/fact-valid-module.rs

@@ -6,12 +6,13 @@
 //! parameters to the imported one and forwards the result back to the caller.  This serves to exercise Wasmtime's
 //! lifting and lowering code and verify the values remain intact during both processes.
 
+use crate::block_on;
 use arbitrary::{Arbitrary, Unstructured};
 use std::any::Any;
 use std::fmt::Debug;
 use std::ops::ControlFlow;
 use wasmtime::component::{self, Component, ComponentNamedList, Lift, Linker, Lower, Val};
-use wasmtime::{Config, Engine, Store, StoreContextMut};
+use wasmtime::{AsContextMut, Config, Engine, Store, StoreContextMut};
 use wasmtime_test_util::component_fuzz::{Declarations, EXPORT_FUNCTION, IMPORT_FUNCTION};
 
 /// Minimum length of an arbitrary list value generated for a test case
@@ -147,45 +148,82 @@ where
 
     let mut config = Config::new();
     config.wasm_component_model(true);
+    config.wasm_component_model_async(true);
+    config.wasm_component_model_async_stackful(true);
+    config.async_support(true);
     config.debug_adapter_modules(input.arbitrary()?);
     let engine = Engine::new(&config).unwrap();
     let wat = declarations.make_component();
     let wat = wat.as_bytes();
     crate::oracles::log_wasm(wat);
     let component = Component::new(&engine, wat).unwrap();
     let mut linker = Linker::new(&engine);
-    linker
-        .root()
-        .func_wrap(
-            IMPORT_FUNCTION,
-            |cx: StoreContextMut<'_, Box<dyn Any + Send>>, params: P| {
-                log::trace!("received parameters {params:?}");
-                let data: &(P, R) = cx.data().downcast_ref().unwrap();
-                let (expected_params, result) = data;
-                assert_eq!(params, *expected_params);
-                log::trace!("returning result {result:?}");
-                Ok(result.clone())
-            },
-        )
-        .unwrap();
-    let mut store: Store<Box<dyn Any + Send>> = Store::new(&engine, Box::new(()));
-    let instance = linker.instantiate(&mut store, &component).unwrap();
-    let func = instance
-        .get_typed_func::<P, R>(&mut store, EXPORT_FUNCTION)
-        .unwrap();
-
-    while input.arbitrary()? {
-        let params = input.arbitrary::<P>()?;
-        let result = input.arbitrary::<R>()?;
-        *store.data_mut() = Box::new((params.clone(), result.clone()));
-        log::trace!("passing in parameters {params:?}");
-        let actual = func.call(&mut store, params).unwrap();
-        log::trace!("got result {actual:?}");
-        assert_eq!(actual, result);
-        func.post_return(&mut store).unwrap();
+
+    fn host_function<P, R>(
+        cx: StoreContextMut<'_, Box<dyn Any + Send>>,
+        params: P,
+    ) -> anyhow::Result<R>
+    where
+        P: Debug + PartialEq + 'static,
+        R: Debug + Clone + 'static,
+    {
+        log::trace!("received parameters {params:?}");
+        let data: &(P, R) = cx.data().downcast_ref().unwrap();
+        let (expected_params, result) = data;
+        assert_eq!(params, *expected_params);
+        log::trace!("returning result {result:?}");
+        Ok(result.clone())
+    }
+
+    if declarations.options.host_async {
+        linker
+            .root()
+            .func_wrap_concurrent(IMPORT_FUNCTION, |a, params| {
+                Box::pin(async move {
+                    a.with(|mut cx| host_function::<P, R>(cx.as_context_mut(), params))
+                })
+            })
+            .unwrap();
+    } else {
+        linker
+            .root()
+            .func_wrap(IMPORT_FUNCTION, |cx, params| {
+                host_function::<P, R>(cx, params)
+            })
+            .unwrap();
     }
+    let mut store: Store<Box<dyn Any + Send>> = Store::new(&engine, Box::new(()));
+
+    block_on(async {
+        let instance = linker
+            .instantiate_async(&mut store, &component)
+            .await
+            .unwrap();
+        let func = instance
+            .get_typed_func::<P, R>(&mut store, EXPORT_FUNCTION)
+            .unwrap();
 
-    Ok(())
+        while input.arbitrary()? {
+            let params = input.arbitrary::<P>()?;
+            let result = input.arbitrary::<R>()?;
+            *store.data_mut() = Box::new((params.clone(), result.clone()));
+            log::trace!("passing in parameters {params:?}");
+            let actual = if declarations.options.guest_caller_async {
+                store
+                    .run_concurrent(async |a| func.call_concurrent(a, params).await.unwrap().0)
+                    .await
+                    .unwrap()
+            } else {
+                let result = func.call_async(&mut store, params).await.unwrap();
+                func.post_return_async(&mut store).await.unwrap();
+                result
+            };
+            log::trace!("got result {actual:?}");
+            assert_eq!(actual, result);
+        }
+
+        Ok(())
+    })
 }
 
 #[cfg(test)]
@@ -197,12 +235,9 @@ mod tests {
     #[test]
     fn static_api_smoke_test() {
         test_n_times(10, |(), u| {
-            let case = TestCase {
-                params: vec![&Type::S32, &Type::Bool, &Type::String],
-                result: Some(&Type::String),
-                encoding1: u.arbitrary()?,
-                encoding2: u.arbitrary()?,
-            };
+            let mut case = TestCase::generate(&[], u)?;
+            case.params = vec![&Type::S32, &Type::Bool, &Type::String];
+            case.result = Some(&Type::String);
 
             let declarations = case.declarations();
             static_api_test::<(i32, bool, String), (String,)>(u, &declarations)

crates/fuzzing/src/generators/component_types.rs

@@ -2,6 +2,8 @@
 
 #![deny(missing_docs)]
 
+use std::task::{Context, Poll, Waker};
+
 pub use wasm_mutate;
 pub use wasm_smith;
 pub mod generators;
@@ -30,6 +32,17 @@ pub fn init_fuzzing() {
     });
 }
 
+fn block_on<F: Future>(future: F) -> F::Output {
+    let mut f = Box::pin(future);
+    let mut cx = Context::from_waker(Waker::noop());
+    loop {
+        match f.as_mut().poll(&mut cx) {
+            Poll::Ready(val) => break val,
+            Poll::Pending => {}
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use arbitrary::{Arbitrary, Unstructured};