Add FunctionCall serialization benchmarks

and a c+rust sample workload benchmark

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

Author: ludfjig

src/hyperlight_host/benches/benchmarks.rs

@@ -15,9 +15,11 @@ limitations under the License.
 */
 
 use criterion::{Criterion, criterion_group, criterion_main};
+use hyperlight_common::flatbuffer_wrappers::function_call::{FunctionCall, FunctionCallType};
+use hyperlight_common::flatbuffer_wrappers::function_types::{ParameterValue, ReturnType};
 use hyperlight_host::GuestBinary;
 use hyperlight_host::sandbox::{MultiUseSandbox, SandboxConfiguration, UninitializedSandbox};
-use hyperlight_testing::simple_guest_as_string;
+use hyperlight_testing::{c_simple_guest_as_string, simple_guest_as_string};
 
 fn create_uninit_sandbox() -> UninitializedSandbox {
     let path = simple_guest_as_string().unwrap();
@@ -133,9 +135,85 @@ fn sandbox_benchmark(c: &mut Criterion) {
     group.finish();
 }
 
+fn function_call_serialization_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("function_call_serialization");
+
+    let function_call = FunctionCall::new(
+        "TestFunction".to_string(),
+        Some(vec![
+            ParameterValue::VecBytes(vec![1; 10 * 1024 * 1024]),
+            ParameterValue::String(String::from_utf8(vec![2; 10 * 1024 * 1024]).unwrap()),
+            ParameterValue::Int(42),
+            ParameterValue::UInt(100),
+            ParameterValue::Long(1000),
+            ParameterValue::ULong(2000),
+            ParameterValue::Float(521521.53),
+            ParameterValue::Double(432.53),
+            ParameterValue::Bool(true),
+            ParameterValue::VecBytes(vec![1; 10 * 1024 * 1024]),
+            ParameterValue::String(String::from_utf8(vec![2; 10 * 1024 * 1024]).unwrap()),
+        ]),
+        FunctionCallType::Guest,
+        ReturnType::Int,
+    );
+
+    let serialized_bytes: Vec<u8> = function_call.clone().try_into().unwrap();
+
+    group.bench_function("serialize_function_call", |b| {
+        b.iter_with_setup(
+            || function_call.clone(),
+            |fc| {
+                let _serialized: Vec<u8> = fc.try_into().unwrap();
+            },
+        );
+    });
+
+    group.bench_function("deserialize_function_call", |b| {
+        b.iter(|| {
+            let _deserialized: FunctionCall = serialized_bytes.as_slice().try_into().unwrap();
+        });
+    });
+
+    group.finish();
+}
+
+#[allow(clippy::disallowed_macros)]
+fn sample_workloads_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("sample_workloads");
+
+    fn bench_24k_in_8k_out(b: &mut criterion::Bencher, guest_path: String) {
+        let mut cfg = SandboxConfiguration::default();
+        cfg.set_input_data_size(25 * 1024);
+
+        let mut sandbox = UninitializedSandbox::new(GuestBinary::FilePath(guest_path), Some(cfg))
+            .unwrap()
+            .evolve()
+            .unwrap();
+
+        b.iter_with_setup(
+            || vec![1; 24 * 1024],
+            |input| {
+                let ret: Vec<u8> = sandbox.call("24K_in_8K_out", (input,)).unwrap();
+                assert_eq!(ret.len(), 8 * 1024, "Expected output length to be 8K");
+                std::hint::black_box(ret);
+            },
+        );
+    }
+
+    group.bench_function("24K_in_8K_out_c", |b| {
+        bench_24k_in_8k_out(b, c_simple_guest_as_string().unwrap());
+    });
+
+    group.bench_function("24K_in_8K_out_rust", |b| {
+        bench_24k_in_8k_out(b, simple_guest_as_string().unwrap());
+    });
+
+    group.finish();
+}
+
 criterion_group! {
     name = benches;
     config = Criterion::default();
-    targets = guest_call_benchmark, sandbox_benchmark, guest_call_benchmark_large_param
+    targets = guest_call_benchmark, sandbox_benchmark, guest_call_benchmark_large_param, function_call_serialization_benchmark, sample_workloads_benchmark
 }
 criterion_main!(benches);

src/tests/c_guests/c_simpleguest/main.c

@@ -4,6 +4,7 @@
 #include "stdint.h"
 #include "string.h"
 #include "stdlib.h"
