RFC Host yielding API

Cargo.toml

@@ -85,6 +85,7 @@ default = [
     "emscripten",
     "middlewares",
 ]
+async = ["wasmer/async"]
 engine = []
 jit = [
     "wasmer-engine-jit",

examples/tunables_limit_memory.rs

@@ -102,11 +102,12 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
         ty: &MemoryType,
         style: &MemoryStyle,
         vm_definition_location: NonNull<VMMemoryDefinition>,
+        src_memory: Option<&dyn vm::Memory>,
     ) -> Result<Arc<dyn vm::Memory>, MemoryError> {
         let adjusted = self.adjust_memory(ty);
         self.validate_memory(&adjusted)?;
         self.base
-            .create_vm_memory(&adjusted, style, vm_definition_location)
+            .create_vm_memory(&adjusted, style, vm_definition_location, src_memory)
     }
 
     /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].

lib/api/Cargo.toml

@@ -27,6 +27,8 @@ wat = { version = "1.0", optional = true }
 thiserror = "1.0"
 more-asserts = "0.2"
 target-lexicon = { version = "0.11", default-features = false }
+async-wormhole = { version="0.3", optional=true }
+switcheroo = { version="0.2", optional=true }
 loupe = "0.1"
 
 [target.'cfg(target_os = "windows")'.dependencies]
@@ -75,6 +77,13 @@ llvm = [
     "wasmer-compiler-llvm",
     "compiler",
 ]
+async = [
+    "async-wormhole",
+    "switcheroo",
+    "wasmer-derive/async",
+    "wasmer-vm/async",
+    "wasmer-engine/async",
+]
 # enables internal features used by the deprecated API.
 deprecated = []
 default-compiler = []

lib/api/src/env.rs

@@ -87,6 +87,10 @@ pub trait WasmerEnv: Clone + Send + Sync {
     fn init_with_instance(&mut self, _instance: &Instance) -> Result<(), HostEnvInitError> {
         Ok(())
     }
+
+    #[cfg(feature = "async")]
+    /// Set the thread-specific yielder
+    fn set_yielder(&mut self, _: *const std::ffi::c_void) {}
 }
 
 impl WasmerEnv for u8 {}

lib/api/src/externals/function.rs

@@ -70,6 +70,53 @@ pub struct Function {
     pub(crate) exported: ExportFunction,
 }
 
+#[cfg(feature = "async")]
+fn build_export_function_metadata<Env>(
+    env: Env,
+    import_init_function_ptr: for<'a> fn(
+        &'a mut Env,
+        &'a crate::Instance,
+    ) -> Result<(), crate::HostEnvInitError>,
+    host_env_set_yielder_fn: fn(*mut std::ffi::c_void, *const std::ffi::c_void),
+) -> (*mut std::ffi::c_void, ExportFunctionMetadata)
+where
+    Env: Clone + Sized + 'static + Send + Sync,
+{
+    let import_init_function_ptr = Some(unsafe {
+        std::mem::transmute::<fn(_, _) -> Result<(), _>, fn(_, _) -> Result<(), _>>(
+            import_init_function_ptr,
+        )
+    });
+    let host_env_clone_fn: fn(*mut std::ffi::c_void) -> *mut std::ffi::c_void = |ptr| {
+        let env_ref: &Env = unsafe {
+            ptr.cast::<Env>()
+                .as_ref()
+                .expect("`ptr` to the environment is null when cloning it")
+        };
+        Box::into_raw(Box::new(env_ref.clone())) as _
+    };
+    let host_env_drop_fn: fn(*mut std::ffi::c_void) = |ptr| {
+        unsafe { Box::from_raw(ptr.cast::<Env>()) };
+    };
+    let env = Box::into_raw(Box::new(env)) as _;
+
+    // # Safety
+    // - All these functions work on all threads
+    // - The host env is `Send`.
+    let metadata = unsafe {
+        ExportFunctionMetadata::new(
+            env,
+            import_init_function_ptr,
+            host_env_clone_fn,
+            host_env_set_yielder_fn,
+            host_env_drop_fn,
+        )
+    };
+
+    (env, metadata)
+}
+
+#[cfg(not(feature = "async"))]
 fn build_export_function_metadata<Env>(
     env: Env,
     import_init_function_ptr: for<'a> fn(
@@ -170,12 +217,19 @@ impl Function {
             };
             Box::into_raw(Box::new(duped_env)) as _
         };
