Method resume_with_fuel

crates/tinywasm/src/func.rs:435–461

Resume execution with up to `fuel` units of fuel. Fuel is accounted in chunks, so execution may overshoot the requested fuel before returning [`ExecProgress::Suspended`] (currently the chunk size is 128 instructions between fuel checks, but this may change in the future). Returns [`ExecProgress::Suspended`] when fuel is exhausted, or [`ExecProgress::Completed`] with the final values once the inv

(&mut self, fuel: u32)

    /// currently blocking. They do not suspend and later resume the host
    /// function in the middle of the nested call.
    pub fn resume_with_fuel(&mut self, fuel: u32) -> Result<ExecProgress<Vec<WasmValue>>> {
        let FuncExecutionState::Running { exec_state, root_func_addr } = &mut self.state else {
            let FuncExecutionState::Completed { result } = &mut self.state else {
                unreachable!("invalid function execution state")
            };
            return match result.take() {
                Some(res) => Ok(ExecProgress::Completed(res)),
                None => Err(Error::other("execution already completed")),
            };
        };

        self.store.enter_execution()?;
        let result = InterpreterRuntime::exec_with_fuel(self.store, exec_state.callframe, fuel);
        self.store.exit_execution();

        match result? {
            crate::interpreter::ExecState::Completed => {
                let result_ty = self.store.state.get_func(*root_func_addr).ty().clone();
                self.state = FuncExecutionState::Completed { result: None };
                Ok(ExecProgress::Completed(collect_call_results(&mut self.store.value_stack, &result_ty)?))
            }
            crate::interpreter::ExecState::Suspended(callframe) => {
                exec_state.callframe = callframe;
                Ok(ExecProgress::Suspended)
            }
        }
    }

    #[cfg(feature = "std")]
    /// Resume execution for at most `time_budget` wall-clock time.