chore: overall code cleanup

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

Author: explodingcamera

.cargo/config.toml

@@ -6,3 +6,4 @@ test-2="test --package tinywasm --test test-two --release -- --enable "
 test-wast="test --package tinywasm --test test-wast -- --enable "
 test-wast-release="test --package tinywasm --test test-wast --release -- --enable "
 generate-charts="test --package tinywasm --test generate-charts -- --enable "
+benchmark="bench -p benchmarks --bench"

BENCHMARKS.md

@@ -2,7 +2,7 @@
 
 All benchmarks are run on a Ryzen 7 5800X with 32GB of RAM, running Linux 6.6.
 WebAssembly files are optimized using [wasm-opt](https://github.com/WebAssembly/binaryen),
-and the benchmark code is available in the `benches` folder.
+and the benchmark code is available in the `crates/benchmarks` folder.
 
 These are mainly preliminary benchmarks, and I will be adding more in the future that are also looking into memory usage and other metrics.
 
@@ -67,15 +67,15 @@ After profiling and fixing some low-hanging fruits, I found the biggest bottlene
 Benchmarks are run using [Criterion.rs](https://github.com/bheisler/criterion.rs). To run a benchmark, use the following command:
 
 ```sh
-$ cargo bench --bench <name>
+$ cargo benchmark <name>
 ```
 
 # Profiling
 
 To profile a benchmark, use the following command:
 
 ```sh
-$ cargo flamegraph --bench <name> -- --bench
+$ cargo flamegraph -p benchmarks --bench <name> -- --bench
 ```
 
 This will generate a flamegraph in `flamegraph.svg` and a `perf.data` file.

Cargo.lock

@@ -1,5 +1,6 @@
 [workspace]
 members=["crates/*"]
+default-members=[".", "crates/tinywasm", "crates/types", "crates/parser"]
 resolver="2"
 
 [profile.wasm]
@@ -25,31 +26,13 @@ edition="2021"
 name="wasm-rust"
 test=false
 
-[[bench]]
-name="selfhosted"
-harness=false
-
-[[bench]]
-name="fibonacci"
-harness=false
-
-
-[[bench]]
-name="argon2id"
-harness=false
+[dev-dependencies]
+color-eyre="0.6"
+tinywasm={path="crates/tinywasm", features=["unsafe"]}
+wat={version="1.0"}
 
 [profile.bench]
 opt-level=3
 lto="thin"
 codegen-units=1
 debug=true
-
-[dev-dependencies]
-color-eyre="0.6"
-criterion={version="0.5", features=["html_reports"]}
-
-tinywasm={path="crates/tinywasm", features=["unsafe"]}
-wat={version="1.0"}
-wasmi={version="0.31", features=["std"]}
-wasmer={version="4.2", features=["cranelift", "singlepass"]}
-argon2={version="0.5"}

Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name="benchmarks"
+publish=false
+edition.workspace=true
+
+[dependencies]
+criterion={version="0.5", features=["html_reports"]}
+tinywasm={path="../../crates/tinywasm", features=["unsafe"]}
+wat={version="1.0"}
+wasmi={version="0.31", features=["std"]}
+wasmer={version="4.2", features=["cranelift", "singlepass"]}
+argon2={version="0.5"}
+
+[[bench]]
+name="selfhosted"
+harness=false
+
+[[bench]]
+name="fibonacci"
+harness=false
+
+[[bench]]
+name="argon2id"
+harness=false

crates/benchmarks/Cargo.toml

@@ -36,7 +36,7 @@ fn run_native(params: (i32, i32, i32)) {
     run_native(params.0, params.1, params.2)
 }
 
-const ARGON2ID: &[u8] = include_bytes!("../examples/rust/out/argon2id.wasm");
+const ARGON2ID: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.wasm");
 fn criterion_benchmark(c: &mut Criterion) {
     let twasm = wasm_to_twasm(ARGON2ID);
     let params = (1000, 2, 1);
@@ -47,8 +47,8 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     group.bench_function("native", |b| b.iter(|| run_native(black_box(params))));
     group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm, black_box(params), "argon2id")));
