Upgrade to Hyperlight 0.13

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Author: jsturtevant

Cargo.lock

@@ -4,7 +4,7 @@ exclude = [ "src/rust_wasm_samples", "src/component_sample" ]
 resolver = "2"
 
 [workspace.package]
-version = "0.12.0"
+version = "0.13.0"
 edition = "2024"
 rust-version = "1.89"
 license = "Apache-2.0"
@@ -13,11 +13,11 @@ repository = "https://github.com/hyperlight-dev/hyperlight-wasm"
 readme = "README.md"
 
 [workspace.dependencies]
-hyperlight-common = { version = "0.12.0", default-features = false }
+hyperlight-common = { version = "0.13.0", default-features = false }
 hyperlight-component-macro = { version = "0.13.0" }
-hyperlight-component-util = { version = "0.12.0" }
-hyperlight-guest = { version = "0.12.0" }
-hyperlight-guest-bin = { version = "0.12.0", features = [ "printf" ] }
-hyperlight-host = { version = "0.12.0", default-features = false, features = ["executable_heap", "init-paging"] }
-hyperlight-wasm-macro = { version = "0.12.0", path = "src/hyperlight_wasm_macro" }
-hyperlight-wasm-runtime = { version = "0.12.0", path = "src/hyperlight_wasm_runtime" }
+hyperlight-component-util = { version = "0.13.0" }
+hyperlight-guest = { version = "0.13.0" }
+hyperlight-guest-bin = { version = "0.13.0", features = [ "printf" ] }
+hyperlight-host = { version = "0.13.0", default-features = false, features = ["executable_heap", "init-paging"] }
+hyperlight-wasm-macro = { version = "0.13.0", path = "src/hyperlight_wasm_macro" }
+hyperlight-wasm-runtime = { version = "0.13.0", path = "src/hyperlight_wasm_runtime" }

Cargo.toml

@@ -48,7 +48,7 @@ fn main() {
     let mut sb: hyperlight_wasm::ProtoWasmSandbox = hyperlight_wasm::SandboxBuilder::new()
         .with_guest_input_buffer_size(70000000)
         .with_guest_heap_size(200000000)
-        .with_guest_stack_size(100000000)
+        .with_guest_scratch_size(100 * 1024 * 1024)
         .build()
         .unwrap();
     let rt = bindings::register_host_functions(&mut sb, state);

src/hyperlight_wasm/examples/component_example/main.rs

@@ -112,7 +112,7 @@ fn main() -> Result<()> {
             "RoundToInt test case {idx} failed: got {}, expected {}",
             result, expected_result
         );
-        loaded_wasm_sandbox.restore(&snapshot)?
+        loaded_wasm_sandbox.restore(snapshot.clone())?
     }
     Ok(())
 }

src/hyperlight_wasm/examples/helloworld/main.rs

