feat: add support for portable-atomic, add send feature

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

Author: explodingcamera

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `ResourceLimiter` callbacks for memory and table allocation or growth
 - A default `validate` Cargo feature & parser option to skip wasm validation
 - Optional parse-time operand deduplication to reduce `.twasm` archive size
+- Optional `send` support for moving stores and store-local handles across threads without internal locks
+- Optional portable atomic shared pointers and counters for targets without native compare-and-swap
 
 ### Changed
 

Cargo.lock

@@ -57,9 +57,12 @@ See the [examples](./examples) directory and [documentation](https://docs.rs/tin
 - **`debug`:** Derives `Debug` for runtime types. Enabled by default.
 - **`parallel-parser`:** Parallelizes function parsing when `std` is enabled. Enabled by default.
 - **`guest-debug`:** Exposes module-internal by-index inspection APIs (`*_by_index`).
+- **`send`:** Makes stores and store-local handles movable across threads. Host callbacks must implement `Send + Sync`. Stores still require exclusive access and do not use internal locks.
 - **`simd-x86`:** Enables x86-specific SIMD intrinsics and uses `unsafe` internally.
 
-With default features disabled, `tinywasm` depends only on `core`, `alloc`, and `libm`, making it usable in `no_std + alloc` environments.
+With default features disabled, `tinywasm` supports `no_std + alloc` and depends only on `libm`.
+
+`Module` is always cloneable, `Send`, and `Sync`. Stores and host callbacks are thread-local by default. The `send` feature makes stores movable across threads and requires `Send + Sync` host callbacks. It does not allow concurrent access to a store. Cargo feature unification applies these callback bounds to the whole dependency graph.
 
 Use [`Engine`](https://docs.rs/tinywasm/latest/tinywasm/engine/struct.Engine.html) and [`engine::Config`](https://docs.rs/tinywasm/latest/tinywasm/engine/struct.Config.html) for non-default fuel accounting, stack sizing, or GC collection thresholds. A configured `ResourceLimiter` can allow, reject, or trap memory and table allocation or growth requests, and GC object allocations.
 

README.md

@@ -17,7 +17,18 @@ wasmparser = { workspace = true, features = ["simd"] }
 
 [features]
 default = ["log", "parallel", "std", "validate"]
+
+# enable integration with the log crate
 log = ["dep:log"]
+
+# parse and validate function bodies in parallel (requires std)
 parallel = ["std"]
+
+# support targets without native atomic CAS
+portable-atomic = ["tinywasm-types/portable-atomic"]
+
+# enable standard library support
 std = ["tinywasm-types/std", "wasmparser/std"]
+
+# validate WebAssembly while parsing
 validate = ["wasmparser/features", "wasmparser/validate"]

crates/parser/Cargo.toml

@@ -292,7 +292,8 @@ impl Parser {
                         }
 
                         let section_end = buffer_offset + section_size;
-                        let section_bytes = alloc::sync::Arc::<[u8]>::from(buffer[buffer_offset..section_end].to_vec());
+                        let section_bytes =
+                            tinywasm_types::Shared::<[u8]>::from(buffer[buffer_offset..section_end].to_vec());
                         reader.queue_owned_code_section(count, parser.offset(), section_bytes, validator.as_mut())?;
                         parser.skip_section();
                         buffer_offset = section_end;

crates/parser/src/lib.rs

@@ -3,7 +3,7 @@ use crate::log::debug;
 use crate::validation::{FuncToValidate, ValidatorResources};
 use crate::validation::{FuncValidatorAllocations, Validator};
 use crate::{ParseError, ParserOptions, Result, conversion::*, optimize};
-use alloc::{boxed::Box, format, string::ToString, sync::Arc, vec::Vec};
+use alloc::{boxed::Box, format, string::ToString, vec::Vec};
 use core::marker::PhantomData;
 use core::ops::Range;
 use tinywasm_types::*;
@@ -37,7 +37,7 @@ pub(crate) fn optimize_function_code(
 pub(crate) struct ModuleReader<'a> {
     func_validator_allocations: Option<FuncValidatorAllocations>,
     operators_reader_allocations: Option<OperatorsReaderAllocations>,
-    translation_metadata: Option<Arc<crate::visit::ModuleMetadata>>,
+    translation_metadata: Option<crate::visit::ModuleMetadata>,
 
     has_code_section: bool,
     has_type_section: bool,
@@ -48,7 +48,7 @@ pub(crate) struct ModuleReader<'a> {
     pub(crate) types: TypeSection,
     pub(crate) code_type_addrs: Box<[u32]>,
     code_results: Box<[ValueCounts]>,
-    pub(crate) exports: Arc<[Export]>,
+    pub(crate) exports: Shared<[Export]>,
     pub(crate) code: Vec<OptimizedFunctionCode>,
     pub(crate) globals: Box<[Global]>,
     pub(crate) tables: Box<[TableDefinition]>,
@@ -68,17 +68,17 @@ pub(crate) struct ModuleReader<'a> {
 impl<'a> ModuleReader<'a> {
     fn translation_metadata(&mut self) -> &crate::visit::ModuleMetadata {
         if self.translation_metadata.is_none() {
-            self.translation_metadata = Some(Arc::new(crate::visit::ModuleMetadata::new(
+            self.translation_metadata = Some(crate::visit::ModuleMetadata::new(
                 &self.types,
                 &self.code_type_addrs,
                 &self.imports,
                 &self.globals,
                 &self.memory_types,
                 &self.tables,
                 &self.tags,
-            )));
+            ));
         }
-        self.translation_metadata.as_deref().unwrap()
+        self.translation_metadata.as_ref().unwrap()
     }
 
     pub(crate) fn process_payload(&mut self, payload: Payload<'_>, validator: Option<&mut Validator>) -> Result<()> {
@@ -435,7 +435,7 @@ impl<'a> ModuleReader<'a> {
         &mut self,
         count: u32,
         body_offset: u64,
-        section_bytes: Arc<[u8]>,
+        section_bytes: Shared<[u8]>,
         validator: Option<&mut Validator>,
     ) -> Result<()> {
         #[cfg(feature = "validate")]
@@ -545,7 +545,7 @@ impl<'a> ModuleReader<'a> {
                     self.types.get(ty_idx).and_then(SubType::as_func).expect("function type was checked while parsing");
                 let params = ValueCounts::from_iter(ty.params());
 
-                Ok(Arc::new(WasmFunction {
+                Ok(Shared::new(WasmFunction {
                     instructions: code.instructions.into_boxed_slice(),
                     data: code.data,
                     locals: code.locals,

crates/parser/src/module.rs

@@ -1,10 +1,9 @@
 use crate::module::{OptimizedFunctionCode, optimize_function_code};
 use crate::validation::{FuncToValidate, FuncValidatorAllocations, ValidatorResources};
 use crate::{ParseError, ParserOptions, Result, conversion};
-use alloc::sync::Arc;
 use alloc::vec::Vec;
 use core::ops::Range;
-use tinywasm_types::ValueCounts;
+use tinywasm_types::{Shared, ValueCounts};
 use wasmparser::OperatorsReaderAllocations;
 
 pub(crate) enum FunctionBodyInput<'a> {
@@ -15,7 +14,7 @@ pub(crate) enum FunctionBodyInput<'a> {
 pub(crate) struct OwnedFunctionBody {
     // A deferred stream code section is copied once, then shared by all queued
     // function jobs from that section.
-    pub section_bytes: Arc<[u8]>,
+    pub section_bytes: Shared<[u8]>,
     pub body_range: Range<usize>,
     pub body_offset: u64,
 }

crates/parser/src/parallel.rs

@@ -88,6 +88,7 @@ name = "test-wasm-wide-arithmetic"
 [dependencies]
 libm = { version = "0.2", default-features = false }
 log = { workspace = true, optional = true }
+portable-atomic = { version = "1.15.0", default-features = false, optional = true }
 tinywasm-parser = { workspace = true, optional = true }
 tinywasm-types = { workspace = true }
 
@@ -111,6 +112,9 @@ default = [
 log = ["dep:log", "tinywasm-parser?/log", "tinywasm-types/log"]
 std = ["tinywasm-parser?/std", "tinywasm-types/std"]
 
+# make stores, instances, references, and host callbacks movable across threads
+send = []
+
 # support for parsing WebAssembly
 parser = ["dep:tinywasm-parser"]
 
@@ -120,6 +124,9 @@ validate = ["parser", "tinywasm-parser/validate"]
 # parallelize function parsing/validation across threads (requires std)
 parallel-parser = ["parser", "tinywasm-parser?/parallel"]
 
+# support targets without native atomic CAS
+portable-atomic = ["dep:portable-atomic", "tinywasm-parser?/portable-atomic", "tinywasm-types/portable-atomic"]
+
 # support for "archiving" tinywasm bytecode
 archive = ["tinywasm-types/archive"]
 

crates/tinywasm/Cargo.toml

@@ -1,10 +1,12 @@
-use alloc::sync::Arc;
+use alloc::boxed::Box;
 
 use crate::ResourceLimiter;
+use crate::shared::StoreShared;
 
 /// Global configuration for the WebAssembly interpreter
 ///
-/// Can be cheaply cloned and shared across multiple executions and threads.
+/// Can be cheaply cloned across stores. With the `send` feature, it can also be
+/// moved and shared across threads.
 ///
 /// ## Example
 /// ```rust
@@ -117,7 +119,7 @@ pub struct Config {
     /// Fuel accounting policy used by budgeted execution. Defaults to [`FuelPolicy::PerInstruction`].
     pub fuel_policy: FuelPolicy,
     /// Resource limiter shared across all stores created from this engine. Defaults to `None`.
-    pub resource_limiter: Option<Arc<dyn ResourceLimiter>>,
+    pub resource_limiter: Option<StoreShared<dyn ResourceLimiter>>,
     /// Initial number of GC heap bytes that triggers collection.
     /// Defaults to 1 MiB.
     pub gc_collection_threshold: usize,
@@ -168,8 +170,11 @@ impl Config {
     }
 
     /// Set the resource limiter shared across all stores created from this engine.
-    pub fn with_resource_limiter(mut self, limiter: Arc<dyn ResourceLimiter>) -> Self {
-        self.resource_limiter = Some(limiter);
+    ///
+    /// The limiter is converted to TinyWasm's internal shared pointer. Pass the
+    /// limiter value directly rather than wrapping it in `Rc` or `Arc`.
+    pub fn with_resource_limiter(mut self, limiter: impl ResourceLimiter + 'static) -> Self {
+        self.resource_limiter = Some(StoreShared::from(Box::new(limiter) as Box<dyn ResourceLimiter>));
         self
     }
 

crates/tinywasm/src/engine.rs

@@ -119,7 +119,8 @@ impl FuncContext<'_> {
         }
         func.func.item.validate_store(self.store)?;
         let func_instance = self.store.state.get_func(func.func.addr()).clone();
-        if matches!(&func_instance.kind, crate::store::FunctionKind::Host(host) if host.typed_callback().is_none()) {
+        if matches!(&func_instance.inner, crate::store::FunctionInstanceInner::Host(host) if host.typed_callback().is_none())
+        {
             let ty = self.store.state.get_canonical_func_type(func_instance.type_addr);
             let (param_count, result_count) = (ty.params().len(), ty.results().len());
             self.store.with_scratch_values(param_count + result_count, |store, values| {