-    group.bench_function("wasmi", |b| b.iter(|| run_wasmi(&ARGON2ID, black_box(params), "argon2id")));
-    group.bench_function("wasmer", |b| b.iter(|| run_wasmer(&ARGON2ID, black_box(params), "argon2id")));
+    group.bench_function("wasmi", |b| b.iter(|| run_wasmi(ARGON2ID, black_box(params), "argon2id")));
+    group.bench_function("wasmer", |b| b.iter(|| run_wasmer(ARGON2ID, black_box(params), "argon2id")));
 }
 
 criterion_group!(

benches/argon2id.rs renamed to crates/benchmarks/benches/argon2id.rs

@@ -20,9 +20,9 @@ fn run_wasmer(wasm: &[u8], iterations: i32, name: &str) {
     let engine: Engine = wasmer::Singlepass::default().into();
     let mut store = Store::default();
     let import_object = imports! {};
-    let module = wasmer::Module::from_binary(&engine, &wasm).expect("wasmer::Module::from_binary");
+    let module = wasmer::Module::from_binary(&engine, wasm).expect("wasmer::Module::from_binary");
     let instance = Instance::new(&mut store, &module, &import_object).expect("Instance::new");
-    let fib = instance.exports.get_typed_function::<i32, i32>(&mut store, name).expect("get_function");
+    let fib = instance.exports.get_typed_function::<i32, i32>(&store, name).expect("get_function");
     fib.call(&mut store, iterations).expect("call");
 }
 
@@ -45,25 +45,25 @@ fn run_native_recursive(n: i32) -> i32 {
     run_native_recursive(n - 1) + run_native_recursive(n - 2)
 }
 
-const FIBONACCI: &[u8] = include_bytes!("../examples/rust/out/fibonacci.wasm");
+const FIBONACCI: &[u8] = include_bytes!("../../../examples/rust/out/fibonacci.wasm");
 fn criterion_benchmark(c: &mut Criterion) {
     let twasm = wasm_to_twasm(FIBONACCI);
 
     {
         let mut group = c.benchmark_group("fibonacci");
         group.bench_function("native", |b| b.iter(|| run_native(black_box(60))));
         group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm, black_box(60), "fibonacci")));
-        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(&FIBONACCI, black_box(60), "fibonacci")));
-        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(&FIBONACCI, black_box(60), "fibonacci")));
+        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(60), "fibonacci")));
+        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(60), "fibonacci")));
     }
 
     {
         let mut group = c.benchmark_group("fibonacci-recursive");
         group.measurement_time(std::time::Duration::from_secs(5));
         group.bench_function("native", |b| b.iter(|| run_native_recursive(black_box(26))));
         group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm, black_box(26), "fibonacci_recursive")));
-        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(&FIBONACCI, black_box(26), "fibonacci_recursive")));
-        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(&FIBONACCI, black_box(26), "fibonacci_recursive")));
+        group.bench_function("wasmi", |b| b.iter(|| run_wasmi(FIBONACCI, black_box(26), "fibonacci_recursive")));
+        group.bench_function("wasmer", |b| b.iter(|| run_wasmer(FIBONACCI, black_box(26), "fibonacci_recursive")));
     }
 }
 

benches/fibonacci.rs renamed to crates/benchmarks/benches/fibonacci.rs

@@ -1,11 +1,10 @@
 mod util;
-use criterion::{criterion_group, criterion_main, Criterion};
-
 use crate::util::twasm_to_module;
