Implemented an asyncify based implementation of asynchronous threading

lib/api/src/externals/memory.rs

@@ -72,7 +72,7 @@ impl Memory {
 
     /// Creates a view into the memory that then allows for
     /// read and write
-    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+    pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
         MemoryView::new(self, store)
     }
 
@@ -119,15 +119,6 @@ impl Memory {
         self.0.grow(store, delta)
     }
 
-    /// Copies the memory to a new store and returns a memory reference to it
-    pub fn copy_to_store(
-        &self,
-        store: &impl AsStoreRef,
-        new_store: &mut impl AsStoreMut,
-    ) -> Result<Self, MemoryError> {
-        Ok(Self(self.0.copy_to_store(store, new_store)?))
-    }
-
     pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternMemory) -> Self {
         Self(memory_impl::Memory::from_vm_extern(store, vm_extern))
     }
@@ -143,34 +134,44 @@ impl Memory {
     }
 
     /// Attempts to clone this memory (if its clonable) in a new store
-    pub fn clone_in_store(
+    /// (cloned memory will be shared between those that clone it)
+    pub fn share_in_store(
         &self,
         store: &impl AsStoreRef,
         new_store: &mut impl AsStoreMut,
-    ) -> Option<Self> {
+    ) -> Result<Self, MemoryError> {
         if !self.ty(store).shared {
             // We should only be able to duplicate in a new store if the memory is shared
-            return None;
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
         }
         self.0
             .try_clone(&store)
             .map(|new_memory| Self::new_from_existing(new_store, new_memory))
+            .ok_or_else(|| MemoryError::Generic("memory is not clonable".to_string()))
     }
 
     /// Attempts to duplicate this memory (if its clonable) in a new store
-    pub fn duplicate_in_store(
+    /// (copied memory)
+    pub fn copy_to_store(
         &self,
         store: &impl AsStoreRef,
         new_store: &mut impl AsStoreMut,
-    ) -> Option<Self> {
+    ) -> Result<Self, MemoryError> {
         if !self.ty(store).shared {
             // We should only be able to duplicate in a new store if the memory is shared
-            return None;
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
         }
         self.0
             .try_clone(&store)
-            .and_then(|mut memory| memory.duplicate().ok())
+            .and_then(|mut memory| memory.copy().ok())
             .map(|new_memory| Self::new_from_existing(new_store, new_memory.into()))
+            .ok_or_else(|| {
+                MemoryError::Generic("memory is not clonable or could not be copied".to_string())
+            })
     }
 
     /// To `VMExtern`.

lib/api/src/externals/memory_view.rs

@@ -19,7 +19,7 @@ use crate::sys::externals::memory_view as memory_view_impl;
 pub struct MemoryView<'a>(pub(crate) memory_view_impl::MemoryView<'a>);
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         MemoryView(memory_view_impl::MemoryView::new(&memory.0, store))
     }
 

lib/api/src/js/externals/memory.rs

@@ -10,7 +10,7 @@ use tracing::warn;
 
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
-use wasmer_types::{Pages, WASM_PAGE_SIZE};
+use wasmer_types::Pages;
 
 use super::memory_view::MemoryView;
 
@@ -136,33 +136,6 @@ impl Memory {
         Ok(Pages(new_pages))
     }
 
-    pub fn copy_to_store(
-        &self,
-        store: &impl AsStoreRef,
-        new_store: &mut impl AsStoreMut,
-    ) -> Result<Self, MemoryError> {
-        // Create the new memory using the parameters of the existing memory
-        let view = self.view(store);
-        let ty = self.ty(store);
-        let amount = view.data_size() as usize;
-
-        let new_memory = Self::new(new_store, ty)?;
-        let new_view_size = new_memory.view(&new_store).data_size() as usize;
-        if amount > new_view_size {
-            let delta = amount - new_view_size;
-            let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
-            new_memory.grow(new_store, Pages(pages as u32))?;
-        }
-        let new_view = new_memory.view(&new_store);
-
-        // Copy the bytes
-        view.copy_to_memory(amount as u64, &new_view)
-            .map_err(|err| MemoryError::Generic(err.to_string()))?;
-
-        // Return the new memory
-        Ok(new_memory)
-    }
-
     pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMMemory) -> Self {
         Self { handle: internal }
     }
@@ -174,11 +147,6 @@ impl Memory {
     pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
         true
     }
