wasmtime / issue #13467 How to limit guest code execution... · git-wasmtime

It looks like fuel consumption is a good fit for either measuring the execution cost of guest code, or for forcing unexpectedly expensive guest code to trap. But neither of these are the same as rate limiting guest code. And unfortunately it doesn't seem straightforward to modify the fuel value once a mutable reference to the Store has been thrown over the wall to a Func::call_async(...).

And it looks like epochs are a good fit for ensuring some measure of fairness between guests on the host. But this also is not the same as rate limiting guest code.

This is my rate limiting code so far. It feels very hacky because it relies on the epoch deadline _always_ being expired. But this is the only way I've found that lets me inspect and top up the fuel once the guest function has started, and it does seem to work. Any thoughts on a cleaner approach?

use wasmtime::{Config, Engine, Linker, Module, Store, UpdateDeadline};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let performance = Performance {
        fuel_per_second: 10000f64,
        jerks_per_second: 50f64,
    };
    let mut config = Config::default();
    config.consume_fuel(true).epoch_interruption(true);
    let engine = Engine::new(&config)?;
    let linker = Linker::new(&engine);
    let module = Module::new(
        &engine,
        r#"
            (module
                (func (export "main")
                    (loop $loop
                        br $loop
                    )
                )
            )
        "#,
    )?;
    let mut store = Store::new(
        &engine,
        State {
            performance: performance.clone(),
        },
    );
    const FUEL: u64 = u64::MAX;
    store.set_fuel(FUEL)?;
    store.fuel_async_yield_interval(Some(performance.fuel_per_jerk()))?;
    store.epoch_deadline_callback(|mut store| {
        let consumed_fuel = FUEL - store.get_fuel()?;
        if consumed_fuel == 0 {
            return Ok(UpdateDeadline::Yield(0));
        }
        store.set_fuel(FUEL)?;
        let delay_secs = consumed_fuel as f64 / store.data().performance.fuel_per_second;
        let delay = tokio::time::sleep(tokio::time::Duration::from_secs_f64(delay_secs));
        Ok(UpdateDeadline::YieldCustom(
            0,
            Box::pin(async move {
                println!("{consumed_fuel}:{delay_secs}");
                delay.await;
            }),
        ))
    });
    let instance = linker.instantiate_async(&mut store, &module).await?;
    let main = instance.get_typed_func::<(), ()>(&mut store, "main")?;
    main.call_async(&mut store, ()).await?;
    Ok(())
}

#[derive(Clone, Debug)]
struct Performance {
    pub fuel_per_second: f64,
    pub jerks_per_second: f64,
}

impl Performance {
    pub const fn fuel_per_jerk(&self) -> u64 {
        f64::max(1.0f64, self.fuel_per_second / self.jerks_per_second) as u64
    }
}

struct State {
    performance: Performance,
}

Stream: git-wasmtime

Topic: wasmtime / issue #13467 How to limit guest code execution...

Wasmtime GitHub notifications bot (May 23 2026 at 20:27):

Wasmtime GitHub notifications bot (May 23 2026 at 20:48):

Wasmtime GitHub notifications bot (May 23 2026 at 20:49):

Wasmtime GitHub notifications bot (May 26 2026 at 20:44):

Wasmtime GitHub notifications bot (May 27 2026 at 00:34):

Wasmtime GitHub notifications bot (May 27 2026 at 00:37):

Wasmtime GitHub notifications bot (May 27 2026 at 00:46):

Wasmtime GitHub notifications bot (May 27 2026 at 04:07):

Wasmtime GitHub notifications bot (May 27 2026 at 12:54):