@@ -97,7 +97,7 @@ fn main() -> Result<()> {
 
     // Recovery option 1: Use restore() to recover the sandbox
     println!("\n7. Recovering sandbox using restore()...");
-    loaded.restore(&snapshot)?;
+    loaded.restore(snapshot.clone())?;
     assert!(!loaded.is_poisoned()?);
     println!("   is_poisoned after restore: {}", loaded.is_poisoned()?);
 

src/hyperlight_wasm/examples/interruption/main.rs

@@ -42,7 +42,7 @@ pub struct LoadedWasmSandbox {
     // because of this we cannot implement drop without making inner an Option (alternatively we could make MultiUseSandbox Copy but that would introduce other issues)
     inner: Option<MultiUseSandbox>,
     // The state the sandbox was in before loading a wasm module. Used for transitioning back to a `WasmSandbox` (unloading the wasm module).
-    runtime_snapshot: Option<Snapshot>,
+    runtime_snapshot: Option<Arc<Snapshot>>,
 }
 
 impl LoadedWasmSandbox {
@@ -86,7 +86,7 @@ impl LoadedWasmSandbox {
     /// Returns `Err(HyperlightError::PoisonedSandbox)` if the sandbox is in a
     /// poisoned state. Use [`restore()`](Self::restore) with a previously
     /// taken snapshot to recover before taking a new snapshot.
-    pub fn snapshot(&mut self) -> Result<Snapshot> {
+    pub fn snapshot(&mut self) -> Result<Arc<Snapshot>> {
         match &mut self.inner {
             Some(inner) => inner.snapshot(),
             None => log_then_return!("No inner MultiUseSandbox to snapshot"),
@@ -105,7 +105,7 @@ impl LoadedWasmSandbox {
     /// 1. Clear the poisoned state
     /// 2. Reset memory to the snapshot state
     /// 3. Allow subsequent [`call_guest_function()`](Self::call_guest_function) calls to succeed
-    pub fn restore(&mut self, snapshot: &Snapshot) -> Result<()> {
+    pub fn restore(&mut self, snapshot: Arc<Snapshot>) -> Result<()> {
         match &mut self.inner {
             Some(inner) => inner.restore(snapshot),
             None => log_then_return!("No inner MultiUseSandbox to restore"),
@@ -135,7 +135,7 @@ impl LoadedWasmSandbox {
 
     pub(super) fn new(
         inner: MultiUseSandbox,
-        runtime_snapshot: Snapshot,
+        runtime_snapshot: Arc<Snapshot>,
     ) -> Result<LoadedWasmSandbox> {
         metrics::gauge!(METRIC_ACTIVE_LOADED_WASM_SANDBOXES).increment(1);
         metrics::counter!(METRIC_TOTAL_LOADED_WASM_SANDBOXES).increment(1);
@@ -360,7 +360,7 @@ mod tests {
     #[test]
     fn test_call_guest_functions_with_custom_config_multiple_times() {
         let mut sandbox = SandboxBuilder::new()
-            .with_guest_stack_size(32 * 1024)
+            .with_guest_scratch_size(32 * 1024)
             .with_guest_heap_size(128 * 1024)
             .build()
             .unwrap();

src/hyperlight_wasm/src/sandbox/loaded_wasm_sandbox.rs

@@ -22,7 +22,9 @@ use super::proto_wasm_sandbox::ProtoWasmSandbox;
 
 // use unreasonably large minimum stack/heap/input data sizes for now to
 // deal with the size of wasmtime/wasi-libc aot artifacts
-pub const MIN_STACK_SIZE: u64 = 64 * 1024;
+// use reasonably large minimum scratch/heap/input data sizes
+// to deal with the size of wasmtime/wasi-libc aot artifacts
+pub const MIN_SCRATCH_SIZE: usize = 2 * 1024 * 1024;
 pub const MIN_INPUT_DATA_SIZE: usize = 192 * 1024;
 pub const MIN_HEAP_SIZE: u64 = 1024 * 1024;
 
@@ -39,6 +41,7 @@ impl SandboxBuilder {
         let mut config: SandboxConfiguration = Default::default();
         config.set_input_data_size(MIN_INPUT_DATA_SIZE);
         config.set_heap_size(MIN_HEAP_SIZE);
+        config.set_scratch_size(MIN_SCRATCH_SIZE);
 
         Self {
             config,
@@ -95,13 +98,14 @@ impl SandboxBuilder {
         self
     }
 
-    /// Set the guest stack size
-    /// This is the size of the stack that code executing in the guest can use.
-    /// If this value is too small then the guest will fail with a stack overflow error
-    /// The default value (and minimum) is set to the value of the MIN_STACK_SIZE const.
-    pub fn with_guest_stack_size(mut self, guest_stack_size: u64) -> Self {
-        if guest_stack_size > MIN_STACK_SIZE {
-            self.config.set_stack_size(guest_stack_size);
+    /// Set the guest scratch size in bytes.
+    /// The scratch region provides writable memory for the guest, including the
+    /// dynamically-sized stack. Increase this if your guest code needs deep
+    /// recursion or large local variables.
+    /// Values smaller than the default (288 KiB) are ignored.
+    pub fn with_guest_scratch_size(mut self, guest_scratch_size: usize) -> Self {
+        if guest_scratch_size > MIN_SCRATCH_SIZE {
+            self.config.set_scratch_size(guest_scratch_size);
         }
         self
     }

src/hyperlight_wasm/src/sandbox/sandbox_builder.rs

@@ -15,8 +15,8 @@ limitations under the License.
 */
 
 use std::path::Path;
+use std::sync::Arc;
 
-use hyperlight_host::mem::memory_region::{MemoryRegion, MemoryRegionFlags, MemoryRegionType};
 use hyperlight_host::sandbox::snapshot::Snapshot;
 use hyperlight_host::{MultiUseSandbox, Result, new_error};
 
@@ -38,7 +38,7 @@ pub struct WasmSandbox {
     inner: Option<MultiUseSandbox>,
     // Snapshot of state of an initial WasmSandbox (runtime loaded, but no guest module code loaded).
     // Used for LoadedWasmSandbox to be able restore state back to WasmSandbox
-    snapshot: Option<Snapshot>,
+    snapshot: Option<Arc<Snapshot>>,
 }
 
 const MAPPED_BINARY_VA: u64 = 0x1_0000_0000u64;
@@ -61,8 +61,11 @@ impl WasmSandbox {
     /// for example when creating a `WasmSandbox` from a `LoadedWasmSandbox`, since
     /// the snapshot has already been created in that case.
     /// Expects a snapshot of the state where wasm runtime is loaded, but no guest module code is loaded.
-    pub(super) fn new_from_loaded(mut loaded: MultiUseSandbox, snapshot: Snapshot) -> Result<Self> {
-        loaded.restore(&snapshot)?;
+    pub(super) fn new_from_loaded(
+        mut loaded: MultiUseSandbox,
+        snapshot: Arc<Snapshot>,
+    ) -> Result<Self> {
+        loaded.restore(snapshot.clone())?;
         metrics::gauge!(METRIC_ACTIVE_WASM_SANDBOXES).increment(1);
         metrics::counter!(METRIC_TOTAL_WASM_SANDBOXES).increment(1);
         Ok(WasmSandbox {
@@ -113,19 +116,8 @@ impl WasmSandbox {
             .as_mut()
             .ok_or_else(|| new_error!("WasmSandbox is None"))?;
 
-        let guest_base: usize = MAPPED_BINARY_VA as usize;
-        let rgn = MemoryRegion {
-            host_region: base as usize..base.wrapping_add(len) as usize,
-            guest_region: guest_base..guest_base + len,
-            flags: MemoryRegionFlags::READ | MemoryRegionFlags::EXECUTE,
-            region_type: MemoryRegionType::Heap,
-        };
-        if let Ok(()) = unsafe { inner.map_region(&rgn) } {
-            inner.call::<()>("LoadWasmModulePhys", (MAPPED_BINARY_VA, len as u64))?;
-        } else {
-            let wasm_bytes = unsafe { std::slice::from_raw_parts(base as *const u8, len).to_vec() };
-            load_wasm_module_from_bytes(inner, wasm_bytes)?;
-        }
+        let wasm_bytes = unsafe { std::slice::from_raw_parts(base as *const u8, len).to_vec() };
+        load_wasm_module_from_bytes(inner, wasm_bytes)?;
 
         self.finalize_module_load()
     }
@@ -390,7 +382,7 @@ mod tests {
         assert!(loaded.is_poisoned()?, "Sandbox should be poisoned");
 
         // Restore should recover the sandbox
-        loaded.restore(&snapshot)?;
+        loaded.restore(snapshot)?;
 
         assert!(
             !loaded.is_poisoned()?,
@@ -526,7 +518,7 @@ mod tests {
         let builder = SandboxBuilder::new()
             .with_guest_input_buffer_size(0x8000)
             .with_guest_output_buffer_size(0x8000)
-            .with_guest_stack_size(0x2000)
+            .with_guest_scratch_size(0x2000)
             .with_guest_heap_size(0x100000);
 
         let mut sandboxes: Vec<SandboxTest> = Vec::new();

src/hyperlight_wasm/src/sandbox/wasm_sandbox.rs

@@ -29,7 +29,7 @@ mod wasmguest;
 #[proc_macro]
 pub fn wasm_guest_bindgen(_: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let path = std::env::var_os("WIT_WORLD").unwrap();
-    util::read_wit_type_from_file(path, |kebab_name, ct| {
+    util::read_wit_type_from_file(path, None, |kebab_name, ct| {
         let decls = emit::run_state(true, true, |s| {
             // Emit type/trait definitions for all instances in the world
             rtypes::emit_toplevel(s, &kebab_name, ct);