feat: add resumable calls / fuel tracking

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

Author: explodingcamera

crates/tinywasm/Cargo.toml

@@ -116,3 +116,7 @@ harness=false
 [[bench]]
 name="tinywasm"
 harness=false
+
+[[bench]]
+name="tinywasm_modes"
+harness=false

crates/tinywasm/benches/tinywasm.rs

@@ -34,11 +34,13 @@ fn tinywasm_run(module: TinyWasmModule) -> Result<()> {
 fn criterion_benchmark(c: &mut Criterion) {
     let module = tinywasm_parse().expect("tinywasm_parse");
     let _twasm = tinywasm_to_twasm(&module).expect("tinywasm_to_twasm");
+    let mut group = c.benchmark_group("tinywasm");
+    group.measurement_time(std::time::Duration::from_secs(10));
 
-    // c.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
-    // c.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
-    // c.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
-    c.bench_function("tinywasm", |b| b.iter(|| tinywasm_run(module.clone())));
+    // group.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
+    // group.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
+    // group.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
+    group.bench_function("tinywasm", |b| b.iter(|| tinywasm_run(module.clone())));
 }
 
 criterion_group!(benches, criterion_benchmark);

crates/tinywasm/benches/tinywasm_modes.rs

@@ -0,0 +1,102 @@
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
+use eyre::Result;
+use tinywasm::engine::{Config, FuelPolicy};
+use tinywasm::types::TinyWasmModule;
+use tinywasm::{Engine, ExecProgress, Extern, FuncContext, FuncHandleTyped, Imports, ModuleInstance, Store};
+
+const WASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm");
+const FUEL_PER_ROUND: u32 = 512;
+const TIME_BUDGET_PER_ROUND: core::time::Duration = core::time::Duration::from_micros(50);
+const BENCH_MEASUREMENT_TIME: core::time::Duration = core::time::Duration::from_secs(10);
+
+fn tinywasm_parse() -> Result<TinyWasmModule> {
+    let parser = tinywasm_parser::Parser::new();
+    Ok(parser.parse_module_bytes(WASM)?)
+}
+
+fn setup_typed_func(module: TinyWasmModule, engine: Option<Engine>) -> Result<(Store, FuncHandleTyped<(), ()>)> {
+    let mut store = match engine {
+        Some(engine) => Store::new(engine),
+        None => Store::default(),
+    };
+
+    let mut imports = Imports::default();
+    imports.define("env", "printi32", Extern::typed_func(|_: FuncContext<'_>, _: i32| Ok(())))?;
+
+    let instance = ModuleInstance::instantiate(&mut store, module.into(), Some(imports))?;
+    let func = instance.exported_func::<(), ()>(&store, "hello")?;
+    Ok((store, func))
+}
+
+fn run_call(store: &mut Store, func: &FuncHandleTyped<(), ()>) -> Result<()> {
+    func.call(store, ())?;
+    Ok(())
+}
+
+fn run_resume_with_fuel(store: &mut Store, func: &FuncHandleTyped<(), ()>) -> Result<()> {
+    let mut execution = func.call_resumable(store, ())?;
+    loop {
+        match execution.resume_with_fuel(FUEL_PER_ROUND)? {
+            ExecProgress::Completed(_) => return Ok(()),
+            ExecProgress::Suspended => {}
+        }
+    }
+}
+
+fn run_resume_with_time_budget(store: &mut Store, func: &FuncHandleTyped<(), ()>) -> Result<()> {
+    let mut execution = func.call_resumable(store, ())?;
+    loop {
+        match execution.resume_with_time_budget(TIME_BUDGET_PER_ROUND)? {
+            ExecProgress::Completed(_) => return Ok(()),
+            ExecProgress::Suspended => {}
+        }
+    }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let module = tinywasm_parse().expect("tinywasm_parse");
+    let mut group = c.benchmark_group("tinywasm_modes");
+    group.measurement_time(BENCH_MEASUREMENT_TIME);
+
+    group.bench_function("call", |b| {
+        b.iter_batched_ref(
+            || setup_typed_func(module.clone(), None).expect("setup call"),
+            |(store, func)| run_call(store, func).expect("run call"),
+            BatchSize::LargeInput,
+        )
+    });
+
+    let per_instruction_engine = Engine::new(Config::new().fuel_policy(FuelPolicy::PerInstruction));
+    group.bench_function("resume_fuel_per_instruction", |b| {
+        b.iter_batched_ref(
+            || {
+                setup_typed_func(module.clone(), Some(per_instruction_engine.clone()))
+                    .expect("setup fuel per-instruction")
+            },
+            |(store, func)| run_resume_with_fuel(store, func).expect("run fuel per-instruction"),
+            BatchSize::LargeInput,
+        )
+    });
+
+    let weighted_engine = Engine::new(Config::new().fuel_policy(FuelPolicy::Weighted));
+    group.bench_function("resume_fuel_weighted", |b| {
+        b.iter_batched_ref(
+            || setup_typed_func(module.clone(), Some(weighted_engine.clone())).expect("setup fuel weighted"),
+            |(store, func)| run_resume_with_fuel(store, func).expect("run fuel weighted"),
+            BatchSize::LargeInput,
+        )
+    });
+
+    group.bench_function("resume_time_budget", |b| {
+        b.iter_batched_ref(
+            || setup_typed_func(module.clone(), None).expect("setup time budget"),
+            |(store, func)| run_resume_with_time_budget(store, func).expect("run time budget"),
+            BatchSize::LargeInput,
+        )
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

crates/tinywasm/src/engine.rs

@@ -39,6 +39,22 @@ pub(crate) struct EngineInner {
     // pub(crate) allocator: Box<dyn Allocator + Send + Sync>,
 }
 
+/// Fuel accounting policy for budgeted execution.
+#[derive(Debug, Clone, Copy)]
+#[non_exhaustive]
+pub enum FuelPolicy {
+    /// Charge one fuel unit per retired instruction.
+    PerInstruction,
+    /// Charge one fuel unit per instruction plus predefined extra cost for specific operations.
+    Weighted,
+}
+
+impl Default for FuelPolicy {
+    fn default() -> Self {
+        Self::PerInstruction
+    }
+}
+
 /// Default initial size for the 32-bit value stack (i32, f32 values).
 pub const DEFAULT_VALUE_STACK_32_SIZE: usize = 64 * 1024; // 64k slots
 
@@ -68,13 +84,21 @@ pub struct Config {
     pub stack_ref_size: usize,
     /// Initial size of the call stack.
     pub call_stack_size: usize,
+    /// Fuel accounting policy used by budgeted execution.
+    pub fuel_policy: FuelPolicy,
 }
 
 impl Config {
     /// Create a new stack configuration with default settings.
     pub fn new() -> Self {
         Self::default()
     }
+
+    /// Set the fuel accounting policy for budgeted execution.
+    pub fn fuel_policy(mut self, fuel_policy: FuelPolicy) -> Self {
+        self.fuel_policy = fuel_policy;
+        self
+    }
 }
 
 impl Default for Config {
@@ -85,6 +109,7 @@ impl Default for Config {
             stack_128_size: DEFAULT_VALUE_STACK_128_SIZE,
             stack_ref_size: DEFAULT_VALUE_STACK_REF_SIZE,
             call_stack_size: DEFAULT_CALL_STACK_SIZE,
+            fuel_policy: FuelPolicy::default(),
         }
     }
 }