refactor: incorporate user_data into Config

Signed-off-by: Cem Onem <cem.oenem@dlr.de>

Author: cemonem

src/execution/config.rs

@@ -1,8 +1,10 @@
-/// Trait that allows user specified configuration for various items during interpretation
+/// Trait that allows user specified configuration for various items during interpretation. Additionally, the types
+/// implementing this trait can act as custom user data within an interpreter instance, passed along to each method of
+/// this trait and host functions whenever they are invoked.
 ///
 /// The default implementation of all trait methods have the least overhead, i. e. most can be optimized out fully.
 // It must always be checked that there is no additional performance penalty for the default config!
-pub trait Config: Default {
+pub trait Config {
     /// A hook which is called before every wasm instruction
     ///
     /// This allows the most intricate insight into the interpreters behavior, at the cost of a
@@ -12,7 +14,4 @@ pub trait Config: Default {
 }
 
 /// Default implementation of the interpreter configuration, with all hooks empty
-#[derive(Default, Debug)]
-pub struct DefaultConfig;
-
-impl Config for DefaultConfig {}
+impl Config for () {}

src/execution/const_interpreter_loop.rs

@@ -1,5 +1,6 @@
 use crate::{
     assert_validated::UnwrapValidatedExt,
+    config::Config,
     core::{
         indices::GlobalIdx,
         reader::{span::Span, WasmReadable, WasmReader},
@@ -21,7 +22,7 @@ use crate::{
 /// This function assumes that the expression has been validated. Passing unvalidated code will likely result in a
 /// panic, or undefined behaviour.
 // TODO this signature might change to support hooks or match the spec better
-pub(crate) fn run_const<T>(
+pub(crate) fn run_const<T: Config>(
     wasm: &mut WasmReader,
     stack: &mut Stack,
     module: &ModuleInst,
@@ -118,7 +119,7 @@ pub(crate) fn run_const<T>(
     Ok(())
 }
 
-pub(crate) fn run_const_span<T>(
+pub(crate) fn run_const_span<T: Config>(
     wasm: &[u8],
     span: &Span,
     module: &ModuleInst,

src/execution/function_ref.rs

@@ -9,7 +9,7 @@ pub struct FunctionRef {
 }
 
 impl FunctionRef {
-    pub fn new_from_name<T>(
+    pub fn new_from_name<T: Config>(
         module_name: &str,
         function_name: &str,
         store: &Store<T>,
@@ -31,11 +31,7 @@ impl FunctionRef {
         }
     }
 
-    pub fn invoke_typed<
-        C: Config + core::fmt::Debug,
-        Param: InteropValueList,
-        Returns: InteropValueList,
-    >(
+    pub fn invoke_typed<C: Config, Param: InteropValueList, Returns: InteropValueList>(
         &self,
         runtime: &mut RuntimeInstance<C>,
         params: Param,
@@ -44,9 +40,9 @@ impl FunctionRef {
         runtime.invoke_typed(self, params /* , store */)
     }
 
-    pub fn invoke<T, C: Config + core::fmt::Debug>(
+    pub fn invoke<C: Config>(
         &self,
-        runtime: &mut RuntimeInstance<T, C>,
+        runtime: &mut RuntimeInstance<C>,
         params: Vec<Value>,
         // store: &mut Store,
     ) -> Result<Vec<Value>, RuntimeError> {

src/execution/interpreter_loop.rs

@@ -43,10 +43,9 @@ use super::{little_endian::LittleEndianBytes, store::Store};
 /// Returns `Ok(None)` in case execution successfully terminates, `Ok(Some(required_fuel))` if execution
 /// terminates due to insufficient fuel, indicating how much fuel is required to resume with `required_fuel`,
 /// and `[Error::RuntimeError]` otherwise.
-pub(super) fn run<T, C: Config>(
+pub(super) fn run<T: Config>(
     resumable: &mut Resumable,
     store: &mut Store<T>,
-    mut config: C,
 ) -> Result<Option<NonZeroU32>, RuntimeError> {
     let stack = &mut resumable.stack;
     let mut current_func_addr = resumable.current_func_addr;
@@ -74,7 +73,9 @@ pub(super) fn run<T, C: Config>(
     use crate::core::reader::types::opcode::*;
     loop {
         // call the instruction hook
-        config.instruction_hook(store.modules[current_module_idx].wasm_bytecode, wasm.pc);
+        store
+            .user_data
+            .instruction_hook(store.modules[current_module_idx].wasm_bytecode, wasm.pc);
 
         // Fuel mechanism: 1 fuel per instruction
         if let Some(fuel) = &mut resumable.maybe_fuel {

src/execution/mod.rs

@@ -8,7 +8,7 @@ use value_stack::Stack;
 
 use crate::core::reader::types::{FuncType, ResultType};
 use crate::execution::assert_validated::UnwrapValidatedExt;
-use crate::execution::config::{Config, DefaultConfig};
+use crate::execution::config::Config;
 use crate::execution::store::Store;
 use crate::execution::value::Value;
 use crate::interop::InteropValueList;
@@ -32,50 +32,46 @@ pub mod value_stack;
 /// The default module name if a [RuntimeInstance] was created using [RuntimeInstance::new].
 pub const DEFAULT_MODULE: &str = "__interpreter_default__";
 
-pub struct RuntimeInstance<'b, T = (), C = DefaultConfig>
+pub struct RuntimeInstance<'b, C = ()>
 where
-    C: Config + core::fmt::Debug,
+    C: Config,
 {
-    pub config: C,
-    pub store: Store<'b, T>,
+    pub store: Store<'b, C>,
 }
 
-impl<T: Default> Default for RuntimeInstance<'_, T, DefaultConfig> {
+impl Default for RuntimeInstance<'_, ()> {
     fn default() -> Self {
-        Self::new(T::default())
+        Self::new(())
     }
 }
 
-impl<'b, T> RuntimeInstance<'b, T, DefaultConfig> {
-    pub fn new(user_data: T) -> Self {
-        Self::new_with_config(user_data, DefaultConfig)
+impl<'b, C: Config> RuntimeInstance<'b, C> {
+    pub fn new(config: C) -> Self {
+        RuntimeInstance {
+            store: Store::new(config),
+        }
     }
 
     pub fn new_with_default_module(
-        user_data: T,
+        config: C,
         validation_info: &'_ ValidationInfo<'b>,
     ) -> Result<Self, RuntimeError> {
-        let mut instance = Self::new_with_config(user_data, DefaultConfig);
+        let mut instance = Self::new(config);
         instance.add_module(DEFAULT_MODULE, validation_info)?;
         Ok(instance)
     }
 
     pub fn new_named(
-        user_data: T,
+        config: C,
         module_name: &str,
         validation_info: &'_ ValidationInfo<'b>,
         // store: &mut Store,
     ) -> Result<Self, RuntimeError> {
-        let mut instance = Self::new_with_config(user_data, DefaultConfig);
+        let mut instance = Self::new(config);
         instance.add_module(module_name, validation_info)?;
         Ok(instance)
     }
-}
 
-impl<'b, T, C> RuntimeInstance<'b, T, C>
-where
-    C: Config + core::fmt::Debug,
-{
     pub fn add_module(
         &mut self,
         module_name: &str,
@@ -84,13 +80,6 @@ where
         self.store.add_module(module_name, validation_info, None)
     }
 
-    pub fn new_with_config(user_data: T, config: C) -> Self {
-        RuntimeInstance {
-            config,
-            store: Store::new(user_data),
-        }
-    }
-
     pub fn get_function_by_name(
         &self,
         module_name: &str,
@@ -196,7 +185,7 @@ where
         &mut self,
         module_name: &str,
         name: &str,
-        host_func: fn(&mut T, Vec<Value>) -> Vec<Value>,
+        host_func: fn(&mut C, Vec<Value>) -> Vec<Value>,
     ) -> Result<FunctionRef, RuntimeError> {
         let host_func_ty = FuncType {
             params: ResultType {
@@ -214,7 +203,7 @@ where
         module_name: &str,
         name: &str,
         host_func_ty: FuncType,
-        host_func: fn(&mut T, Vec<Value>) -> Vec<Value>,
+        host_func: fn(&mut C, Vec<Value>) -> Vec<Value>,
     ) -> Result<FunctionRef, RuntimeError> {
         let func_addr = self.store.alloc_host_func(host_func_ty, host_func);
         self.store.registry.register(
@@ -225,11 +214,11 @@ where
         Ok(FunctionRef { func_addr })
     }
 
-    pub fn user_data(&self) -> &T {
+    pub fn config(&self) -> &C {
         &self.store.user_data
     }
 
-    pub fn user_data_mut(&mut self) -> &mut T {
+    pub fn config_mut(&mut self) -> &mut C {
         &mut self.store.user_data
     }
 }

src/execution/store.rs

@@ -1,5 +1,6 @@
 use core::mem;
 
+use crate::config::Config;
 use crate::core::indices::TypeIdx;
 use crate::core::reader::span::Span;
 use crate::core::reader::types::data::{DataModeActive, DataSegment};
@@ -28,7 +29,6 @@ use alloc::sync::Arc;
 use alloc::vec;
 use alloc::vec::Vec;
 
-use super::config::DefaultConfig;
 use super::interpreter_loop::{data_drop, elem_drop};
 use super::UnwrapValidatedExt;
 
@@ -39,7 +39,7 @@ use crate::linear_memory::LinearMemory;
 /// globals, element segments, and data segments that have been allocated during the life time of
 /// the abstract machine.
 /// <https://webassembly.github.io/spec/core/exec/runtime.html#store>
-pub struct Store<'b, T> {
+pub struct Store<'b, T: Config> {
     pub functions: Vec<FuncInst<T>>,
     pub memories: Vec<MemInst>,
     pub globals: Vec<GlobalInst>,
@@ -59,7 +59,7 @@ pub struct Store<'b, T> {
     pub(crate) dormitory: Dormitory,
 }
 
-impl<'b, T> Store<'b, T> {
+impl<'b, T: Config> Store<'b, T> {
     /// Creates a new empty store with some user data
     pub fn new(user_data: T) -> Self {
         Self {
@@ -622,7 +622,7 @@ impl<'b, T> Store<'b, T> {
                         };
 
                         // Run the interpreter
-                        let result = interpreter_loop::run(&mut resumable, self, DefaultConfig)?;
+                        let result = interpreter_loop::run(&mut resumable, self)?;
 
                         match result {
                             None => {
@@ -666,7 +666,7 @@ impl<'b, T> Store<'b, T> {
                     .expect("the key to always be valid as self was not dropped yet");
 
                 // Resume execution
-                let result = interpreter_loop::run(resumable, self, DefaultConfig)?;
+                let result = interpreter_loop::run(resumable, self)?;
 
                 match result {
                     None => {
@@ -918,7 +918,7 @@ impl ExternVal {
     ///
     /// Note: This method may panic if self does not come from the given [`Store`].
     ///<https://webassembly.github.io/spec/core/valid/modules.html#imports>
-    pub fn extern_type<T>(&self, store: &Store<T>) -> ExternType {
+    pub fn extern_type<T: Config>(&self, store: &Store<T>) -> ExternType {
         match self {
             // TODO: fix ugly clone in function types
             ExternVal::Func(func_addr) => ExternType::Func(

tests/user_data.rs

@@ -1,16 +1,20 @@
 use std::sync::mpsc::Sender;
 
-use wasm::{RuntimeInstance, Value};
+use wasm::{config::Config, RuntimeInstance, Value};
 
 #[test_log::test]
 fn counter() {
-    fn add_one(user_data: &mut u32, _params: Vec<Value>) -> Vec<Value> {
-        *user_data += 1;
+    #[derive(Debug, PartialEq)]
+    struct MyU32(pub u32);
+    impl Config for MyU32 {}
+
+    fn add_one(user_data: &mut MyU32, _params: Vec<Value>) -> Vec<Value> {
+        user_data.0 += 1;
 
         Vec::new()
     }
 
-    let mut instance = RuntimeInstance::new(0);
+    let mut instance = RuntimeInstance::new(MyU32(0));
     instance
         .add_host_function_typed::<(), ()>("host", "add_one", add_one)
         .unwrap();
@@ -23,23 +27,27 @@ fn counter() {
             .unwrap();
     }
 
-    assert_eq!(*instance.user_data(), 5);
+    assert_eq!(*instance.config(), MyU32(5));
 }
 
 #[test_log::test]
 fn channels() {
+    struct MySender(pub Sender<String>);
+    impl Config for MySender {}
+
     let (tx, rx) = std::sync::mpsc::channel::<String>();
 
     std::thread::spawn(|| {
-        fn send_message(user_data: &mut Sender<String>, _params: Vec<Value>) -> Vec<Value> {
+        fn send_message(user_data: &mut MySender, _params: Vec<Value>) -> Vec<Value> {
             user_data
+                .0
                 .send("Hello from host function!".to_owned())
                 .unwrap();
 
             Vec::new()
         }
 
-        let mut instance = RuntimeInstance::new(tx);
+        let mut instance = RuntimeInstance::new(MySender(tx));
         instance
             .add_host_function_typed::<(), ()>("host", "send_message", send_message)
             .unwrap();