feat: add shared memories

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

Cargo.toml

@@ -47,7 +47,7 @@ unexpected_cfgs = { level = "warn", check-cfg = ["cfg(rust_analyzer)"] }
 
 [dev-dependencies]
 anyhow.workspace = true
-tinywasm = { path = "crates/tinywasm", features = ["state"] }
+tinywasm = { path = "crates/tinywasm", features = ["send", "state"] }
 tinywasm-wasi.workspace = true
 wat.workspace = true
 

crates/cli/src/wast_runner.rs

@@ -8,7 +8,9 @@ use std::time::Duration;
 use anyhow::{Context, Result, anyhow, bail};
 use log::{debug, error};
 use tinywasm::types::{MemoryType, RefType, RefValue, TableType, WasmType, WasmValue};
-use tinywasm::{ExecProgress, Global, HostFunction, Imports, Memory, Module, ModuleInstance, Store, Table};
+use tinywasm::{
+    ExecProgress, Global, HostFunction, Imports, Memory, MemoryShared, Module, ModuleInstance, Store, Table,
+};
 use wast::QuoteWat;
 use wast::core::{AbstractHeapType, NanPattern};
 
@@ -17,7 +19,7 @@ const TEST_MAX_SUSPENSIONS: u32 = 1000;
 // Older suites classify encodings that wasmparser accepts with the latest feature set as malformed.
 const ACCEPTED_MALFORMED_MESSAGES: &[&str] =
     &["integer representation too long", "zero byte expected", "zero flag expected"];