+use criterion::{criterion_group, criterion_main, Criterion};
 
 fn run_native() {
     use tinywasm::*;
-    let module = tinywasm::Module::parse_bytes(include_bytes!("../examples/rust/out/print.wasm")).expect("parse");
+    let module = tinywasm::Module::parse_bytes(include_bytes!("../../../examples/rust/out/print.wasm")).expect("parse");
     let mut store = Store::default();
     let mut imports = Imports::default();
     imports.define("env", "printi32", Extern::typed_func(|_: FuncContext<'_>, _: i32| Ok(()))).expect("define");
@@ -46,18 +45,18 @@ fn run_wasmer(wasm: &[u8]) {
             "printi32" => Function::new_typed(&mut store, |_: i32| {}),
         },
     };
-    let module = wasmer::Module::from_binary(&engine, &wasm).expect("wasmer::Module::from_binary");
+    let module = wasmer::Module::from_binary(&engine, wasm).expect("wasmer::Module::from_binary");
     let instance = Instance::new(&mut store, &module, &import_object).expect("Instance::new");
     let hello = instance.exports.get_function("hello").expect("get_function");
     hello.call(&mut store, &[]).expect("call");
 }
 
-const TINYWASM: &[u8] = include_bytes!("../examples/rust/out/tinywasm.wasm");
+const TINYWASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm");
 fn criterion_benchmark(c: &mut Criterion) {
     let twasm = util::wasm_to_twasm(TINYWASM);
 
     let mut group = c.benchmark_group("selfhosted");
-    group.bench_function("native", |b| b.iter(|| run_native()));
+    group.bench_function("native", |b| b.iter(run_native));
     group.bench_function("tinywasm", |b| b.iter(|| run_tinywasm(&twasm)));
     group.bench_function("wasmi", |b| b.iter(|| run_wasmi(TINYWASM)));
     group.bench_function("wasmer", |b| b.iter(|| run_wasmer(TINYWASM)));

benches/selfhosted.rs renamed to crates/benchmarks/benches/selfhosted.rs

@@ -10,7 +10,7 @@ pub fn wasm_to_twasm(wasm: &[u8]) -> Vec<u8> {
 
 #[inline]
 pub fn twasm_to_module(twasm: &[u8]) -> tinywasm::Module {
-    unsafe { TinyWasmModule::from_twasm_unchecked(&twasm) }.into()
+    unsafe { TinyWasmModule::from_twasm_unchecked(twasm) }.into()
 }
 
 pub fn tinywasm(twasm: &[u8]) -> (tinywasm::Store, tinywasm::ModuleInstance) {

benches/util/mod.rs renamed to crates/benchmarks/benches/util/mod.rs

@@ -131,7 +131,7 @@ pub(crate) fn convert_module_globals<'a, T: IntoIterator<Item = wasmparser::Resu
     Ok(globals)
 }
 
-pub(crate) fn convert_module_export(export: wasmparser::Export) -> Result<Export> {
+pub(crate) fn convert_module_export(export: wasmparser::Export<'_>) -> Result<Export> {
     let kind = match export.kind {
         wasmparser::ExternalKind::Func => ExternalKind::Func,
         wasmparser::ExternalKind::Table => ExternalKind::Table,
@@ -146,7 +146,7 @@ pub(crate) fn convert_module_export(export: wasmparser::Export) -> Result<Export
 }
 
 pub(crate) fn convert_module_code(
-    func: wasmparser::FunctionBody,
+    func: wasmparser::FunctionBody<'_>,
     mut validator: FuncValidator<ValidatorResources>,
 ) -> Result<CodeSection> {
     let locals_reader = func.get_locals_reader()?;
@@ -205,18 +205,17 @@ pub(crate) fn convert_memarg(memarg: wasmparser::MemArg) -> MemoryArg {
     MemoryArg { offset: memarg.offset, align: memarg.align, align_max: memarg.max_align, mem_addr: memarg.memory }
 }
 
-pub(crate) fn process_const_operators(ops: OperatorsReader) -> Result<ConstInstruction> {
+pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<ConstInstruction> {
     let ops = ops.into_iter().collect::<wasmparser::Result<Vec<_>>>()?;
     // In practice, the len can never be something other than 2,
     // but we'll keep this here since it's part of the spec
     // Invalid modules will be rejected by the validator anyway (there are also tests for this in the testsuite)
     assert!(ops.len() >= 2);
     assert!(matches!(ops[ops.len() - 1], wasmparser::Operator::End));
-
     process_const_operator(ops[ops.len() - 2].clone())
 }
 
-pub fn process_const_operator(op: wasmparser::Operator) -> Result<ConstInstruction> {
+pub(crate) fn process_const_operator(op: wasmparser::Operator<'_>) -> Result<ConstInstruction> {
     match op {
         wasmparser::Operator::RefNull { ty } => Ok(ConstInstruction::RefNull(convert_valtype(&ty))),
         wasmparser::Operator::RefFunc { function_index } => Ok(ConstInstruction::RefFunc(function_index)),
@@ -229,7 +228,7 @@ pub fn process_const_operator(op: wasmparser::Operator) -> Result<ConstInstructi
     }
 }
 
-pub fn process_operators<'a>(
+pub(crate) fn process_operators<'a>(
     mut offset: usize,
     ops: impl Iterator<Item = Result<wasmparser::Operator<'a>, wasmparser::BinaryReaderError>>,
     mut validator: FuncValidator<ValidatorResources>,
@@ -515,7 +514,6 @@ pub fn process_operators<'a>(
                 return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported instruction: {:?}", op)));
             }
         };
-
         instructions.push(res);
     }
 
@@ -524,6 +522,5 @@ pub fn process_operators<'a>(
     }
 
     validator.finish(offset)?;
-
     Ok(instructions.into_boxed_slice())
 }