Remove configuration relating to timeouts

Signed-off-by: Ludvig Liljenberg <[email protected]>

Author: ludfjig

src/hyperlight_host/benches/benchmarks.rs

@@ -14,8 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use std::time::Duration;
-
 use criterion::{criterion_group, criterion_main, Criterion};
 use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
 use hyperlight_host::sandbox::{MultiUseSandbox, SandboxConfiguration, UninitializedSandbox};
@@ -77,7 +75,6 @@ fn guest_call_benchmark(c: &mut Criterion) {
         let mut config = SandboxConfiguration::default();
         config.set_input_data_size(2 * SIZE + (1024 * 1024)); // 2 * SIZE + 1 MB, to allow 1MB for the rest of the serialized function call
         config.set_heap_size(SIZE as u64 * 15);
-        config.set_max_execution_time(Duration::from_secs(10));
 
         let sandbox = UninitializedSandbox::new(
             GuestBinary::FilePath(simple_guest_as_string().unwrap()),

src/hyperlight_host/src/sandbox/config.rs

@@ -14,8 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-use std::cmp::{max, min};
-use std::time::Duration;
+use std::cmp::max;
 
 use tracing::{instrument, Span};
 
@@ -56,31 +55,6 @@ pub struct SandboxConfiguration {
     /// field should be represented as an `Option`, that type is not
     /// FFI-safe, so it cannot be.
     heap_size_override: u64,
-    /// The max_execution_time of a guest execution in milliseconds. If set to 0, the max_execution_time
-    /// will be set to the default value of 1000ms if the guest execution does not complete within the time specified
-    /// then the execution will be cancelled, the minimum value is 1ms
-    ///
-    /// Note: this is a C-compatible struct, so even though this optional
-    /// field should be represented as an `Option`, that type is not
-    /// FFI-safe, so it cannot be.
-    ///
-    max_execution_time: u16,
-    /// The max_wait_for_cancellation represents the maximum time the host should wait for a guest execution to be cancelled
-    /// If set to 0, the max_wait_for_cancellation will be set to the default value of 10ms.
-    /// The minimum value is 1ms.
-    ///
-    /// Note: this is a C-compatible struct, so even though this optional
-    /// field should be represented as an `Option`, that type is not
-    /// FFI-safe, so it cannot be.
-    max_wait_for_cancellation: u8,
-    // The max_initialization_time represents the maximum time the host should wait for a guest to initialize
-    // If set to 0, the max_initialization_time will be set to the default value of 2000ms.
-    // The minimum value is 1ms.
-    //
-    // Note: this is a C-compatible struct, so even though this optional
-    // field should be represented as an `Option`, that type is not
-    // FFI-safe, so it cannot be.
-    max_initialization_time: u16,
 }
 
 impl SandboxConfiguration {
@@ -92,24 +66,6 @@ impl SandboxConfiguration {
     pub const DEFAULT_OUTPUT_SIZE: usize = 0x4000;
     /// The minimum size of output data
     pub const MIN_OUTPUT_SIZE: usize = 0x2000;
-    /// The default value for max initialization time (in milliseconds)
-    pub const DEFAULT_MAX_INITIALIZATION_TIME: u16 = 2000;
-    /// The minimum value for max initialization time (in milliseconds)
-    pub const MIN_MAX_INITIALIZATION_TIME: u16 = 1;
-    /// The maximum value for max initialization time (in milliseconds)
-    pub const MAX_MAX_INITIALIZATION_TIME: u16 = u16::MAX;
-    /// The default and minimum values for max execution time (in milliseconds)
-    pub const DEFAULT_MAX_EXECUTION_TIME: u16 = 1000;
-    /// The minimum value for max execution time (in milliseconds)
-    pub const MIN_MAX_EXECUTION_TIME: u16 = 1;
-    /// The maximum value for max execution time (in milliseconds)
-    pub const MAX_MAX_EXECUTION_TIME: u16 = u16::MAX;
-    /// The default and minimum values for max wait for cancellation (in milliseconds)
-    pub const DEFAULT_MAX_WAIT_FOR_CANCELLATION: u8 = 100;
-    /// The minimum value for max wait for cancellation (in milliseconds)
-    pub const MIN_MAX_WAIT_FOR_CANCELLATION: u8 = 10;
-    /// The maximum value for max wait for cancellation (in milliseconds)
-    pub const MAX_MAX_WAIT_FOR_CANCELLATION: u8 = u8::MAX;
 
     #[allow(clippy::too_many_arguments)]
     /// Create a new configuration for a sandbox with the given sizes.
@@ -119,63 +75,14 @@ impl SandboxConfiguration {
         output_data_size: usize,
         stack_size_override: Option<u64>,
         heap_size_override: Option<u64>,
-        max_execution_time: Option<Duration>,
-        max_initialization_time: Option<Duration>,
-        max_wait_for_cancellation: Option<Duration>,
         #[cfg(gdb)] guest_debug_info: Option<DebugInfo>,
     ) -> Self {
         Self {
             input_data_size: max(input_data_size, Self::MIN_INPUT_SIZE),
             output_data_size: max(output_data_size, Self::MIN_OUTPUT_SIZE),
             stack_size_override: stack_size_override.unwrap_or(0),
             heap_size_override: heap_size_override.unwrap_or(0),
-            max_execution_time: {
-                match max_execution_time {
-                    Some(max_execution_time) => match max_execution_time.as_millis() {
-                        0 => Self::DEFAULT_MAX_EXECUTION_TIME,
-                        1.. => min(
-                            Self::MAX_MAX_EXECUTION_TIME.into(),
-                            max(
-                                max_execution_time.as_millis(),
-                                Self::MIN_MAX_EXECUTION_TIME.into(),
-                            ),
-                        ) as u16,
-                    },
-                    None => Self::DEFAULT_MAX_EXECUTION_TIME,
-                }
-            },
-            max_wait_for_cancellation: {
-                match max_wait_for_cancellation {
-                    Some(max_wait_for_cancellation) => {
-                        match max_wait_for_cancellation.as_millis() {
-                            0 => Self::DEFAULT_MAX_WAIT_FOR_CANCELLATION,
-                            1.. => min(
-                                Self::MAX_MAX_WAIT_FOR_CANCELLATION.into(),
-                                max(
-                                    max_wait_for_cancellation.as_millis(),
-                                    Self::MIN_MAX_WAIT_FOR_CANCELLATION.into(),
-                                ),
-                            ) as u8,
-                        }
-                    }
-                    None => Self::DEFAULT_MAX_WAIT_FOR_CANCELLATION,
-                }
-            },
-            max_initialization_time: {
-                match max_initialization_time {
-                    Some(max_initialization_time) => match max_initialization_time.as_millis() {
-                        0 => Self::DEFAULT_MAX_INITIALIZATION_TIME,
-                        1.. => min(
-                            Self::MAX_MAX_INITIALIZATION_TIME.into(),
-                            max(
-                                max_initialization_time.as_millis(),
-                                Self::MIN_MAX_INITIALIZATION_TIME.into(),
-                            ),
-                        ) as u16,
-                    },
-                    None => Self::DEFAULT_MAX_INITIALIZATION_TIME,
-                }
-            },
+
             #[cfg(gdb)]
             guest_debug_info,
         }
@@ -207,62 +114,6 @@ impl SandboxConfiguration {
         self.heap_size_override = heap_size;
     }
 
-    /// Set the maximum execution time of a guest function execution. If set to 0, the max_execution_time
-    /// will be set to the default value of DEFAULT_MAX_EXECUTION_TIME if the guest execution does not complete within the time specified
-    /// then the execution will be cancelled, the minimum value is MIN_MAX_EXECUTION_TIME
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub fn set_max_execution_time(&mut self, max_execution_time: Duration) {
-        match max_execution_time.as_millis() {
-            0 => self.max_execution_time = Self::DEFAULT_MAX_EXECUTION_TIME,
-            1.. => {
-                self.max_execution_time = min(
-                    Self::MAX_MAX_EXECUTION_TIME.into(),
-                    max(
-                        max_execution_time.as_millis(),
-                        Self::MIN_MAX_EXECUTION_TIME.into(),
-                    ),
-                ) as u16
-            }
-        }
-    }
-
-    /// Set the maximum time to wait for guest execution calculation. If set to 0, the maximum cancellation time
-    /// will be set to the default value of DEFAULT_MAX_WAIT_FOR_CANCELLATION if the guest execution cancellation does not complete within the time specified
-    /// then an error will be returned, the minimum value is MIN_MAX_WAIT_FOR_CANCELLATION
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub fn set_max_execution_cancel_wait_time(&mut self, max_wait_for_cancellation: Duration) {
-        match max_wait_for_cancellation.as_millis() {
-            0 => self.max_wait_for_cancellation = Self::DEFAULT_MAX_WAIT_FOR_CANCELLATION,
-            1.. => {
-                self.max_wait_for_cancellation = min(
-                    Self::MAX_MAX_WAIT_FOR_CANCELLATION.into(),
-                    max(
-                        max_wait_for_cancellation.as_millis(),
-                        Self::MIN_MAX_WAIT_FOR_CANCELLATION.into(),
-                    ),
-                ) as u8
-            }
-        }
-    }
-
-    /// Set the maximum time to wait for guest initialization. If set to 0, the maximum initialization time
-    /// will be set to the default value of DEFAULT_MAX_INITIALIZATION_TIME if the guest initialization does not complete within the time specified
-    /// then an error will be returned, the minimum value is MIN_MAX_INITIALIZATION_TIME
-    pub fn set_max_initialization_time(&mut self, max_initialization_time: Duration) {
-        match max_initialization_time.as_millis() {
-            0 => self.max_initialization_time = Self::DEFAULT_MAX_INITIALIZATION_TIME,
-            1.. => {
-                self.max_initialization_time = min(
-                    Self::MAX_MAX_INITIALIZATION_TIME.into(),
-                    max(
-                        max_initialization_time.as_millis(),
-                        Self::MIN_MAX_INITIALIZATION_TIME.into(),
-                    ),
-                ) as u16
-            }
-        }
-    }
-
     /// Sets the configuration for the guest debug
     #[cfg(gdb)]
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
@@ -280,20 +131,6 @@ impl SandboxConfiguration {
         self.output_data_size
     }
 
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn get_max_execution_time(&self) -> u16 {
-        self.max_execution_time
-    }
-
-    #[instrument(skip_all, parent = Span::current(), level= "Trace")]
-    pub(crate) fn get_max_wait_for_cancellation(&self) -> u8 {
-        self.max_wait_for_cancellation
-    }
-
-    pub(crate) fn get_max_initialization_time(&self) -> u16 {
-        self.max_initialization_time
-    }
-
     #[cfg(gdb)]
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub(crate) fn get_guest_debug_info(&self) -> Option<DebugInfo> {
@@ -335,9 +172,6 @@ impl Default for SandboxConfiguration {
             Self::DEFAULT_OUTPUT_SIZE,
             None,
             None,
-            None,
-            None,
-            None,
             #[cfg(gdb)]
             None,
         )
@@ -346,8 +180,6 @@ impl Default for SandboxConfiguration {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
-
     use super::SandboxConfiguration;
     use crate::testing::simple_guest_exe_info;
 
@@ -357,21 +189,11 @@ mod tests {
         const HEAP_SIZE_OVERRIDE: u64 = 0x50000;
         const INPUT_DATA_SIZE_OVERRIDE: usize = 0x4000;
         const OUTPUT_DATA_SIZE_OVERRIDE: usize = 0x4001;
-        const MAX_EXECUTION_TIME_OVERRIDE: u16 = 1010;
-        const MAX_WAIT_FOR_CANCELLATION_OVERRIDE: u8 = 200;
-        const MAX_INITIALIZATION_TIME_OVERRIDE: u16 = 2000;
         let mut cfg = SandboxConfiguration::new(
             INPUT_DATA_SIZE_OVERRIDE,
             OUTPUT_DATA_SIZE_OVERRIDE,
             Some(STACK_SIZE_OVERRIDE),
             Some(HEAP_SIZE_OVERRIDE),
-            Some(Duration::from_millis(MAX_EXECUTION_TIME_OVERRIDE as u64)),
-            Some(Duration::from_millis(
-                MAX_INITIALIZATION_TIME_OVERRIDE as u64,
-            )),
-            Some(Duration::from_millis(
-                MAX_WAIT_FOR_CANCELLATION_OVERRIDE as u64,
-            )),
             #[cfg(gdb)]
             None,
         );
@@ -388,15 +210,6 @@ mod tests {
         assert_eq!(2048, cfg.heap_size_override);
         assert_eq!(INPUT_DATA_SIZE_OVERRIDE, cfg.input_data_size);
         assert_eq!(OUTPUT_DATA_SIZE_OVERRIDE, cfg.output_data_size);
-        assert_eq!(MAX_EXECUTION_TIME_OVERRIDE, cfg.max_execution_time);
-        assert_eq!(
-            MAX_WAIT_FOR_CANCELLATION_OVERRIDE,
-            cfg.max_wait_for_cancellation
-        );
-        assert_eq!(
-            MAX_WAIT_FOR_CANCELLATION_OVERRIDE,
-            cfg.max_wait_for_cancellation
-        );
     }
 
     #[test]
@@ -406,57 +219,19 @@ mod tests {
             SandboxConfiguration::MIN_OUTPUT_SIZE - 1,
             None,
             None,
-            Some(Duration::from_millis(
-                SandboxConfiguration::MIN_MAX_EXECUTION_TIME as u64,
-            )),
-            Some(Duration::from_millis(
-                SandboxConfiguration::MIN_MAX_INITIALIZATION_TIME as u64,
-            )),
-            Some(Duration::from_millis(
-                SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION as u64 - 1,
-            )),
             #[cfg(gdb)]
             None,
         );
         assert_eq!(SandboxConfiguration::MIN_INPUT_SIZE, cfg.input_data_size);
         assert_eq!(SandboxConfiguration::MIN_OUTPUT_SIZE, cfg.output_data_size);
         assert_eq!(0, cfg.stack_size_override);
         assert_eq!(0, cfg.heap_size_override);
-        assert_eq!(
-            SandboxConfiguration::MIN_MAX_EXECUTION_TIME,
-            cfg.max_execution_time
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION,
-            cfg.max_wait_for_cancellation
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_MAX_EXECUTION_TIME,
-            cfg.max_initialization_time
-        );
 
         cfg.set_input_data_size(SandboxConfiguration::MIN_INPUT_SIZE - 1);
         cfg.set_output_data_size(SandboxConfiguration::MIN_OUTPUT_SIZE - 1);
-        cfg.set_max_execution_time(Duration::from_millis(
-            SandboxConfiguration::MIN_MAX_EXECUTION_TIME as u64,
-        ));
-        cfg.set_max_initialization_time(Duration::from_millis(
-            SandboxConfiguration::MIN_MAX_INITIALIZATION_TIME as u64 - 1,
-        ));
-        cfg.set_max_execution_cancel_wait_time(Duration::from_millis(
-            SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION as u64 - 1,
-        ));
 
         assert_eq!(SandboxConfiguration::MIN_INPUT_SIZE, cfg.input_data_size);
         assert_eq!(SandboxConfiguration::MIN_OUTPUT_SIZE, cfg.output_data_size);
-        assert_eq!(
-            SandboxConfiguration::MIN_MAX_EXECUTION_TIME,
-            cfg.max_execution_time
-        );
-        assert_eq!(
-            SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION,
-            cfg.max_wait_for_cancellation
-        );
     }
 
     mod proptests {
@@ -481,27 +256,6 @@ mod tests {
                 prop_assert_eq!(size, cfg.get_output_data_size());
             }
 
-            #[test]
-            fn max_execution_time(time in SandboxConfiguration::MIN_MAX_EXECUTION_TIME..=SandboxConfiguration::MIN_MAX_EXECUTION_TIME * 10) {
-                let mut cfg = SandboxConfiguration::default();
-                cfg.set_max_execution_time(std::time::Duration::from_millis(time.into()));
-                prop_assert_eq!(time, cfg.get_max_execution_time());
-            }
-
-            #[test]
-            fn max_wait_for_cancellation(time in SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION..=SandboxConfiguration::MIN_MAX_WAIT_FOR_CANCELLATION * 10) {
-                let mut cfg = SandboxConfiguration::default();
-                cfg.set_max_execution_cancel_wait_time(std::time::Duration::from_millis(time.into()));
-                prop_assert_eq!(time, cfg.get_max_wait_for_cancellation());
-            }
-
-            #[test]
-            fn max_initialization_time(time in SandboxConfiguration::MIN_MAX_INITIALIZATION_TIME..=SandboxConfiguration::MIN_MAX_INITIALIZATION_TIME * 10) {
-                let mut cfg = SandboxConfiguration::default();
-                cfg.set_max_initialization_time(std::time::Duration::from_millis(time.into()));
-                prop_assert_eq!(time, cfg.get_max_initialization_time());
-            }
-
             #[test]
             fn stack_size_override(size in 0x1000..=0x10000u64) {
                 let mut cfg = SandboxConfiguration::default();