use peek for stack access, reorganization and simplifications

Author: InvalidPathException

README.md

@@ -13,8 +13,8 @@ Based on the [original paper by Ben L. Titzer](https://www.cs.tufts.edu/comp/150
   - `wasm_memory.rs` - Linear memory management
   - `signature.rs` - Function signature handling
   - `leb128.rs` - LEB128 encoding/decoding utilities
-  - `byte_iter.rs` - Byte stream iteration helpers
   - `error.rs` - Error types and handling
+  - `opcodes.rs` - Opcode constants
   - `lib.rs` - Library entry point
   - `/bin` - Example usage demonstrations
 - `/tests` - Tests

bench.md

@@ -9,9 +9,7 @@ This file documents the coremark bench results to keep track of performance impr
     - repr(C) for the SideTableEntry struct caused mysterious improvements, not sure if it is a fluke
 - cc02503: avg = 855.71814, n = 20 (remove defensive malformed check in main loop)
     - since the module is already validated at run time, there is no reason for the check to exist, it was a remnant of early development phase that lacked proper handling for some malformed modules
-- current: no significant difference
-
-On nightly, the performance is slightly better (sometimes reaching 900)
+- current: avg = 948.285031, n = 20 (use peek for stack access, reorganization and simplifications)
 
 Next step: use direct threading to improve branch prediction 
 
@@ -28,6 +26,6 @@ wasmi: ~1700
 tinywasm: ~630
 
 Goal:
-We expect/hope to reach ~1200 after threaded dispatch implementation. It seems like Ben Titzer only reached performance comparable to production-ready, optimizing interpreters through manually crafted assembly code for hot paths. 
+I expect/hope to reach ~1200 after threaded dispatch implementation. It seems like Ben Titzer only reached performance comparable to production-ready, optimizing interpreters through manually crafted assembly code for hot paths. 
 
-Higher performance may not be pursued after the point and instead I might focus on adding more instructions to achieve Wasm 2.0 spec parity (should be easy with AI).
+Higher performance may not be pursued after the point and instead I might focus on adding more instructions to achieve Wasm 2.0 spec parity.

benches/coremark.rs

@@ -7,10 +7,8 @@ use criterion::{criterion_group, criterion_main, Criterion, Throughput};
 use wagmi::{ExportValue, Imports, Instance, Module, RuntimeFunction, ValType, WasmValue};
 
 fn clock_ms_i64() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("Clock may have gone backwards")
-        .as_millis() as i64
+    SystemTime::now().duration_since(UNIX_EPOCH).expect("Clock may have gone backwards").as_millis()
+        as i64
 }
 
 fn setup_instance() -> (Instance, wagmi::RuntimeFunction) {
@@ -41,12 +39,16 @@ fn bench_coremark(c: &mut Criterion) {
     let results_once = instance.invoke(&run_fn, &[]).expect("invoke run once");
     let elapsed_once = t0.elapsed();
     let score_once = results_once[0].as_f32();
-    println!("coremark single-run: elapsed={:.6}s score={}", elapsed_once.as_secs_f64(), score_once);
+    println!(
+        "coremark single-run: elapsed={:.6}s score={}",
+        elapsed_once.as_secs_f64(),
+        score_once
+    );
 
     let mut group = c.benchmark_group("coremark_minimal");
     let mut scores: Vec<f32> = Vec::new();
     group.sample_size(10);
-    group.measurement_time(Duration::from_secs(600));
+    group.measurement_time(Duration::from_secs(150));
     group.warm_up_time(Duration::from_secs(1));
     group.throughput(Throughput::Elements(1));
     group.bench_function("run", |b| {
@@ -73,5 +75,3 @@ fn bench_coremark(c: &mut Criterion) {
 
 criterion_group!(benches, bench_coremark);
 criterion_main!(benches);
-
-

rustfmt.toml

@@ -0,0 +1,3 @@
+edition = "2021"
+use_small_heuristics = "Max"
+struct_variant_width = 40

src/bin/utils/mod.rs

@@ -1,16 +1,14 @@
-use std::process::Command;
-use std::path::{Path, PathBuf};
-use std::fs;
 use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
 
 /// Compiles a WAT file to WASM using wat2wasm
 pub fn compile_wat(wat_path: &Path) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
     let temp_dir = env::temp_dir();
-    let stem = wat_path.file_stem()
-        .ok_or("Invalid WAT file path")?
-        .to_string_lossy();
+    let stem = wat_path.file_stem().ok_or("Invalid WAT file path")?.to_string_lossy();
     let wasm_path = temp_dir.join(format!("{}.wasm", stem));
-    
+
     // Determine the correct wat2wasm binary based on OS
     let wat2wasm = if cfg!(target_os = "macos") {
         "tools/osx/wat2wasm"
@@ -19,25 +17,26 @@ pub fn compile_wat(wat_path: &Path) -> Result<Vec<u8>, Box<dyn std::error::Error
     } else {
         return Err("Unsupported OS for wat2wasm".into());
     };
-    
+
     // Run wat2wasm
     let output = Command::new(wat2wasm)
         .arg(wat_path)
         .arg("-o")
         .arg(&wasm_path)
         .output()
         .map_err(|e| format!("Failed to run wat2wasm: {}", e))?;
-    
+
     if !output.status.success() {
         return Err(format!(
             "wat2wasm compilation failed: {}",
             String::from_utf8_lossy(&output.stderr)
-        ).into());
+        )
+        .into());
     }
-    
+
     let wasm_bytes = fs::read(&wasm_path)?;
     let _ = fs::remove_file(&wasm_path);
-    
+
     Ok(wasm_bytes)
 }
 
@@ -48,4 +47,4 @@ pub fn load_resource_module(name: &str) -> Result<Vec<u8>, Box<dyn std::error::E
         .join("src/bin/resources")
         .join(format!("{}.wat", name));
     compile_wat(&path)
-}
+}