+
         let host_env_drop_fn: fn(*mut c_void) = |ptr: *mut c_void| {
             unsafe {
                 Box::from_raw(ptr as *mut VMDynamicFunctionContext<DynamicFunctionWithoutEnv>)
             };
         };
 
+        #[cfg(feature = "async")]
+        let host_env_set_yielder_fn = |_, _| {
+            //no-op
+            println!("No-op");
+        };
+
         Self {
             store: store.clone(),
             definition: FunctionDefinition::Host(HostFunctionDefinition { has_env: false }),
@@ -189,6 +243,8 @@ impl Function {
                             host_env,
                             None,
                             host_env_clone_fn,
+                            #[cfg(feature = "async")]
+                            host_env_set_yielder_fn,
                             host_env_drop_fn,
                         )
                     },
@@ -270,10 +326,27 @@ impl Function {
                 Env::init_with_instance(&mut *env.ctx.env, instance)
             };
 
+        #[cfg(feature = "async")]
+        let (host_env, metadata) = {
+            let host_env_set_yielder_fn = |env_ptr, yielder_ptr| {
+                let env: &mut Env = unsafe { std::mem::transmute(env_ptr) };
+                env.set_yielder(yielder_ptr);
+            };
+
+            build_export_function_metadata::<VMDynamicFunctionContext<DynamicFunctionWithEnv<Env>>>(
+                dynamic_ctx,
+                import_init_function_ptr,
+                host_env_set_yielder_fn,
+            )
+        };
+
+        #[cfg(not(feature = "async"))]
         let (host_env, metadata) = build_export_function_metadata::<
             VMDynamicFunctionContext<DynamicFunctionWithEnv<Env>>,
         >(dynamic_ctx, import_init_function_ptr);
 
+        // We don't yet have the address with the Wasm ABI signature.
+
         // We don't yet have the address with the Wasm ABI signature.
         // The engine linker will replace the address with one pointing to a
         // generated dynamic trampoline.