+#include "assert.h"
 // Included from hyperlight_guest_bin/third_party/printf
 #include "printf.h"
 
@@ -232,6 +233,12 @@ int log_message(const char *message, int64_t level) {
   return -1;
 }
 
+hl_Vec *twenty_four_k_in_eight_k_out(const hl_FunctionCall* params) {
+  hl_Vec input = params->parameters[0].value.VecBytes;
+  assert(input.len == 24 * 1024);
+  return hl_flatbuffer_result_from_Bytes(input.data, 8 * 1024);
+}
+
 HYPERLIGHT_WRAP_FUNCTION(echo, String, 1, String)
 // HYPERLIGHT_WRAP_FUNCTION(set_byte_array_to_zero, 1, VecBytes) is not valid for functions that return VecBytes
 HYPERLIGHT_WRAP_FUNCTION(print_output, Int, 1, String)
@@ -260,6 +267,7 @@ HYPERLIGHT_WRAP_FUNCTION(guest_abort_with_msg, Int, 2, Int, String)
 HYPERLIGHT_WRAP_FUNCTION(guest_abort_with_code, Int, 1, Int)
 HYPERLIGHT_WRAP_FUNCTION(execute_on_stack, Int, 0)
 HYPERLIGHT_WRAP_FUNCTION(log_message, Int, 2, String, Long)
+// HYPERLIGHT_WRAP_FUNCTION(twenty_four_k_in_eight_k_out, VecBytes, 1, VecBytes) is not valid for functions that return VecBytes
 
 void hyperlight_main(void)
 {
@@ -295,6 +303,9 @@ void hyperlight_main(void)
     HYPERLIGHT_REGISTER_FUNCTION("GuestAbortWithMessage", guest_abort_with_msg);
     HYPERLIGHT_REGISTER_FUNCTION("ExecuteOnStack", execute_on_stack);
     HYPERLIGHT_REGISTER_FUNCTION("LogMessage", log_message);
+    // HYPERLIGHT_REGISTER_FUNCTION macro does not work for functions that return VecBytes,
+    // so we use hl_register_function_definition directly
+    hl_register_function_definition("24K_in_8K_out", twenty_four_k_in_eight_k_out, 1, (hl_ParameterType[]){hl_ParameterType_VecBytes}, hl_ReturnType_VecBytes);
 }
 
 // This dispatch function is only used when the host dispatches a guest function

src/tests/rust_guests/simpleguest/src/main.rs

@@ -725,6 +725,19 @@ fn add_to_static_and_fail(_: &FunctionCall) -> Result<Vec<u8>> {
     ))
 }
 
+#[hyperlight_guest_tracing::trace_function]
+fn twenty_four_k_in_eight_k_out(function_call: &FunctionCall) -> Result<Vec<u8>> {
+    if let ParameterValue::VecBytes(input) = &function_call.parameters.as_ref().unwrap()[0] {
+        assert!(input.len() == 24 * 1024, "Input must be 24K bytes");
+        Ok(get_flatbuffer_result(&input[..8 * 1024]))
+    } else {
+        Err(HyperlightGuestError::new(
+            ErrorCode::GuestFunctionParameterTypeMismatch,
+            "Invalid parameters passed to 24K_in_8K_out".to_string(),
+        ))
+    }
+}
+
 #[hyperlight_guest_tracing::trace_function]
 fn violate_seccomp_filters(function_call: &FunctionCall) -> Result<Vec<u8>> {
     if function_call.parameters.is_none() {
@@ -901,6 +914,14 @@ fn exec_mapped_buffer(function_call: &FunctionCall) -> Result<Vec<u8>> {
 #[no_mangle]
 #[hyperlight_guest_tracing::trace_function]
 pub extern "C" fn hyperlight_main() {
+    let twenty_four_k_in_def = GuestFunctionDefinition::new(
+        "24K_in_8K_out".to_string(),
+        Vec::from(&[ParameterType::VecBytes]),
+        ReturnType::VecBytes,
+        twenty_four_k_in_eight_k_out as usize,
+    );
+    register_function(twenty_four_k_in_def);
+
     let read_from_user_memory_def = GuestFunctionDefinition::new(
         "ReadFromUserMemory".to_string(),
         Vec::from(&[ParameterType::ULong, ParameterType::VecBytes]),