chore: simplify interpreter::exec

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

Author: explodingcamera

benches/fibonacci.rs

@@ -30,7 +30,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let mut group = c.benchmark_group("fibonacci");
     group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(module.clone())));
-    // group.bench_function("wasmi", |b| b.iter(|| run_wasmi()));
+    group.bench_function("wasmi", |b| b.iter(|| run_wasmi()));
 }
 
 criterion_group!(

crates/tinywasm/src/func.rs

@@ -1,17 +1,17 @@
-use crate::{log, runtime::RawWasmValue};
+use crate::{log, runtime::RawWasmValue, unlikely, Function};
 use alloc::{boxed::Box, format, string::String, string::ToString, vec, vec::Vec};
-use tinywasm_types::{FuncAddr, FuncType, ValType, WasmValue};
+use tinywasm_types::{FuncType, ModuleInstanceAddr, ValType, WasmValue};
 
 use crate::{
     runtime::{CallFrame, Stack},
-    Error, FuncContext, ModuleInstance, Result, Store,
+    Error, FuncContext, Result, Store,
 };
 
 #[derive(Debug)]
 /// A function handle
 pub struct FuncHandle {
-    pub(crate) module: ModuleInstance,
-    pub(crate) addr: FuncAddr,
+    pub(crate) module_addr: ModuleInstanceAddr,
+    pub(crate) addr: u32,
     pub(crate) ty: FuncType,
 
     /// The name of the function, if it has one
@@ -22,18 +22,13 @@ impl FuncHandle {
     /// Call a function (Invocation)
     ///
     /// See <https://webassembly.github.io/spec/core/exec/modules.html#invocation>
+    #[inline]
     pub fn call(&self, store: &mut Store, params: &[WasmValue]) -> Result<Vec<WasmValue>> {
-        let mut stack = Stack::default();
-
-        // 1. Assert: funcs[func_addr] exists
-        // 2. let func_inst be the functiuon instance funcs[func_addr]
-        let func_inst = store.get_func(self.addr as usize)?.clone();
-
         // 3. Let func_ty be the function type
         let func_ty = &self.ty;
 
         // 4. If the length of the provided argument values is different from the number of expected arguments, then fail
-        if func_ty.params.len() != params.len() {
+        if unlikely(func_ty.params.len() != params.len()) {
             log::info!("func_ty.params: {:?}", func_ty.params);
             return Err(Error::Other(format!(
                 "param count mismatch: expected {}, got {}",
@@ -43,31 +38,34 @@ impl FuncHandle {
         }
 
         // 5. For each value type and the corresponding value, check if types match
-        for (i, (ty, param)) in func_ty.params.iter().zip(params).enumerate() {
+        if !unlikely(func_ty.params.iter().zip(params).enumerate().all(|(i, (ty, param))| {
             if ty != &param.val_type() {
-                return Err(Error::Other(format!(
-                    "param type mismatch at index {}: expected {:?}, got {:?}",
-                    i, ty, param
-                )));
+                log::error!("param type mismatch at index {}: expected {:?}, got {:?}", i, ty, param);
+                false
+            } else {
+                true
             }
+        })) {
+            return Err(Error::Other("Type mismatch".into()));
         }
 
-        let locals = match &func_inst.func {
-            crate::Function::Host(h) => {
-                let func = h.func.clone();
-                let ctx = FuncContext { store, module: &self.module };
+        let func_inst = store.get_func(self.addr as usize)?;
+        let wasm_func = match &func_inst.func {
+            Function::Host(host_func) => {
+                let func = &host_func.clone().func;
+                let ctx = FuncContext { store, module_addr: self.module_addr };
                 return (func)(ctx, params);
             }
-            crate::Function::Wasm(ref f) => f.locals.to_vec(),
+            Function::Wasm(wasm_func) => wasm_func,
         };
 
         // 6. Let f be the dummy frame
-        log::debug!("locals: {:?}", locals);
-        let call_frame = CallFrame::new(func_inst, params.iter().map(|v| RawWasmValue::from(*v)), locals);
+        let call_frame =
+            CallFrame::new(wasm_func.clone(), func_inst.owner, params.iter().map(|v| RawWasmValue::from(*v)));
 
         // 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)
-        stack.call_stack.push(call_frame)?;
+        let mut stack = Stack::new(call_frame);
 
         // 9. Invoke the function instance
         let runtime = store.runtime();
@@ -125,6 +123,7 @@ macro_rules! impl_into_wasm_value_tuple {
             $($T: Into<WasmValue>),*
         {
             #[allow(non_snake_case)]
+            #[inline]
             fn into_wasm_value_tuple(self) -> Vec<WasmValue> {
                 let ($($T,)*) = self;
                 vec![$($T.into(),)*]
@@ -136,6 +135,7 @@ macro_rules! impl_into_wasm_value_tuple {
 macro_rules! impl_into_wasm_value_tuple_single {
     ($T:ident) => {
         impl IntoWasmValueTuple for $T {
+            #[inline]
             fn into_wasm_value_tuple(self) -> Vec<WasmValue> {
                 vec![self.into()]
             }
@@ -164,6 +164,7 @@ macro_rules! impl_from_wasm_value_tuple {
         where
             $($T: TryFrom<WasmValue, Error = ()>),*
         {
+            #[inline]
             fn from_wasm_value_tuple(values: &[WasmValue]) -> Result<Self> {
                 #[allow(unused_variables, unused_mut)]
                 let mut iter = values.iter();
@@ -186,6 +187,7 @@ macro_rules! impl_from_wasm_value_tuple {
 macro_rules! impl_from_wasm_value_tuple_single {
     ($T:ident) => {
         impl FromWasmValueTuple for $T {
+            #[inline]
             fn from_wasm_value_tuple(values: &[WasmValue]) -> Result<Self> {
                 #[allow(unused_variables, unused_mut)]
                 let mut iter = values.iter();
@@ -254,6 +256,7 @@ macro_rules! impl_val_types_from_tuple {
         where
             $($t: ToValType,)+
         {
+            #[inline]
             fn val_types() -> Box<[ValType]> {
                 Box::new([$($t::to_val_type(),)+])
             }
@@ -262,6 +265,7 @@ macro_rules! impl_val_types_from_tuple {
 }
 
 impl ValTypesFromTuple for () {
+    #[inline]
     fn val_types() -> Box<[ValType]> {
         Box::new([])
     }
@@ -271,6 +275,7 @@ impl<T1> ValTypesFromTuple for T1
 where
     T1: ToValType,
 {
+    #[inline]
     fn val_types() -> Box<[ValType]> {
         Box::new([T1::to_val_type()])
     }

crates/tinywasm/src/imports.rs

@@ -7,6 +7,7 @@ use crate::{
     log, LinkingError, Result,
 };
 use alloc::{
+    boxed::Box,
     collections::BTreeMap,
     rc::Rc,
     string::{String, ToString},
@@ -18,10 +19,10 @@ use tinywasm_types::*;
 #[derive(Debug, Clone)]
 pub enum Function {
     /// A host function
-    Host(HostFunction),
+    Host(Rc<HostFunction>),
 
     /// A function defined in WebAssembly
-    Wasm(WasmFunction),
+    Wasm(Rc<WasmFunction>),
 }
 
 impl Function {
@@ -34,7 +35,6 @@ impl Function {
 }
 
 /// A host function
-#[derive(Clone)]
 pub struct HostFunction {
     pub(crate) ty: tinywasm_types::FuncType,
     pub(crate) func: HostFuncInner,
@@ -52,13 +52,13 @@ impl HostFunction {
     }
 }
 
-pub(crate) type HostFuncInner = Rc<dyn Fn(FuncContext<'_>, &[WasmValue]) -> Result<Vec<WasmValue>>>;
+pub(crate) type HostFuncInner = Box<dyn Fn(FuncContext<'_>, &[WasmValue]) -> Result<Vec<WasmValue>>>;
 
 /// The context of a host-function call
 #[derive(Debug)]
 pub struct FuncContext<'a> {
     pub(crate) store: &'a mut crate::Store,
-    pub(crate) module: &'a crate::ModuleInstance,
+    pub(crate) module_addr: ModuleInstanceAddr,
 }
 
 impl FuncContext<'_> {
@@ -73,13 +73,13 @@ impl FuncContext<'_> {
     }
 
     /// Get a reference to the module instance
-    pub fn module(&self) -> &crate::ModuleInstance {
-        self.module
+    pub fn module(&self) -> crate::ModuleInstance {
+        self.store.get_module_instance_raw(self.module_addr)
     }
 
     /// Get a reference to an exported memory
     pub fn memory(&mut self, name: &str) -> Result<crate::MemoryRef> {
-        self.module.exported_memory(self.store, name)
+        self.module().exported_memory(self.store, name)
     }
 }
 
@@ -140,7 +140,7 @@ impl Extern {
         ty: &tinywasm_types::FuncType,
         func: impl Fn(FuncContext<'_>, &[WasmValue]) -> Result<Vec<WasmValue>> + 'static,
     ) -> Self {
-        Self::Function(Function::Host(HostFunction { func: Rc::new(func), ty: ty.clone() }))
+        Self::Function(Function::Host(Rc::new(HostFunction { func: Box::new(func), ty: ty.clone() })))
     }
 
     /// Create a new typed function import
@@ -159,7 +159,7 @@ impl Extern {
 
         let ty = tinywasm_types::FuncType { params: P::val_types(), results: R::val_types() };
 
-        Self::Function(Function::Host(HostFunction { func: Rc::new(inner_func), ty }))
+        Self::Function(Function::Host(Rc::new(HostFunction { func: Box::new(inner_func), ty })))
     }
 
     pub(crate) fn kind(&self) -> ExternalKind {

crates/tinywasm/src/instance.rs

@@ -42,6 +42,10 @@ impl ModuleInstance {
         self.0 = other.0;
     }
 
+    pub(crate) fn swap_with(&mut self, other_addr: ModuleInstanceAddr, store: &mut Store) {
+        self.swap(store.get_module_instance_raw(other_addr))
+    }
+
     /// Get the module instance's address
     pub fn id(&self) -> ModuleInstanceAddr {
         self.0.idx
@@ -172,7 +176,7 @@ impl ModuleInstance {
         let func_inst = store.get_func(func_addr as usize)?;
         let ty = func_inst.func.ty();
 
-        Ok(FuncHandle { addr: func_addr, module: self.clone(), name: Some(name.to_string()), ty: ty.clone() })
+        Ok(FuncHandle { addr: func_addr, module_addr: self.id(), name: Some(name.to_string()), ty: ty.clone() })
     }
 
     /// Get a typed exported function by name
@@ -230,7 +234,7 @@ impl ModuleInstance {
         let func_inst = store.get_func(*func_addr as usize)?;
         let ty = func_inst.func.ty();
 
-        Ok(Some(FuncHandle { module: self.clone(), addr: *func_addr, ty: ty.clone(), name: None }))
+        Ok(Some(FuncHandle { module_addr: self.id(), addr: *func_addr, ty: ty.clone(), name: None }))
     }
 
     /// Invoke the start function of the module