@@ -387,6 +460,21 @@ impl Function {
         let function = inner::Function::<Args, Rets>::new(func);
         let address = function.address();
 
+        #[cfg(feature = "async")]
+        let (host_env, metadata) = {
+            let host_env_set_yielder_fn = |env_ptr, yielder_ptr| {
+                let env: &mut Env = unsafe { std::mem::transmute(env_ptr) };
+                env.set_yielder(yielder_ptr);
+            };
+
+            build_export_function_metadata::<Env>(
+                env,
+                Env::init_with_instance,
+                host_env_set_yielder_fn,
+            )
+        };
+
+        #[cfg(not(feature = "async"))]
         let (host_env, metadata) =
             build_export_function_metadata::<Env>(env, Env::init_with_instance);
 
@@ -484,7 +572,7 @@ impl Function {
         &self.store
     }
 
-    fn call_wasm(
+    pub(crate) fn call_wasm(
         &self,
         func: &WasmFunctionDefinition,
         params: &[Val],

lib/api/src/externals/mod.rs

@@ -3,6 +3,9 @@ mod global;
 mod memory;
 mod table;
 
+#[cfg(feature = "async")]
+mod yielder;
+
 pub use self::function::{
     FromToNativeWasmType, Function, HostFunction, WasmTypeList, WithEnv, WithoutEnv,
 };
@@ -13,6 +16,9 @@ pub use self::global::Global;
 pub use self::memory::Memory;
 pub use self::table::Table;
 
+#[cfg(feature = "async")]
+pub use self::yielder::Yielder;
+
 use crate::exports::{ExportError, Exportable};
 use crate::store::{Store, StoreObject};
 use crate::ExternType;

lib/api/src/externals/yielder.rs

@@ -0,0 +1,28 @@
+use async_wormhole::AsyncYielder;
+
+use crate::{RuntimeError, Val};
+
+/// Wrapper around `async-wormhole`'s yielder
+#[derive(Clone)]
+pub struct Yielder {
+    inner: *const std::ffi::c_void,
+}
+
+impl Yielder {
+    /// Create a new instance from a raw pointer to a yielder
+    pub fn new(inner: *const std::ffi::c_void) -> Self {
+        Self { inner }
+    }
+
+    /// Get the `AsyncYielder`
+    pub fn get(&self) -> &mut AsyncYielder<Result<Box<[Val]>, RuntimeError>> {
+        let yielder: &mut AsyncYielder<Result<Box<[Val]>, RuntimeError>> =
+            unsafe { std::mem::transmute(self.inner) };
+
+        yielder
+    }
+}
+
+//FIXME
+unsafe impl Send for Yielder {}
+unsafe impl Sync for Yielder {}

lib/api/src/instance.rs

@@ -115,6 +115,7 @@ impl Instance {
     pub fn new(module: &Module, resolver: &dyn Resolver) -> Result<Self, InstantiationError> {
         let store = module.store();
         let handle = module.instantiate(resolver)?;
+
         let exports = module
             .exports()
             .map(|export| {
@@ -155,6 +156,83 @@ impl Instance {
         &self.module
     }
 
+    ///TODO
+    #[cfg(feature = "async")]
+    pub async fn call_with_stack<Stack: switcheroo::stack::Stack + Unpin>(
+        &self,
+        func_name: &str,
+        stack: Stack,
+    ) -> Result<Box<[crate::Val]>, RuntimeError> {
+        use crate::externals::function::FunctionDefinition;
+        use crate::Val;
+
+        let mut task = async_wormhole::AsyncWormhole::new(
+            stack,
+            |yielder| -> Result<Box<[crate::Val]>, RuntimeError> {
+                let yielder_ptr: *mut std::ffi::c_void = unsafe { std::mem::transmute(&yielder) };
+
+                let func = self
+                    .exports
+                    .get_function(func_name)
+                    .expect("No such function");
+                {
+                    let hdl = self.handle.lock().unwrap();
+                    hdl.set_yielder(yielder_ptr);
+                }
+
+                let params = &[];
+
+                let mut results = vec![Val::null(); func.result_arity()];
+
+                match &func.definition {
+                    FunctionDefinition::Wasm(wasm) => {
+                        let res = func.call_wasm(&wasm, params, &mut results);
+
+                        if let Err(e) = res {
+                            return Err(e);
+                        }
+                    }
+                    _ => unimplemented!("The function definition isn't supported for the moment"),
+                }
+
+                Ok(results.into_boxed_slice())
+            },
+        )
+        .expect("Failed to create async function call");
+
+        {
+            use std::cell::Cell;
+            use wasmer_vm::{take_tls, restore_tls};
+
+            let ptr: u64 = {
+                let ptr = take_tls().into_inner();
+                unsafe{ std::mem::transmute(ptr) }
+            };
+
+            let tls_store = Mutex::new((false, ptr));
+
+            task.set_pre_post_poll(move || {
+                let mut tls_store = tls_store.lock().unwrap();
+
+                if tls_store.0 {
+                    let ptr = take_tls().into_inner();
+                    tls_store.1 = unsafe{ std::mem::transmute(ptr) };
+                    tls_store.0 = false;
+                } else {
+                    let mut value = 0;
+                    std::mem::swap(&mut value, &mut tls_store.1);
+
+                    let value = unsafe{ std::mem::transmute(value) };
+                    restore_tls(Cell::new(value));
+
+                    tls_store.0 = true;
+                }
+            });
+        }
+
+        task.await
+    }
+
     /// Returns the [`Store`] where the `Instance` belongs.
     pub fn store(&self) -> &Store {
         self.module.store()

lib/api/src/lib.rs

@@ -285,6 +285,8 @@ pub mod internals {
 
 pub use crate::env::{HostEnvInitError, LazyInit, WasmerEnv};
 pub use crate::exports::{ExportError, Exportable, Exports, ExportsIterator};
+#[cfg(feature = "async")]
+pub use crate::externals::Yielder;
 pub use crate::externals::{
     Extern, FromToNativeWasmType, Function, Global, HostFunction, Memory, Table, WasmTypeList,
 };

lib/compiler-llvm/src/trampoline/wasm.rs

@@ -74,6 +74,7 @@ impl FuncTrampoline {
         trampoline_func
             .as_global_value()
             .set_dll_storage_class(DLLStorageClass::Export);
+
         self.generate_trampoline(trampoline_func, ty, &callee_attrs, &self.ctx, &intrinsics)?;
 
         if let Some(ref callbacks) = config.callbacks {

lib/derive/Cargo.toml

@@ -19,3 +19,7 @@ proc-macro-error = "1.0.0"
 [dev-dependencies]
 wasmer = { path = "../api", version = "1.0.2" }
 compiletest_rs = "0.6"
+
+[features]
+default = []
+async = []