feat: pre-processed wasm

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

ARCHITECTURE.md

@@ -17,7 +17,8 @@ Some key differences are:
 ## Bytecode Format
 
 To improve performance and reduce code size, instructions are encoded as enum variants instead of opcodes.
-This allows preprocessing the bytecode into a more compact format, which can be loaded directly into memory and executed without decoding later. This can skip the decoding step entirely on resource-constrained devices where memory is limited.
+This allows preprocessing the bytecode into a more compact format, which can be loaded directly into memory and executed without decoding later. This can skip the decoding step entirely on resource-constrained devices where memory is limited. See this [blog post](https://wasmer.io/posts/improving-with-zero-copy-deserialization) by Wasmer
+for more details which inspired this design.
 
 Some instructions are split into multiple variants to reduce the size of the enum (e.g. `br_table` and `br_label`).
 Additionally, label instructions contain offsets relative to the current instruction to make branching faster and easier to implement.

Cargo.lock

@@ -9,7 +9,7 @@ fn run_tinywasm(module: TinyWasmModule, iterations: i32) {
     let mut store = Store::default();
     let imports = Imports::default();
     let instance = ModuleInstance::instantiate(&mut store, module, Some(imports)).expect("instantiate");
-    let hello = instance.exported_func::<i32, i32>(&mut store, "fibonacci").expect("exported_func");
+    let hello = instance.exported_func::<i32, i32>(&store, "fibonacci").expect("exported_func");
     hello.call(&mut store, iterations).expect("call");
 }
 
@@ -29,8 +29,8 @@ fn criterion_benchmark(c: &mut Criterion) {
     let module = tinywasm_module(FIBONACCI);
 
     let mut group = c.benchmark_group("fibonacci");
-    group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(module.clone(), black_box(50))));
-    group.bench_function("wasmi", |b| b.iter(|| run_wasmi(black_box(50))));
+    group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(module.clone(), black_box(60))));
+    group.bench_function("wasmi", |b| b.iter(|| run_wasmi(black_box(60))));
 }
 
 criterion_group!(

benches/fibonacci.rs

@@ -10,7 +10,7 @@ fn run_tinywasm(module: TinyWasmModule) {
     let mut imports = Imports::default();
     imports.define("env", "printi32", Extern::typed_func(|_: FuncContext<'_>, _: i32| Ok(()))).expect("define");
     let instance = ModuleInstance::instantiate(&mut store, module, Some(imports)).expect("instantiate");
-    let hello = instance.exported_func::<(), ()>(&mut store, "hello").expect("exported_func");
+    let hello = instance.exported_func::<(), ()>(&store, "hello").expect("exported_func");
     hello.call(&mut store, ()).expect("call");
 }
 
@@ -32,7 +32,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let mut group = c.benchmark_group("selfhosted");
     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!(

benches/selfhosted.rs

@@ -11,9 +11,9 @@ repository.workspace=true
 # fork of wasmparser with no_std support, see https://github.com/bytecodealliance/wasmtime/issues/3495
 wasmparser={version="0.100", package="wasmparser-nostd", default-features=false}
 log={version="0.4", optional=true}
-tinywasm-types={version="0.3.0-alpha.0", path="../types"}
+tinywasm-types={version="0.3.0-alpha.0", path="../types", default-features=false}
 
 [features]
 default=["std", "logging"]
 logging=["log"]
-std=[]
+std=["tinywasm-types/std"]

crates/parser/Cargo.toml

@@ -25,7 +25,7 @@ mod module;
 use alloc::{string::ToString, vec::Vec};
 pub use error::*;
 use module::ModuleReader;
-use tinywasm_types::WasmFunction;
+use tinywasm_types::{TypedWasmFunction, WasmFunction};
 use wasmparser::Validator;
 
 pub use tinywasm_types::TinyWasmModule;
@@ -116,19 +116,13 @@ impl TryFrom<ModuleReader> for TinyWasmModule {
             .code
             .into_iter()
             .zip(code_type_addrs)
-            .map(|(f, ty_idx)| {
-                (
-                    ty_idx,
-                    WasmFunction {
-                        instructions: f.body,
-                        locals: f.locals,
-                        ty: reader
-                            .func_types
-                            .get(ty_idx as usize)
-                            .expect("No func type for func, this is a bug")
-                            .clone(),
-                    },
-                )
+            .map(|(f, ty_idx)| TypedWasmFunction {
+                type_addr: ty_idx,
+                wasm_function: WasmFunction {
+                    instructions: f.body,
+                    locals: f.locals,
+                    ty: reader.func_types.get(ty_idx as usize).expect("No func type for func, this is a bug").clone(),
+                },
             })
             .collect::<Vec<_>>();
 

crates/parser/src/lib.rs

@@ -29,11 +29,12 @@ plotters={version="0.3"}
 pretty_env_logger="0.5"
 
 [features]
-default=["std", "parser", "logging"]
+default=["std", "parser", "logging", "archive"]
 logging=["log", "tinywasm-types/logging", "tinywasm-parser?/logging"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["tinywasm-parser"]
-unsafe=[]
+unsafe=["tinywasm-types/unsafe"]
+archive=["tinywasm-types/archive"]
 
 [[test]]
 name="generate-charts"

crates/tinywasm/Cargo.toml

@@ -0,0 +1,27 @@
+use alloc::vec::Vec;
+use tinywasm_types::*;
+
+/// A WebAssembly Data Instance
+///
+/// See <https://webassembly.github.io/spec/core/exec/runtime.html#data-instances>
+#[derive(Debug)]
+pub(crate) struct DataInstance {
+    pub(crate) data: Option<Vec<u8>>,
+    pub(crate) _owner: ModuleInstanceAddr, // index into store.module_instances
+}
+
+impl DataInstance {
+    pub(crate) fn new(data: Option<Vec<u8>>, owner: ModuleInstanceAddr) -> Self {
+        Self { data, _owner: owner }
+    }
+
+    pub(crate) fn drop(&mut self) -> Option<()> {
+        match self.data {
+            None => None,
+            Some(_) => {
+                let _ = self.data.take();
+                Some(())
+            }
+        }
+    }
+}

crates/tinywasm/src/store/data.rs

@@ -0,0 +1,19 @@
+use crate::TableElement;
+use alloc::vec::Vec;
+use tinywasm_types::*;
+
+/// A WebAssembly Element Instance
+///
+/// See <https://webassembly.github.io/spec/core/exec/runtime.html#element-instances>
+#[derive(Debug)]
+pub(crate) struct ElementInstance {
+    pub(crate) kind: ElementKind,
+    pub(crate) items: Option<Vec<TableElement>>, // none is the element was dropped
+    _owner: ModuleInstanceAddr,                  // index into store.module_instances
+}
+
+impl ElementInstance {
+    pub(crate) fn new(kind: ElementKind, owner: ModuleInstanceAddr, items: Option<Vec<TableElement>>) -> Self {
+        Self { kind, _owner: owner, items }
+    }
+}

crates/tinywasm/src/store/element.rs

@@ -0,0 +1,11 @@
+use crate::Function;
+use tinywasm_types::*;
+
+#[derive(Debug, Clone)]
+/// A WebAssembly Function Instance
+///
+/// See <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
+pub(crate) struct FunctionInstance {
+    pub(crate) func: Function,
+    pub(crate) owner: ModuleInstanceAddr, // index into store.module_instances, none for host functions
+}