chore: atomic module data

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

Author: explodingcamera

.gitignore

@@ -9,3 +9,4 @@ flamegraph.svg
 /.idea
 /*.iml
 profile.json
+profile.json.gz

crates/parser/src/module.rs

@@ -1,14 +1,15 @@
 use crate::log::debug;
 use crate::{ParseError, Result, conversion};
 use alloc::string::ToString;
-use alloc::{boxed::Box, format, vec::Vec};
+use alloc::sync::Arc;
+use alloc::{format, vec::Vec};
 use tinywasm_types::{
-    Data, Element, Export, FuncType, Global, Import, Instruction, MemoryType, TableType, TinyWasmModule, ValueCounts,
-    ValueCountsSmall, WasmFunction, WasmFunctionData,
+    ArcSlice, Data, Element, Export, FuncType, Global, Import, Instruction, MemoryType, TableType, TinyWasmModule,
+    ValueCounts, ValueCountsSmall, WasmFunction, WasmFunctionData,
 };
 use wasmparser::{FuncValidatorAllocations, Payload, Validator};
 
-pub(crate) type Code = (Box<[Instruction]>, WasmFunctionData, ValueCounts);
+pub(crate) type Code = (Arc<[Instruction]>, WasmFunctionData, ValueCounts);
 
 #[derive(Default)]
 pub(crate) struct ModuleReader {
@@ -195,25 +196,24 @@ impl ModuleReader {
             .map(|((instructions, data, locals), ty_idx)| {
                 let ty = self.func_types.get(ty_idx as usize).expect("No func type for func, this is a bug").clone();
                 let params = ValueCountsSmall::from(&ty.params);
-                WasmFunction { instructions, data, locals, params, ty }
+                WasmFunction { instructions: ArcSlice(instructions), data, locals, params, ty }
             })
-            .collect::<Vec<_>>()
-            .into_boxed_slice();
+            .collect::<Vec<_>>();
 
         let globals = self.globals;
         let table_types = self.table_types;
 
         Ok(TinyWasmModule {
-            funcs,
-            func_types: self.func_types.into_boxed_slice(),
-            globals: globals.into_boxed_slice(),
-            table_types: table_types.into_boxed_slice(),
-            imports: self.imports.into_boxed_slice(),
+            funcs: funcs.into(),
+            func_types: self.func_types.into(),
+            globals: globals.into(),
+            table_types: table_types.into(),
+            imports: self.imports.into(),
             start_func: self.start_func,
-            data: self.data.into_boxed_slice(),
-            exports: self.exports.into_boxed_slice(),
-            elements: self.elements.into_boxed_slice(),
-            memory_types: self.memory_types.into_boxed_slice(),
+            data: self.data.into(),
+            exports: self.exports.into(),
+            elements: self.elements.into(),
+            memory_types: self.memory_types.into(),
         })
     }
 }

crates/parser/src/visit.rs

@@ -2,7 +2,7 @@ use crate::Result;
 
 use crate::conversion::{convert_heaptype, convert_valtype};
 use alloc::string::ToString;
-use alloc::{boxed::Box, vec::Vec};
+use alloc::vec::Vec;
 use tinywasm_types::{Instruction, MemoryArg, WasmFunctionData};
 use wasmparser::{
     FuncValidator, FuncValidatorAllocations, FunctionBody, VisitOperator, VisitSimdOperator, WasmModuleResources,
@@ -37,7 +37,7 @@ pub(crate) fn process_operators_and_validate<R: WasmModuleResources>(
     validator: FuncValidator<R>,
     body: FunctionBody<'_>,
     local_addr_map: Vec<u32>,
-) -> Result<(Box<[Instruction]>, WasmFunctionData, FuncValidatorAllocations)> {
+) -> Result<(alloc::sync::Arc<[Instruction]>, WasmFunctionData, FuncValidatorAllocations)> {
     let mut reader = body.get_operators_reader()?;
     let remaining = reader.get_binary_reader().bytes_remaining();
     let mut builder = FunctionBuilder::new(remaining, validator, local_addr_map);
@@ -52,7 +52,7 @@ pub(crate) fn process_operators_and_validate<R: WasmModuleResources>(
     }
 
     Ok((
-        builder.instructions.into_boxed_slice(),
+        alloc::sync::Arc::from(builder.instructions),
         WasmFunctionData { v128_constants: builder.v128_constants.into_boxed_slice() },
         builder.validator.into_allocations(),
     ))

crates/tinywasm/src/func.rs

@@ -60,10 +60,10 @@ impl FuncHandle {
 
         // 7. Push the frame f to the call stack
         // & 8. Push the values to the stack (Not needed since the call frame owns the values)
-        store.stack.initialize(callframe);
+        store.stack.clear();
 
         // 9. Invoke the function instance
-        InterpreterRuntime::exec(store)?;
+        InterpreterRuntime::exec(store, callframe)?;
 
         // Once the function returns:
         // 1. Assert: m values are on the top of the stack (Ensured by validation)

crates/tinywasm/src/imports.rs

@@ -363,7 +363,7 @@ impl Imports {
     ) -> Result<ResolvedImports> {
         let mut imports = ResolvedImports::new();
 
-        for import in &module.0.imports {
+        for import in &*module.0.imports {
             let val = self.take(store, import).ok_or_else(|| LinkingError::unknown_import(import))?;
 
             match val {

crates/tinywasm/src/instance.rs

@@ -1,4 +1,5 @@
-use alloc::{boxed::Box, format, rc::Rc};
+use alloc::boxed::Box;
+use alloc::{format, rc::Rc};
 use tinywasm_types::*;
 
 use crate::func::{FromWasmValueTuple, IntoWasmValueTuple};
@@ -20,7 +21,7 @@ pub(crate) struct ModuleInstanceInner {
     pub(crate) store_id: usize,
     pub(crate) idx: ModuleInstanceAddr,
 
-    pub(crate) types: Box<[FuncType]>,
+    pub(crate) types: ArcSlice<FuncType>,
 
     pub(crate) func_addrs: Box<[FuncAddr]>,
     pub(crate) table_addrs: Box<[TableAddr]>,
@@ -30,8 +31,8 @@ pub(crate) struct ModuleInstanceInner {
     pub(crate) data_addrs: Box<[DataAddr]>,
 
     pub(crate) func_start: Option<FuncAddr>,
-    pub(crate) imports: Box<[Import]>,
-    pub(crate) exports: Box<[Export]>,
+    pub(crate) imports: ArcSlice<Import>,
+    pub(crate) exports: ArcSlice<Export>,
 }
 
 impl ModuleInstance {
@@ -65,29 +66,29 @@ impl ModuleInstance {
         let idx = store.next_module_instance_idx();
         let mut addrs = imports.unwrap_or_default().link(store, &module, idx)?;
 
-        addrs.funcs.extend(store.init_funcs(module.0.funcs.into(), idx)?);
-        addrs.tables.extend(store.init_tables(module.0.table_types.into(), idx)?);
-        addrs.memories.extend(store.init_memories(module.0.memory_types.into(), idx)?);
+        addrs.funcs.extend(store.init_funcs(&module.0.funcs, idx)?);
+        addrs.tables.extend(store.init_tables(&module.0.table_types, idx)?);
+        addrs.memories.extend(store.init_memories(&module.0.memory_types, idx)?);
 
-        let global_addrs = store.init_globals(addrs.globals, module.0.globals.into(), &addrs.funcs, idx)?;
+        let global_addrs = store.init_globals(addrs.globals, &module.0.globals, &addrs.funcs, idx)?;
         let (elem_addrs, elem_trapped) =
             store.init_elements(&addrs.tables, &addrs.funcs, &global_addrs, &module.0.elements, idx)?;
-        let (data_addrs, data_trapped) = store.init_data(&addrs.memories, module.0.data.into(), idx)?;
+        let (data_addrs, data_trapped) = store.init_data(&addrs.memories, &module.0.data, idx)?;
 
         let instance = ModuleInstanceInner {
             failed_to_instantiate: elem_trapped.is_some() || data_trapped.is_some(),
             store_id: store.id(),
             idx,
-            types: module.0.func_types,
+            types: module.0.func_types.clone(),
             func_addrs: addrs.funcs.into_boxed_slice(),
             table_addrs: addrs.tables.into_boxed_slice(),
             mem_addrs: addrs.memories.into_boxed_slice(),
             global_addrs: global_addrs.into_boxed_slice(),
             elem_addrs,
             data_addrs,
             func_start: module.0.start_func,
-            imports: module.0.imports,
-            exports: module.0.exports,
+            imports: module.0.imports.clone(),
+            exports: module.0.exports.clone(),
         };
 
         let instance = Self::new(instance);

crates/tinywasm/src/interpreter/executor.rs

@@ -22,10 +22,9 @@ pub(crate) struct Executor<'store> {
 }
 
 impl<'store> Executor<'store> {
-    pub(crate) fn new(store: &'store mut Store) -> Result<Self> {
-        let current_frame = store.stack.call_stack.pop().expect("no call frame, this is a bug");
-        let current_module = store.get_module_instance_raw(current_frame.module_addr());
-        Ok(Self { cf: current_frame, module: current_module, store })
+    pub(crate) fn new(store: &'store mut Store, cf: CallFrame) -> Result<Self> {
+        let module = store.get_module_instance_raw(cf.module_addr());
+        Ok(Self { module, store, cf })
     }
 
     pub(crate) fn run_to_completion(&mut self) -> Result<()> {
@@ -104,22 +103,22 @@ impl<'store> Executor<'store> {
             BrTable(default, len) => return self.exec_brtable(*default, *len),
             Return => return self.exec_return(),
             EndBlockFrame => self.exec_end_block(),
-            LocalGet32(local_index) => self.exec_local_get::<Value32>(*local_index),
-            LocalGet64(local_index) => self.exec_local_get::<Value64>(*local_index),
-            LocalGet128(local_index) => self.exec_local_get::<Value128>(*local_index),
-            LocalGetRef(local_index) => self.exec_local_get::<ValueRef>(*local_index),
-            LocalSet32(local_index) => self.exec_local_set::<Value32>(*local_index),
-            LocalSet64(local_index) => self.exec_local_set::<Value64>(*local_index),
-            LocalSet128(local_index) => self.exec_local_set::<Value128>(*local_index),
-            LocalSetRef(local_index) => self.exec_local_set::<ValueRef>(*local_index),
-            LocalCopy32(from, to) => self.exec_local_copy::<Value32>(*from, *to),
-            LocalCopy64(from, to) => self.exec_local_copy::<Value64>(*from, *to),
-            LocalCopy128(from, to) => self.exec_local_copy::<Value128>(*from, *to),
-            LocalCopyRef(from, to) => self.exec_local_copy::<ValueRef>(*from, *to),
-            LocalTee32(local_index) => self.exec_local_tee::<Value32>(*local_index),
-            LocalTee64(local_index) => self.exec_local_tee::<Value64>(*local_index),
-            LocalTee128(local_index) => self.exec_local_tee::<Value128>(*local_index),
-            LocalTeeRef(local_index) => self.exec_local_tee::<ValueRef>(*local_index),
+            LocalGet32(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value32>(*local_index)),
+            LocalGet64(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value64>(*local_index)),
+            LocalGet128(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value128>(*local_index)),
+            LocalGetRef(local_index) => self.store.stack.values.push(self.cf.locals.get::<ValueRef>(*local_index)),
+            LocalSet32(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value32>()),
+            LocalSet64(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value64>()),
+            LocalSet128(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value128>()),
+            LocalSetRef(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<ValueRef>()),
+            LocalCopy32(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value32>(*from)),
+            LocalCopy64(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value64>(*from)),
+            LocalCopy128(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value128>(*from)),
+            LocalCopyRef(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<ValueRef>(*from)),
+            LocalTee32(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value32>()),
+            LocalTee64(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value64>()),
+            LocalTee128(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value128>()),
+            LocalTeeRef(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<ValueRef>()),
             GlobalGet(global_index) => self.exec_global_get(*global_index),
             GlobalSet32(global_index) => self.exec_global_set::<Value32>(*global_index),
             GlobalSet64(global_index) => self.exec_global_set::<Value64>(*global_index),
@@ -567,11 +566,11 @@ impl<'store> Executor<'store> {
         wasm_func: Rc<WasmFunction>,
         owner: ModuleInstanceAddr,
     ) -> ControlFlow<Option<Error>> {
-        let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
-
         if IS_RETURN_CALL {
+            let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
             self.cf.reuse_for(wasm_func, locals, self.store.stack.blocks.len() as u32, owner);
         } else {
+            let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
             let new_call_frame = CallFrame::new_raw(wasm_func, owner, locals, self.store.stack.blocks.len() as u32);
             self.cf.incr_instr_ptr(); // skip the call instruction
             self.store.stack.call_stack.push(core::mem::replace(&mut self.cf, new_call_frame))?;
@@ -580,7 +579,7 @@ impl<'store> Executor<'store> {
         self.module.swap_with(self.cf.module_addr(), self.store);
         ControlFlow::Continue(())
     }
-    fn exec_call_host(&mut self, host_func: &Rc<imports::HostFunction>) -> ControlFlow<Option<Error>> {
+    fn exec_call_host(&mut self, host_func: Rc<imports::HostFunction>) -> ControlFlow<Option<Error>> {
         let params = self.store.stack.values.pop_types(&host_func.ty.params).collect::<Box<_>>();
         let res = host_func.call(FuncContext { store: self.store, module_addr: self.module.id() }, &params).to_cf()?;
         self.store.stack.values.extend_from_wasmvalues(&res);
@@ -589,9 +588,9 @@ impl<'store> Executor<'store> {
     }
     fn exec_call_direct<const IS_RETURN_CALL: bool>(&mut self, v: u32) -> ControlFlow<Option<Error>> {
         let func_inst = self.store.state.get_func(self.module.resolve_func_addr(v));
-        match func_inst.func.clone() {
-            crate::Function::Wasm(wasm_func) => self.exec_call::<IS_RETURN_CALL>(wasm_func, func_inst.owner),
-            crate::Function::Host(host_func) => self.exec_call_host(&host_func),
+        match &func_inst.func {
+            crate::Function::Wasm(wasm_func) => self.exec_call::<IS_RETURN_CALL>(wasm_func.clone(), func_inst.owner),
+            crate::Function::Host(host_func) => self.exec_call_host(host_func.clone()),
         }
     }
     fn exec_call_indirect<const IS_RETURN_CALL: bool>(
@@ -612,26 +611,26 @@ impl<'store> Executor<'store> {
         let func_inst = self.store.state.get_func(func_ref);
         let call_ty = self.module.func_ty(type_addr);
 
-        match func_inst.func.clone() {
+        match &func_inst.func {
             crate::Function::Wasm(wasm_func) => {
-                if unlikely(wasm_func.ty != *call_ty) {
+                if wasm_func.ty != *call_ty {
                     return ControlFlow::Break(Some(
                         Trap::IndirectCallTypeMismatch { actual: wasm_func.ty.clone(), expected: call_ty.clone() }
                             .into(),
                     ));
                 }
 
-                self.exec_call::<IS_RETURN_CALL>(wasm_func, func_inst.owner)
+                self.exec_call::<IS_RETURN_CALL>(wasm_func.clone(), func_inst.owner)
             }
             crate::Function::Host(host_func) => {
-                if unlikely(host_func.ty != *call_ty) {
+                if host_func.ty != *call_ty {
                     return ControlFlow::Break(Some(
                         Trap::IndirectCallTypeMismatch { actual: host_func.ty.clone(), expected: call_ty.clone() }
                             .into(),
                     ));
                 }
 
-                self.exec_call_host(&host_func)
+                self.exec_call_host(host_func.clone())
             }
         }
     }
@@ -645,24 +644,24 @@ impl<'store> Executor<'store> {
 
         // falsy value is on the top of the stack
         if else_offset == 0 {
-            self.cf.jump(end_offset as usize);
+            self.cf.jump(end_offset);
             return;
         }
 
-        self.cf.jump(else_offset as usize);
+        self.cf.jump(else_offset);
         self.enter_block(end_offset - else_offset, BlockType::Else, (params, results));
     }
     fn exec_else(&mut self, end_offset: u32) {
         self.exec_end_block();
-        self.cf.jump(end_offset as usize);
+        self.cf.jump(end_offset);
     }
     fn resolve_functype(&self, idx: u32) -> (StackHeight, StackHeight) {
         let ty = self.module.func_ty(idx);
         ((&*ty.params).into(), (&*ty.results).into())
     }
     fn enter_block(&mut self, end_instr_offset: u32, ty: BlockType, (params, results): (StackHeight, StackHeight)) {
         self.store.stack.blocks.push(BlockFrame {
-            instr_ptr: self.cf.instr_ptr(),
+            instr_ptr: self.cf.instr_ptr() as u32,
             end_instr_offset,
             stack_ptr: self.store.stack.values.height(),
             results,
@@ -730,18 +729,6 @@ impl<'store> Executor<'store> {
         let block = self.store.stack.blocks.pop();
         self.store.stack.values.truncate_keep(block.stack_ptr, block.results);
     }
-    fn exec_local_get<T: InternalValue>(&mut self, local_index: u16) {
-        let v = self.cf.locals.get::<T>(local_index);
-        self.store.stack.values.push(v);
-    }
-    fn exec_local_set<T: InternalValue>(&mut self, local_index: u16) {
-        let v = self.store.stack.values.pop::<T>();
-        self.cf.locals.set(local_index, v);
-    }
-    fn exec_local_tee<T: InternalValue>(&mut self, local_index: u16) {
-        let v = self.store.stack.values.peek::<T>();
-        self.cf.locals.set(local_index, v);
-    }
 
     fn exec_global_get(&mut self, global_index: u32) {
         self.store
@@ -830,7 +817,7 @@ impl<'store> Executor<'store> {
 
         let data_len = data.data.as_ref().map_or(0, |d| d.len());
 
-        if unlikely(((size + offset) as usize > data_len) || ((dst + size) as usize > mem.len())) {
+        if ((size + offset) as usize > data_len) || ((dst + size) as usize > mem.len()) {
             return Err(Trap::MemoryOutOfBounds { offset: offset as usize, len: size as usize, max: data_len }.into());
         }
 
@@ -999,7 +986,7 @@ impl<'store> Executor<'store> {
         let elem_len = elem.items.as_ref().map_or(0, alloc::vec::Vec::len);
         let table_len = table.size();
 
-        if unlikely(size < 0 || ((size + offset) as usize > elem_len) || ((dst + size) > table_len)) {
+        if size < 0 || ((size + offset) as usize > elem_len) || ((dst + size) > table_len) {
             return Err(Trap::TableOutOfBounds { offset: offset as usize, len: size as usize, max: elem_len }.into());
         }
 
@@ -1038,7 +1025,7 @@ impl<'store> Executor<'store> {
         let val = self.store.stack.values.pop::<ValueRef>();
         let i = self.store.stack.values.pop::<i32>();
 
-        if unlikely(i + n > table.size()) {
+        if i + n > table.size() {
             return Err(Error::Trap(Trap::TableOutOfBounds {
                 offset: i as usize,
                 len: n as usize,
@@ -1052,9 +1039,4 @@ impl<'store> Executor<'store> {
 
         table.fill(self.module.func_addrs(), i as usize, n as usize, val.into())
     }
-
-    fn exec_local_copy<T: InternalValue>(&mut self, from: u16, to: u16) {
-        let v = self.cf.locals.get::<T>(from);
-        self.cf.locals.set(to, v);
-    }
 }