-
-    #[allow(unused)]
-    pub fn duplicate(&mut self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
-        self.handle.duplicate()
-    }
 }
 
 impl std::cmp::PartialEq for Memory {

lib/api/src/js/externals/memory_view.rs

@@ -26,7 +26,7 @@ pub struct MemoryView<'a> {
 }
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, _store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, _store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         Self::new_raw(&memory.handle.memory)
     }
 

lib/api/src/js/vm.rs

@@ -59,7 +59,7 @@ impl VMMemory {
     }
 
     /// Copies this memory to a new memory
-    pub fn duplicate(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
+    pub fn copy(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
         let new_memory = crate::js::externals::memory::Memory::js_memory_from_type(&self.ty)?;
 
         let src = crate::js::externals::memory_view::MemoryView::new_raw(&self.memory);

lib/api/src/ptr.rs

@@ -60,7 +60,7 @@ pub type WasmPtr64<T> = WasmPtr<T, Memory64>;
 #[repr(transparent)]
 pub struct WasmPtr<T, M: MemorySize = Memory32> {
     offset: M::Offset,
-    _phantom: PhantomData<*mut T>,
+    _phantom: PhantomData<T>,
 }
 
 impl<T, M: MemorySize> WasmPtr<T, M> {

lib/api/src/store.rs

@@ -188,6 +188,7 @@ impl fmt::Debug for Store {
 }
 
 /// A temporary handle to a [`Store`].
+#[derive(Debug)]
 pub struct StoreRef<'a> {
     pub(crate) inner: &'a StoreInner,
 }

lib/api/src/sys/externals/memory.rs

@@ -39,12 +39,6 @@ impl Memory {
         self.handle.get(store.as_store_ref().objects()).ty()
     }
 
-    /// Creates a view into the memory that then allows for
-    /// read and write
-    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
-        MemoryView::new(self, store)
-    }
-
     pub fn grow<IntoPages>(
         &self,
         store: &mut impl AsStoreMut,
@@ -56,34 +50,6 @@ impl Memory {
         self.handle.get_mut(store.objects_mut()).grow(delta.into())
     }
 
-    pub fn copy_to_store(
-        &self,
-        store: &impl AsStoreRef,
-        new_store: &mut impl AsStoreMut,
-    ) -> Result<Self, MemoryError> {
-        // Create the new memory using the parameters of the existing memory
-        let view = self.view(store);
-        let ty = self.ty(store);
-        let amount = view.data_size() as usize;
-
-        let new_memory = Self::new(new_store, ty)?;
-        let mut new_view = new_memory.view(&new_store);
-        let new_view_size = new_view.data_size() as usize;
-        if amount > new_view_size {
-            let delta = amount - new_view_size;
-            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
-            new_memory.grow(new_store, Pages(pages as u32))?;
-            new_view = new_memory.view(&new_store);
-        }
-
-        // Copy the bytes
-        view.copy_to_memory(amount as u64, &new_view)
-            .map_err(|err| MemoryError::Generic(err.to_string()))?;
-
-        // Return the new memory
-        Ok(new_memory)
-    }
-
     pub(crate) fn from_vm_extern(store: &impl AsStoreRef, vm_extern: VMExternMemory) -> Self {
         Self {
             handle: unsafe {

lib/api/src/sys/externals/memory_view.rs

@@ -22,7 +22,7 @@ pub struct MemoryView<'a> {
 }
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let size = memory.handle.get(store.as_store_ref().objects()).size();
 
         let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();

lib/api/src/sys/tunables.rs

@@ -6,6 +6,7 @@ pub use wasmer_compiler::BaseTunables;
 #[cfg(test)]
 mod tests {
     use super::*;
+    #[allow(unused)]
     use crate::sys::NativeEngineExt;
     use crate::TableType;
     use std::cell::UnsafeCell;
@@ -123,7 +124,7 @@ mod tests {
             None
         }
 
-        fn duplicate(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
             let mem = self.mem.clone();
             Ok(Box::new(Self {
                 memory_definition: Some(UnsafeCell::new(VMMemoryDefinition {
@@ -243,6 +244,7 @@ mod tests {
         let compiler = Cranelift::default();
 
         let tunables = TinyTunables {};
+        #[allow(deprecated)]
         let mut engine = Engine::new(compiler.into(), Default::default(), Default::default());
         engine.set_tunables(tunables);
         let mut store = Store::new(engine);