generalize async fiber abstraction

benches/call.rs

@@ -134,8 +134,8 @@ fn bench_host_to_wasm<Params, Results>(
     typed_params: Params,
     typed_results: Results,
 ) where
-    Params: WasmParams + ToVals + Copy,
-    Results: WasmResults + ToVals + Copy + PartialEq + Debug,
+    Params: WasmParams + ToVals + Copy + Sync,
+    Results: WasmResults + ToVals + Copy + Sync + PartialEq + Debug + 'static,
 {
     // Benchmark the "typed" version, which should be faster than the versions
     // below.
@@ -628,7 +628,8 @@ mod component {
             + PartialEq
             + Debug
             + Send
-            + Sync,
+            + Sync
+            + 'static,
     {
         // Benchmark the "typed" version.
         c.bench_function(&format!("component - host-to-wasm - typed - {name}"), |b| {

crates/wasmtime/src/runtime.rs

@@ -34,6 +34,8 @@ pub(crate) mod code_memory;
 #[cfg(feature = "debug-builtins")]
 pub(crate) mod debug;
 pub(crate) mod externals;
+#[cfg(feature = "async")]
+pub(crate) mod fiber;
 pub(crate) mod gc;
 pub(crate) mod instance;
 pub(crate) mod instantiate;

crates/wasmtime/src/runtime/component/func.rs

@@ -547,7 +547,7 @@ impl Func {
         let mut store = store.as_context_mut();
         assert!(
             store.0.async_support(),
-            "cannot use `call_async` without enabling async support in the config"
+            "cannot use `post_return_async` without enabling async support in the config"
         );
         // Future optimization opportunity: conditionally use a fiber here since
         // some func's post_return will not need the async context (i.e. end up

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -179,7 +179,7 @@ where
     ) -> Result<Return>
     where
         Params: Send + Sync,
-        Return: Send + Sync,
+        Return: Send + Sync + 'static,
     {
         let mut store = store.as_context_mut();
         assert!(

crates/wasmtime/src/runtime/component/linker.rs

@@ -441,10 +441,8 @@ impl<T: 'static> LinkerInstance<'_, T> {
             self.engine.config().async_support,
             "cannot use `func_wrap_async` without enabling async support in the config"
         );
-        let ff = move |mut store: StoreContextMut<'_, T>, params: Params| -> Result<Return> {
-            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
-            let future = f(store.as_context_mut(), params);
-            unsafe { async_cx.block_on(Pin::from(future)) }?
+        let ff = move |store: StoreContextMut<'_, T>, params: Params| -> Result<Return> {
+            store.block_on(|store| f(store, params).into())?
         };
         self.func_wrap(name, ff)
     }
@@ -603,12 +601,10 @@ impl<T: 'static> LinkerInstance<'_, T> {
             self.engine.config().async_support,
             "cannot use `func_new_async` without enabling async support in the config"
         );
-        let ff = move |mut store: StoreContextMut<'_, T>, params: &[Val], results: &mut [Val]| {
-            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
-            let future = f(store.as_context_mut(), params, results);
-            unsafe { async_cx.block_on(Pin::from(future)) }?
+        let ff = move |store: StoreContextMut<'_, T>, params: &[Val], results: &mut [Val]| {
+            store.with_blocking(|store, cx| cx.block_on(Pin::from(f(store, params, results)))?)
         };
-        self.func_new(name, ff)
+        return self.func_new(name, ff);
     }
 
     /// Defines a [`Module`] within this instance.
@@ -676,12 +672,8 @@ impl<T: 'static> LinkerInstance<'_, T> {
         let dtor = Arc::new(crate::func::HostFunc::wrap_inner(
             &self.engine,
             move |mut cx: crate::Caller<'_, T>, (param,): (u32,)| {
-                let async_cx = cx.as_context_mut().0.async_cx().expect("async cx");
-                let future = dtor(cx.as_context_mut(), param);
-                match unsafe { async_cx.block_on(Pin::from(future)) } {
-                    Ok(Ok(())) => Ok(()),
-                    Ok(Err(trap)) | Err(trap) => Err(trap),
-                }
+                cx.as_context_mut()
+                    .block_on(|store| dtor(store, param).into())?
             },
         ));
         self.insert(name, Definition::Resource(ty, dtor))?;

crates/wasmtime/src/runtime/component/store.rs

@@ -28,6 +28,13 @@ impl ComponentStoreData {
     pub fn next_component_instance_id(&self) -> ComponentInstanceId {
         self.instances.next_key()
     }
+
+    #[cfg(feature = "component-model-async")]
+    pub(crate) fn drop_fibers(store: &mut StoreOpaque) {
+        _ = store;
+        // This function will actually do something when runtime support for
+        // `component-model-async` is merged.
+    }
 }
 
 impl StoreData {