src/bin/wagmi_example_basic.rs

@@ -1,5 +1,5 @@
 use std::rc::Rc;
-use wagmi::{Module, Instance, Imports, WasmValue};
+use wagmi::{Imports, Instance, Module, WasmValue};
 
 mod utils;
 use utils::load_resource_module;
@@ -10,103 +10,109 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let arithmetic_module = Rc::new(arithmetic_module);
     let imports = Imports::new();
     let arithmetic_instance = Instance::instantiate(arithmetic_module, &imports)?;
-    
-    
+
     if let Some(wagmi::ExportValue::Function(add)) = arithmetic_instance.exports.get("add") {
-        let result = arithmetic_instance.invoke(add, &[WasmValue::from_i32(10), WasmValue::from_i32(32)])?;
+        let result =
+            arithmetic_instance.invoke(add, &[WasmValue::from_i32(10), WasmValue::from_i32(32)])?;
         println!("add(10, 32) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(sub)) = arithmetic_instance.exports.get("subtract") {
-        let result = arithmetic_instance.invoke(sub, &[WasmValue::from_i32(100), WasmValue::from_i32(58)])?;
+        let result = arithmetic_instance
+            .invoke(sub, &[WasmValue::from_i32(100), WasmValue::from_i32(58)])?;
         println!("subtract(100, 58) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(mul)) = arithmetic_instance.exports.get("multiply") {
-        let result = arithmetic_instance.invoke(mul, &[WasmValue::from_i32(6), WasmValue::from_i32(7)])?;
+        let result =
+            arithmetic_instance.invoke(mul, &[WasmValue::from_i32(6), WasmValue::from_i32(7)])?;
         println!("multiply(6, 7) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(div)) = arithmetic_instance.exports.get("divide") {
-        let result = arithmetic_instance.invoke(div, &[WasmValue::from_i32(84), WasmValue::from_i32(2)])?;
+        let result =
+            arithmetic_instance.invoke(div, &[WasmValue::from_i32(84), WasmValue::from_i32(2)])?;
         println!("divide(84, 2) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(modulo)) = arithmetic_instance.exports.get("modulo") {
-        let result = arithmetic_instance.invoke(modulo, &[WasmValue::from_i32(10), WasmValue::from_i32(3)])?;
+        let result = arithmetic_instance
+            .invoke(modulo, &[WasmValue::from_i32(10), WasmValue::from_i32(3)])?;
         println!("modulo(10, 3) = {}", result[0].as_i32());
     }
-    
-    
+
     let factorial_bytes = load_resource_module("factorial")?;
     let factorial_module = Module::compile(factorial_bytes)?;
     let factorial_module = Rc::new(factorial_module);
     let factorial_instance = Instance::instantiate(factorial_module, &imports)?;
-    
-    if let Some(wagmi::ExportValue::Function(factorial)) = factorial_instance.exports.get("factorial") {
+
+    if let Some(wagmi::ExportValue::Function(factorial)) =
+        factorial_instance.exports.get("factorial")
+    {
         for n in [0, 1, 5, 10] {
             let result = factorial_instance.invoke(factorial, &[WasmValue::from_i32(n)])?;
             println!("factorial({}) = {}", n, result[0].as_i32());
         }
     }
-    
-    
+
     let control_bytes = load_resource_module("control_flow")?;
     let control_module = Module::compile(control_bytes)?;
     let control_module = Rc::new(control_module);
     let control_instance = Instance::instantiate(control_module, &imports)?;
-    
-    
+
     if let Some(wagmi::ExportValue::Function(fib)) = control_instance.exports.get("fibonacci") {
         for n in [0, 1, 2, 5, 10] {
             let result = control_instance.invoke(fib, &[WasmValue::from_i32(n)])?;
             println!("fibonacci({}) = {}", n, result[0].as_i32());
         }
     }
-    
+
     if let Some(wagmi::ExportValue::Function(max)) = control_instance.exports.get("max") {
-        let result = control_instance.invoke(max, &[WasmValue::from_i32(42), WasmValue::from_i32(17)])?;
+        let result =
+            control_instance.invoke(max, &[WasmValue::from_i32(42), WasmValue::from_i32(17)])?;
         println!("max(42, 17) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(min)) = control_instance.exports.get("min") {
-        let result = control_instance.invoke(min, &[WasmValue::from_i32(42), WasmValue::from_i32(17)])?;
+        let result =
+            control_instance.invoke(min, &[WasmValue::from_i32(42), WasmValue::from_i32(17)])?;
         println!("min(42, 17) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(abs)) = control_instance.exports.get("abs") {
         let result = control_instance.invoke(abs, &[WasmValue::from_i32(-42)])?;
         println!("abs(-42) = {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(sign)) = control_instance.exports.get("sign") {
         for n in [-42, 0, 42] {
             let result = control_instance.invoke(sign, &[WasmValue::from_i32(n)])?;
             println!("sign({}) = {}", n, result[0].as_i32());
         }
     }
-    
-    
+
     let memory_bytes = load_resource_module("memory_ops")?;
     let memory_module = Module::compile(memory_bytes)?;
     let memory_module = Rc::new(memory_module);
     let memory_instance = Instance::instantiate(memory_module, &imports)?;
-    
-    
-    if let (Some(wagmi::ExportValue::Function(store)), Some(wagmi::ExportValue::Function(load))) = 
-        (memory_instance.exports.get("store_i32"), memory_instance.exports.get("load_i32")) {
-        
+
+    if let (Some(wagmi::ExportValue::Function(store)), Some(wagmi::ExportValue::Function(load))) =
+        (memory_instance.exports.get("store_i32"), memory_instance.exports.get("load_i32"))
+    {
         memory_instance.invoke(store, &[WasmValue::from_i32(0), WasmValue::from_i32(42)])?;
         println!("Stored 42 at offset 0");
-        
+
         let result = memory_instance.invoke(load, &[WasmValue::from_i32(0)])?;
         println!("Loaded from offset 0: {}", result[0].as_i32());
     }
-    
+
     if let Some(wagmi::ExportValue::Function(memset)) = memory_instance.exports.get("memset") {
-        memory_instance.invoke(memset, &[WasmValue::from_i32(100), WasmValue::from_i32(0xFF), WasmValue::from_i32(10)])?;
+        memory_instance.invoke(
+            memset,
+            &[WasmValue::from_i32(100), WasmValue::from_i32(0xFF), WasmValue::from_i32(10)],
+        )?;
         println!("Filled 10 bytes at offset 100 with 0xFF");
     }
-    
+
     Ok(())
-}
+}