lunatic_process/runtimes/
wasmtime.rs

1use std::sync::Arc;
2
3use anyhow::Result;
4use wasmtime::ResourceLimiter;
5
6use crate::{
7    config::{ProcessConfig, UNIT_OF_COMPUTE_IN_INSTRUCTIONS},
8    state::ProcessState,
9    ExecutionResult, ResultValue,
10};
11
12use super::RawWasm;
13
14#[derive(Clone)]
15pub struct WasmtimeRuntime {
16    engine: wasmtime::Engine,
17}
18
19impl WasmtimeRuntime {
20    pub fn new(config: &wasmtime::Config) -> Result<Self> {
21        let engine = wasmtime::Engine::new(config)?;
22        Ok(Self { engine })
23    }
24
25    /// Compiles a wasm module to machine code and performs type-checking on host functions.
26    pub fn compile_module<T>(&self, data: RawWasm) -> Result<WasmtimeCompiledModule<T>>
27    where
28        T: ProcessState,
29    {
30        let module = wasmtime::Module::new(&self.engine, data.as_slice())?;
31        let mut linker = wasmtime::Linker::new(&self.engine);
32        // Register host functions to linker.
33        <T as ProcessState>::register(&mut linker)?;
34        let instance_pre = linker.instantiate_pre(&module)?;
35        let compiled_module = WasmtimeCompiledModule::new(data, module, instance_pre);
36        Ok(compiled_module)
37    }
38
39    pub async fn instantiate<T>(
40        &self,
41        compiled_module: &WasmtimeCompiledModule<T>,
42        state: T,
43    ) -> Result<WasmtimeInstance<T>>
44    where
45        T: ProcessState + Send + ResourceLimiter,
46    {
47        let max_fuel = state.config().get_max_fuel();
48        let mut store = wasmtime::Store::new(&self.engine, state);
49        // Set limits of the store
50        store.limiter(|state| state);
51        // Trap if out of fuel
52        store.out_of_fuel_trap();
53        // Define maximum fuel
54        match max_fuel {
55            Some(max_fuel) => {
56                store.out_of_fuel_async_yield(max_fuel, UNIT_OF_COMPUTE_IN_INSTRUCTIONS)
57            }
58            // If no limit is specified use maximum
59            None => store.out_of_fuel_async_yield(u64::MAX, UNIT_OF_COMPUTE_IN_INSTRUCTIONS),
60        };
61        // Create instance
62        let instance = compiled_module
63            .instantiator()
64            .instantiate_async(&mut store)
65            .await?;
66        // Mark state as initialized
67        store.data_mut().initialize();
68        Ok(WasmtimeInstance { store, instance })
69    }
70}
71
72pub struct WasmtimeCompiledModule<T> {
73    inner: Arc<WasmtimeCompiledModuleInner<T>>,
74}
75
76pub struct WasmtimeCompiledModuleInner<T> {
77    source: RawWasm,
78    module: wasmtime::Module,
79    instance_pre: wasmtime::InstancePre<T>,
80}
81
82impl<T> WasmtimeCompiledModule<T> {
83    pub fn new(
84        source: RawWasm,
85        module: wasmtime::Module,
86        instance_pre: wasmtime::InstancePre<T>,
87    ) -> WasmtimeCompiledModule<T> {
88        let inner = Arc::new(WasmtimeCompiledModuleInner {
89            source,
90            module,
91            instance_pre,
92        });
93        Self { inner }
94    }
95
96    pub fn exports(&self) -> impl ExactSizeIterator<Item = wasmtime::ExportType<'_>> {
97        self.inner.module.exports()
98    }
99
100    pub fn source(&self) -> &RawWasm {
101        &self.inner.source
102    }
103
104    pub fn instantiator(&self) -> &wasmtime::InstancePre<T> {
105        &self.inner.instance_pre
106    }
107}
108
109impl<T> Clone for WasmtimeCompiledModule<T> {
110    fn clone(&self) -> Self {
111        Self {
112            inner: self.inner.clone(),
113        }
114    }
115}
116
117pub struct WasmtimeInstance<T>
118where
119    T: Send,
120{
121    store: wasmtime::Store<T>,
122    instance: wasmtime::Instance,
123}
124
125impl<T> WasmtimeInstance<T>
126where
127    T: Send,
128{
129    pub async fn call(mut self, function: &str, params: Vec<wasmtime::Val>) -> ExecutionResult<T> {
130        let entry = self.instance.get_func(&mut self.store, function);
131
132        if entry.is_none() {
133            return ExecutionResult {
134                state: self.store.into_data(),
135                result: ResultValue::SpawnError(format!("Function '{function}' not found")),
136            };
137        }
138
139        let result = entry
140            .unwrap()
141            .call_async(&mut self.store, &params, &mut [])
142            .await;
143
144        ExecutionResult {
145            state: self.store.into_data(),
146            result: match result {
147                Ok(()) => ResultValue::Ok,
148                Err(err) => {
149                    // If the trap is a result of calling `proc_exit(0)`, treat it as an no-error finish.
150                    match err.downcast_ref::<wasmtime_wasi::I32Exit>() {
151                        Some(wasmtime_wasi::I32Exit(0)) => ResultValue::Ok,
152                        _ => ResultValue::Failed(err.to_string()),
153                    }
154                }
155            },
156        }
157    }
158}
159
160pub fn default_config() -> wasmtime::Config {
161    let mut config = wasmtime::Config::new();
162    config
163        .async_support(true)
164        .debug_info(false)
165        // The behavior of fuel running out is defined on the Store
166        .consume_fuel(true)
167        .wasm_reference_types(true)
168        .wasm_bulk_memory(true)
169        .wasm_multi_value(true)
170        .wasm_multi_memory(true)
171        .cranelift_opt_level(wasmtime::OptLevel::SpeedAndSize)
172        // Allocate resources on demand because we can't predict how many process will exist
173        .allocation_strategy(wasmtime::InstanceAllocationStrategy::OnDemand)
174        // Always use static memories
175        .static_memory_forced(true);
176    config
177}
lunatic_process/runtimes/wasmtime.rs

lunatic_process/runtimes/
wasmtime.rs