-const ACCEPTED_INVALID_MESSAGES: &[&str] = &["multiple memories"];
+const ACCEPTED_INVALID_MESSAGES: &[&str] = &["multiple memories", "multiple tables"];
 
 macro_rules! float_value {
     ($pattern:expr, $float:ty, $variant:ident) => {
@@ -172,6 +174,8 @@ impl WastRunner {
         let table64 = Table::try_new(store, TableType::new64(RefType::FUNCREF, 10, Some(20)), RefValue::Null.into())?;
         let memory =
             Memory::try_new(store, MemoryType::default().with_page_count_initial(1).with_page_count_max(Some(2)))?;
+        let shared_memory =
+            MemoryShared::try_new(MemoryType::default().with_page_count_initial(1).with_page_count_max(Some(2)))?;
         let global_i32 =
             Global::try_new(store, tinywasm::types::GlobalType::new(WasmType::I32, false), WasmValue::I32(666))?;
         let global_i64 =
@@ -183,6 +187,7 @@ impl WastRunner {
 
         imports
             .define("spectest", "memory", memory)
+            .define("spectest", "shared_memory", shared_memory)
             .define("spectest", "table", table)
             .define("spectest", "table64", table64)
             .define("spectest", "global_i32", global_i32)

crates/parser/src/conversion.rs

@@ -109,6 +109,7 @@ pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> MemoryTyp
         memory.maximum,
         memory.page_size_log2.map(|x| 1 << x),
     )
+    .with_shared(memory.shared)
 }
 
 pub(crate) fn convert_module_globals(

crates/tinywasm/src/func/context.rs

@@ -30,6 +30,12 @@ impl FuncContext<'_> {
         self.module().memory(name)
     }
 
+    /// Get a shared memory export.
+    #[cfg(feature = "std")]
+    pub fn memory_shared(&self, name: &str) -> Result<crate::MemoryShared> {
+        self.module().memory_shared(name)
+    }
+
     /// Get any exported extern value by name.
     pub fn extern_item(&self, name: &str) -> Result<crate::ExternItem> {
         self.module().extern_item(name)

crates/tinywasm/src/imports.rs

@@ -2,6 +2,8 @@ use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
+#[cfg(feature = "std")]
+use crate::MemoryShared;
 use crate::{Function, Global, HostFunction, LinkingError, Memory, Result, Table, Tag};
 use tinywasm_types::*;
 
@@ -16,6 +18,9 @@ pub enum Extern {
     Table(Table),
     /// A memory instance.
     Memory(Memory),
+    /// A shared memory, importable into independent stores.
+    #[cfg(feature = "std")]
+    MemoryShared(MemoryShared),
     /// A function import.
     Function(Function),
     /// A reusable host function definition.
@@ -45,6 +50,13 @@ impl_conv! {
     Tag => Tag,
 }
 
+#[cfg(feature = "std")]
+impl From<MemoryShared> for Extern {
+    fn from(value: MemoryShared) -> Self {
+        Self::MemoryShared(value)
+    }
+}
+
 /// Imports for a module instance
 ///
 /// This is used to link a module instance to its imports
@@ -188,6 +200,8 @@ impl Imports {
                     crate::ExternItem::Func(value) => Extern::Function(value),
                     crate::ExternItem::Global(value) => Extern::Global(value),
                     crate::ExternItem::Memory(value) => Extern::Memory(value),
+                    #[cfg(feature = "std")]
+                    crate::ExternItem::MemoryShared(value) => Extern::MemoryShared(value),
                     crate::ExternItem::Table(value) => Extern::Table(value),
                     crate::ExternItem::Tag(value) => Extern::Tag(value),
                 })
@@ -228,6 +242,7 @@ impl ResolvedImports {
         real_size: usize,
     ) -> Result<()> {
         Self::compare_types(import, &expected.arch(), &actual.arch())?;
+        Self::compare_types(import, &expected.shared(), &actual.shared())?;
 
         if actual.page_count_initial() > expected.page_count_initial() && actual.page_count_initial() > real_size as u64
         {
@@ -286,6 +301,16 @@ impl ResolvedImports {
                     memory.0.validate_store(store)?;
                     ExternVal::Memory(memory.0.addr)
                 }
+                #[cfg(feature = "std")]
+                Extern::MemoryShared(memory) => {
+                    let index = MemAddr::try_from(store.state.shared_memories.len())
+                        .map_err(|_| crate::Error::UnsupportedFeature("too many shared memories"))?;
+                    if index >= crate::store::SHARED_MEM_BIT - 1 {
+                        return Err(crate::Error::UnsupportedFeature("too many shared memories"));
+                    }
+                    store.state.shared_memories.push(memory.clone());
+                    ExternVal::Memory(index | crate::store::SHARED_MEM_BIT)
+                }
                 Extern::Function(func) => {
                     func.item.validate_store(store)?;
                     ExternVal::Func(func.addr())
@@ -339,8 +364,21 @@ impl ResolvedImports {
                     imports.tables.push(table_addr);
                 }
                 (ExternVal::Memory(memory_addr), ImportKind::Memory(ty)) => {
-                    let mem = store.state.get_mem(memory_addr);
-                    Self::compare_memory_types(import, &mem.kind, ty, mem.page_count)?;
+                    #[cfg(feature = "std")]
+                    let (kind, pages) = if memory_addr & crate::store::SHARED_MEM_BIT != 0 {
+                        let memory =
+                            &store.state.shared_memories[(memory_addr & !crate::store::SHARED_MEM_BIT) as usize];
+                        (memory.ty(), memory.page_count())
+                    } else {
+                        let memory = store.state.get_mem(memory_addr);
+                        (memory.kind, memory.page_count)
+                    };
+                    #[cfg(not(feature = "std"))]
+                    let (kind, pages) = {
+                        let memory = store.state.get_mem(memory_addr);
+                        (memory.kind, memory.page_count)
+                    };
+                    Self::compare_memory_types(import, &kind, ty, pages)?;
                     imports.memories.push(memory_addr);
                 }
                 (ExternVal::Func(func_addr), ImportKind::Function(ty)) => {

crates/tinywasm/src/instance.rs

@@ -9,13 +9,18 @@ use crate::store::MemoryInstance;
 use crate::{
     Error, Function, FunctionTyped, Global, Imports, Memory, Result, Store, StoreItem, Table, Tag, Trap, WasmValue,
 };
+#[cfg(feature = "std")]
+use crate::{MemoryShared, store::SHARED_MEM_BIT};
 
 /// A typed view over an exported extern value.
 pub enum ExternItem {
     /// Exported function handle.
     Func(Function),
     /// Exported memory reference.
     Memory(Memory),
+    /// Exported shared memory.
+    #[cfg(feature = "std")]
+    MemoryShared(MemoryShared),
     /// Exported table reference.
     Table(Table),
     /// Exported global reference.
@@ -57,6 +62,8 @@ struct ModuleInstanceInner {
     func_addrs: Box<[FuncAddr]>,
     table_addrs: Box<[TableAddr]>,
     mem_addrs: Box<[MemAddr]>,
+    #[cfg(feature = "std")]
+    shared_backings: Box<[(MemAddr, MemoryShared)]>,
     global_addrs: Box<[GlobalAddr]>,
     tag_addrs: Box<[TagAddr]>,
     elem_addrs: Box<[ElemAddr]>,
@@ -187,6 +194,19 @@ impl ModuleInstance {
     }
 
     fn instantiate_inner(store: &mut Store, module: &Module, imports: &[crate::Extern]) -> Result<Self> {
+        if module.memory_types.iter().any(|ty| ty.shared() && ty.page_count_max_declared().is_none())
+            || module.imports.iter().any(|import| {
+                matches!(import.kind, ImportKind::Memory(ty) if ty.shared() && ty.page_count_max_declared().is_none())
+            })
+        {
+            return Err(Error::UnsupportedFeature("shared memory requires a maximum"));
+        }
+        #[cfg(not(feature = "std"))]
+        if module.memory_types.iter().any(MemoryType::shared)
+            || module.imports.iter().any(|import| matches!(import.kind, ImportKind::Memory(ty) if ty.shared()))
+        {
+            return Err(Error::UnsupportedFeature("shared memory requires std"));
+        }
         let type_addrs = store.register_module_types(&module.types);
         let id = store.next_module_instance_id();
         let mut addrs = crate::imports::ResolvedImports::new(store, module, &type_addrs, imports)?;
@@ -205,13 +225,23 @@ impl ModuleInstance {
         let elem_addrs = store.alloc_elements(&addrs.funcs, &addrs.globals, &module.elements, &type_addrs)?;
         let data_addrs = store.alloc_data(&module.data);
 
+        #[cfg(feature = "std")]
+        let shared_backings = addrs
+            .memories
+            .iter()
+            .filter(|&&addr| addr & SHARED_MEM_BIT != 0)
+            .map(|&addr| (addr, store.state.shared_memories[(addr & !SHARED_MEM_BIT) as usize].clone()))
+            .collect();
+
         let instance = ModuleInstanceInner {
             store_id: store.id(),
             id,
             type_addrs,
             func_addrs: addrs.funcs.into_boxed_slice(),
             table_addrs: addrs.tables.into_boxed_slice(),
             mem_addrs: addrs.memories.into_boxed_slice(),
+            #[cfg(feature = "std")]
+            shared_backings,
             global_addrs: addrs.globals.into_boxed_slice(),
             tag_addrs: addrs.tags.into_boxed_slice(),
             elem_addrs,
@@ -295,7 +325,17 @@ impl ModuleInstance {
                     ExternItem::Table(Table(StoreItem::new(self.0.store_id, self.resolve_table_addr(export.index))))
                 }
                 ExternalKind::Memory => {
-                    ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, self.resolve_mem_addr(export.index))))
+                    let addr = self.resolve_mem_addr(export.index);
+                    #[cfg(feature = "std")]
+                    if addr & SHARED_MEM_BIT != 0 {
+                        ExternItem::MemoryShared(
+                            self.shared_backing(addr).expect("exported shared memory has a backing"),
+                        )
+                    } else {
+                        ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr)))
+                    }
+                    #[cfg(not(feature = "std"))]
+                    ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr)))
                 }
                 ExternalKind::Global => {
                     ExternItem::Global(Global(StoreItem::new(self.0.store_id, self.resolve_global_addr(export.index))))
@@ -352,7 +392,13 @@ impl ModuleInstance {
             ExternVal::Func(addr) => {
                 Ok(ExternItem::Func(Function { item: StoreItem::new(self.0.store_id, addr), module_id: self.id() }))
             }
-            ExternVal::Memory(addr) => Ok(ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr)))),
+            ExternVal::Memory(addr) => {
+                #[cfg(feature = "std")]
+                if addr & SHARED_MEM_BIT != 0 {
+                    return Ok(ExternItem::MemoryShared(self.shared_backing(addr)?));
+                }
+                Ok(ExternItem::Memory(Memory(StoreItem::new(self.0.store_id, addr))))
+            }
             ExternVal::Table(addr) => Ok(ExternItem::Table(Table(StoreItem::new(self.0.store_id, addr)))),
             ExternVal::Global(addr) => Ok(ExternItem::Global(Global(StoreItem::new(self.0.store_id, addr)))),
             ExternVal::Tag(addr) => Ok(ExternItem::Tag(Tag(StoreItem::new(self.0.store_id, addr)))),
@@ -482,11 +528,32 @@ impl ModuleInstance {
     /// Get a memory export by name.
     pub fn memory(&self, name: &str) -> Result<Memory> {
         match self.require_export(name)? {
-            ExternVal::Memory(mem_addr) => Ok(Memory(StoreItem::new(self.0.store_id, mem_addr))),
+            ExternVal::Memory(mem_addr) if mem_addr & crate::store::SHARED_MEM_BIT == 0 => {
+                Ok(Memory(StoreItem::new(self.0.store_id, mem_addr)))
+            }
             _ => cold!(Err(Error::Other(format!("Export is not a memory: {name}")))),
         }
     }
 
+    #[cfg(feature = "std")]
+    fn shared_backing(&self, addr: MemAddr) -> Result<MemoryShared> {
+        self.0
+            .shared_backings
+            .iter()
+            .find(|(index, _)| *index == addr)
+            .map(|(_, backing)| backing.clone())
+            .ok_or_else(|| Error::Other("invalid shared memory address".into()))
+    }
+
+    /// Returns a shared memory export by name.
+    #[cfg(feature = "std")]
+    pub fn memory_shared(&self, name: &str) -> Result<MemoryShared> {
+        match self.require_export(name)? {
+            ExternVal::Memory(addr) if addr & SHARED_MEM_BIT != 0 => self.shared_backing(addr),
+            _ => Err(Error::Other(format!("Export is not a shared memory: {name}"))),
+        }
+    }
+
     /// Get a memory by its module-local index.
     ///
     /// This exposes an internal module-owned memory directly and bypasses the
@@ -496,7 +563,11 @@ impl ModuleInstance {
     #[cfg_attr(docsrs, doc(cfg(feature = "guest-debug")))]
     #[cfg(feature = "guest-debug")]
     pub fn memory_by_index(&self, memory_index: MemAddr) -> Result<Memory> {
-        Ok(Memory(StoreItem::new(self.0.store_id, Self::index_addr(&self.0.mem_addrs, memory_index, "memory")?)))
+        let addr = Self::index_addr(&self.0.mem_addrs, memory_index, "memory")?;
+        if addr & crate::store::SHARED_MEM_BIT != 0 {
+            return Err(Error::UnsupportedFeature("use shared memory access for this index"));
+        }
+        Ok(Memory(StoreItem::new(self.0.store_id, addr)))
     }
 
     /// Get a table export by name.