remove DevolvableSandbox trait

Signed-off-by: Jorge Prendes <[email protected]>

Author: jprendes

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -43,8 +43,8 @@ use crate::mem::memory_region::{MemoryRegion, MemoryRegionFlags};
 use crate::mem::ptr::RawPtr;
 use crate::mem::shared_mem::HostSharedMemory;
 use crate::metrics::maybe_time_and_emit_guest_call;
-use crate::sandbox_state::sandbox::{DevolvableSandbox, EvolvableSandbox, Sandbox};
-use crate::sandbox_state::transition::{MultiUseContextCallback, Noop};
+use crate::sandbox_state::sandbox::{EvolvableSandbox, Sandbox};
+use crate::sandbox_state::transition::MultiUseContextCallback;
 use crate::{HyperlightError, Result, log_then_return};
 
 /// A sandbox that supports being used Multiple times.
@@ -360,27 +360,6 @@ impl std::fmt::Debug for MultiUseSandbox {
     }
 }
 
-impl DevolvableSandbox<MultiUseSandbox, MultiUseSandbox, Noop<MultiUseSandbox, MultiUseSandbox>>
-    for MultiUseSandbox
-{
-    /// Consume `self` and move it back to a `MultiUseSandbox` with previous state.
-    ///
-    /// The purpose of this function is to allow multiple states to be associated with a single MultiUseSandbox.
-    ///
-    /// An implementation such as HyperlightJs or HyperlightWasm can use this to call guest functions to load JS or WASM code and then evolve the sandbox causing state to be captured.
-    /// The new MultiUseSandbox can then be used to call guest functions to execute the loaded code.
-    /// The devolve can be used to return the MultiUseSandbox to the state before the code was loaded. Thus avoiding initialisation overhead
-    #[instrument(err(Debug), skip_all, parent = Span::current(), level = "Trace")]
-    fn devolve(mut self, _tsn: Noop<MultiUseSandbox, MultiUseSandbox>) -> Result<MultiUseSandbox> {
-        let rgns_to_unmap = self
-            .mem_mgr
-            .unwrap_mgr_mut()
-            .pop_and_restore_state_from_snapshot()?;
-        unsafe { self.vm.unmap_regions(rgns_to_unmap)? };
-        Ok(self)
-    }
-}
-
 impl<'a, F>
     EvolvableSandbox<
         MultiUseSandbox,

src/hyperlight_host/src/sandbox_state/sandbox.rs

@@ -30,9 +30,8 @@ use crate::{Result, new_error};
 /// into a next state. That "next state" may in turn know how to roll back
 /// to the root node.
 ///
-/// These transitions are expressed as `EvolvableSandbox` and
-/// `DevolvableSandbox` implementations any `Sandbox` implementation can
-/// opt into.
+/// These transitions are expressed as `EvolvableSandbox` implementations
+/// any `Sandbox` implementation can opt into.
 pub trait Sandbox: Sized + Debug {
     /// Check to ensure the current stack cookie matches the one that
     /// was selected when the stack was constructed.
@@ -70,11 +69,3 @@ pub trait EvolvableSandbox<Cur: Sandbox, Next: Sandbox, T: TransitionMetadata<Cu
     /// Evolve `Self` to `Next` providing Metadata.
     fn evolve(self, tsn: T) -> Result<Next>;
 }
-
-/// A `Sandbox` that knows how to roll back to a "previous" `Sandbox`
-pub trait DevolvableSandbox<Cur: Sandbox, Prev: Sandbox, T: TransitionMetadata<Cur, Prev>>:
-    Sandbox
-{
-    /// Devolve `Self` to `Prev` providing Metadata.
-    fn devolve(self, tsn: T) -> Result<Prev>;
-}

src/hyperlight_host/src/sandbox_state/transition.rs

@@ -22,9 +22,9 @@ use super::sandbox::Sandbox;
 use crate::Result;
 use crate::func::call_ctx::MultiUseGuestCallContext;
 
-/// Metadata about an evolution or devolution. Any `Sandbox` implementation
-/// that also implements `EvolvableSandbox` or `DevolvableSandbox`
-/// can decide the following things in a type-safe way:
+/// Metadata about an evolution. Any `Sandbox` implementation
+/// that also implements `EvolvableSandbox` can decide the following
+/// things in a type-safe way:
 ///
 /// 1. That transition is possible
 /// 2. That transition requires a specific kind of metadata
@@ -40,8 +40,7 @@ use crate::func::call_ctx::MultiUseGuestCallContext;
 /// ```
 ///
 /// ...then you can define a metadata-free evolve transition between
-/// `MySandbox1` and `MySandbox2`, and a devolve transition that requires
-/// a callback between `MySandbox2` and `MySandbox` as follows:
+/// `MySandbox1` and `MySandbox2` as follows:
 ///
 /// ```ignore
 /// impl EvolvableSandbox<
@@ -65,7 +64,7 @@ pub trait TransitionMetadata<Cur: Sandbox, Next: Sandbox> {}
 
 /// Transition metadata that contains and does nothing. `Noop` is a
 /// placeholder when you want to implement an `EvolvableSandbox`
-/// or `DevolvableSandbox` that needs no additional metadata to succeed.
+/// that needs no additional metadata to succeed.
 ///
 /// Construct one of these by using the `default()` method.
 pub struct Noop<Cur: Sandbox, Next: Sandbox> {