a bunch of experiments :)

some interesting things here, main things for now I want to pull into
the main branch are reworking the parser to be single pass
and some of the tweaks to interpreter dispatch. Acc-stuff
has gotten a bit out of hand and doesn't really show too much
perf gains (or none) in the current state, this will need a bit
more thought-out rework of our other superinstructions too.
Also we might want to switch back to 16-byte operands since there
wasn't too much of a perf gain.

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

Author: explodingcamera

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Optional `send` support for moving stores and store-local handles across threads
 - Optional portable atomic shared pointers and counters for targets without native compare-and-swap
 - Optional `nightly-tail-calls` backend using Rust's unstable explicit tail calls for interpreter dispatch
+- Streaming parser-managed numeric accumulator bytecode
 
 ### Changed
 

Cargo.lock

@@ -31,9 +31,9 @@ pretty_env_logger = "0.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 wasm-testsuite = { version = "0.7" }
-wasmparser = { version = "0.258", default-features = false }
-wast = "258"
-wat = "1.258"
+wasmparser = { version = "0.259", default-features = false }
+wast = "259"
+wat = "1.259"
 
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support", "rayon"] }
 

Cargo.toml

@@ -11,10 +11,25 @@ const TIME_BUDGET_PER_ROUND: core::time::Duration = core::time::Duration::from_m
 const BENCH_MEASUREMENT_TIME: core::time::Duration = core::time::Duration::from_secs(10);
 
 fn tinywasm_parse() -> Result<Module> {
-    let parser = tinywasm_parser::Parser::default();
+    Ok(tinywasm_parser::Parser::default().parse_module_bytes(WASM)?)
+}
+
+fn tinywasm_parse_single_threaded() -> Result<Module> {
+    let parser = tinywasm_parser::Parser::new(tinywasm_parser::ParserOptions::new().with_parser_threads(1));
     Ok(parser.parse_module_bytes(WASM)?)
 }
 
+fn accumulator_module() -> Result<Module> {
+    let mut wat = String::from("(module (func (export \"chain\") (param i32) (result i32) local.get 0 ");
+    for _ in 0..1024 {
+        wat.push_str("i32.const 1 i32.add ");
+    }
+    wat.push_str("))");
+    let wasm = wat::parse_str(wat).expect("valid accumulator benchmark module");
+    let parser = tinywasm_parser::Parser::default();
+    Ok(parser.parse_module_bytes(&wasm)?)
+}
+
 fn setup_typed_func(module: &Module, engine: Option<Engine>) -> Result<(Store, FunctionTyped<(), ()>)> {
     let mut store = match engine {
         Some(engine) => Store::new(engine),
@@ -34,6 +49,13 @@ fn run_call(store: &mut Store, func: &FunctionTyped<(), ()>) -> Result<()> {
     Ok(())
 }
 
+fn setup_chain(module: &Module) -> Result<(Store, FunctionTyped<i32, i32>)> {
+    let mut store = Store::default();
+    let instance = ModuleInstance::instantiate(&mut store, module, None)?;
+    let func = instance.func::<i32, i32>(&store, "chain")?;
+    Ok((store, func))
+}
+
 fn run_resume_with_fuel(store: &mut Store, func: &FunctionTyped<(), ()>) -> Result<()> {
     let mut execution = func.call_resumable(store, ())?;
     loop {
@@ -55,6 +77,11 @@ fn run_resume_with_time_budget(store: &mut Store, func: &FunctionTyped<(), ()>)
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
+    let mut parse_group = c.benchmark_group("tinywasm_parse_modes");
+    parse_group.measurement_time(BENCH_MEASUREMENT_TIME);
+    parse_group.bench_function("streaming", |b| b.iter(|| tinywasm_parse_single_threaded().expect("parse module")));
+    parse_group.finish();
+
     let module = tinywasm_parse().expect("tinywasm_parse");
     let mut group = c.benchmark_group("tinywasm_modes");
     group.measurement_time(BENCH_MEASUREMENT_TIME);
@@ -94,6 +121,18 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 
     group.finish();
+
+    let accumulator_chain = accumulator_module().expect("parse accumulator benchmark");
+    let mut group = c.benchmark_group("accumulator");
+    group.measurement_time(BENCH_MEASUREMENT_TIME);
+    group.bench_function("chain", |b| {
+        b.iter_batched_ref(
+            || setup_chain(&accumulator_chain).expect("setup accumulator chain"),
+            |(store, func)| assert_eq!(func.call(store, 0).expect("run accumulator chain"), 1024),
+            BatchSize::LargeInput,
+        )
+    });
+    group.finish();
 }
 
 criterion_group!(benches, criterion_benchmark);

benches/tinywasm_modes.rs

@@ -0,0 +1 @@
+too-many-arguments-threshold = 8

clippy.toml

@@ -5,7 +5,6 @@ edition.workspace = true
 rust-version.workspace = true
 description = "Minimal command-line interface for TinyWasm"
 documentation = "https://docs.rs/tinywasm-cli"
-readme = "README.md"
 repository.workspace = true
 license.workspace = true
 keywords = ["cli", "runtime", "tinywasm", "wasm", "webassembly"]

crates/cli/Cargo.toml

@@ -4,7 +4,6 @@ version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
 description = "Parser and lowering pipeline for TinyWasm"
-readme = "README.md"
 repository.workspace = true
 license.workspace = true
 keywords.workspace = true

crates/parser/Cargo.toml

@@ -19,7 +19,7 @@ let bytes = include_bytes!("./file.wasm");
 let parser = Parser::default();
 let module = parser.parse_module_bytes(bytes)?;
 
-let parser = Parser::new(ParserOptions::default().with_rewrite_optimization(false));
+let parser = Parser::new(ParserOptions::default().with_operand_deduplication(true));
 let module = parser.parse_module_bytes(bytes)?;
 
 let module = parser.parse_module_file("path/to/file.wasm")?;