start building a component for benchmarking

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

Author: jsturtevant

src/hyperlight_wasm/Cargo.toml

@@ -84,3 +84,8 @@ mshv3 = ["hyperlight-host/mshv3"]
 [[bench]]
 name = "benchmarks"
 harness = false
+
+[[bench]]
+name = "benchmarks_components"
+harness = false
+

src/hyperlight_wasm/benches/benchmarks_components.rs

@@ -0,0 +1,61 @@
+use criterion::{Bencher, Criterion, criterion_group, criterion_main};
+use hyperlight_host::HyperlightError;
+use hyperlight_wasm::{LoadedWasmSandbox, Result, SandboxBuilder};
+
+fn wasm_component_guest_call_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("wasm_component_guest_functions");
+
+    // let bench_guest_function = |b: &mut Bencher<'_>, ext| {
+    //     let mut loaded_wasm_sandbox = get_loaded_wasm_sandbox(ext);
+
+    //     b.iter(|| {
+    //         loaded_wasm_sandbox
+    //             .call_guest_function::<String>("Echo", "Hello World!".to_string())
+    //             .unwrap()
+    //     });
+    // };
+
+    // group.bench_function("wasm_guest_call", |b: &mut Bencher<'_>| {
+    //     bench_guest_function(b, "wasm");
+    // });
+
+    // group.bench_function("wasm_guest_call_aot", |b: &mut Bencher<'_>| {
+    //     bench_guest_function(b, "aot");
+    // });
+
+    group.finish();
+}
+
+fn wasm_component_sandbox_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("wasm_component_sandboxes");
+    let create_wasm_sandbox = || {
+        get_loaded_wasm_sandbox("wasm");
+    };
+
+    group.bench_function("create_sandbox", |b| {
+        b.iter_with_large_drop(create_wasm_sandbox);
+    });
+
+    group.bench_function("create_sandbox_and_drop", |b| {
+        b.iter(create_wasm_sandbox);
+    });
+
+    group.finish();
+}
+
+fn get_loaded_wasm_sandbox(ext: &str) -> LoadedWasmSandbox {
+    let mut sandbox = SandboxBuilder::new().build().unwrap();
+
+    let wasm_sandbox = sandbox.load_runtime().unwrap();
+
+    wasm_sandbox
+        .load_module(format!("../../x64/release/component_sample.aot",))
+        .unwrap()
+}
+
+criterion_group! {
+    name = benches_components;
+    config = Criterion::default();//.warm_up_time(Duration::from_millis(50)); // If warm_up_time is default 3s warmup, the benchmark will fail due memory error
+    targets = wasm_component_guest_call_benchmark, wasm_component_sandbox_benchmark
+}
+criterion_main!(benches_components);

src/hyperlight_wasm/scripts/build-wasm-examples.sh

@@ -33,17 +33,26 @@ else
 
     docker build --build-arg GCC_VERSION=12 --build-arg WASI_SDK_VERSION_FULL=20.0 --cache-from ghcr.io/hyperlight-dev/wasm-clang-builder:latest -t wasm-clang-builder:latest . 2> ${OUTPUT_DIR}/dockerbuild.log
 
-    for FILENAME in $(find . -name '*.c')
+    for FILENAME in $(find . -name '*.c' -not -path './components/*')
     do
         echo Building ${FILENAME}
         # Build the wasm file with wasi-libc for wasmtime
-        docker run --rm -i -v "${PWD}:/tmp/host" -v "${OUTPUT_DIR}:/tmp/output" wasm-clang-builder:latest /opt/wasi-sdk/bin/clang -flto -ffunction-sections -mexec-model=reactor -O3 -z stack-size=4096 -Wl,--initial-memory=65536 -Wl,--export=__data_end -Wl,--export=__heap_base,--export=malloc,--export=free,--export=__wasm_call_ctors -Wl,--strip-all,--no-entry -Wl,--allow-undefined -Wl,--gc-sections  -o /tmp/output/${FILENAME%.*}-wasi-libc.wasm /tmp/host/${FILENAME}
+        docker run --rm -i -v "${PWD}:/tmp/host" -v "${OUTPUT_DIR}:/tmp/output/" wasm-clang-builder:latest /opt/wasi-sdk/bin/clang -flto -ffunction-sections -mexec-model=reactor -O3 -z stack-size=4096 -Wl,--initial-memory=65536 -Wl,--export=__data_end -Wl,--export=__heap_base,--export=malloc,--export=free,--export=__wasm_call_ctors -Wl,--strip-all,--no-entry -Wl,--allow-undefined -Wl,--gc-sections  -o /tmp/output/${FILENAME%.*}-wasi-libc.wasm /tmp/host/${FILENAME}
 
         # Build AOT for Wasmtime; note that Wasmtime does not support
         # interpreting, so its wasm binary is secretly an AOT binary.
         cargo run -p hyperlight-wasm-aot compile ${OUTPUT_DIR}/${FILENAME%.*}-wasi-libc.wasm ${OUTPUT_DIR}/${FILENAME%.*}.aot
         cp ${OUTPUT_DIR}/${FILENAME%.*}.aot ${OUTPUT_DIR}/${FILENAME%.*}.wasm
     done
+
+    echo Building component
+    # Build the wasm file with wasi-libc for wasmtime
+    docker run --rm -i -v "${PWD}:/tmp/host" -v "${OUTPUT_DIR}:/tmp/output/" wasm-clang-builder:latest /opt/wasi-sdk/bin/clang -flto -ffunction-sections -mexec-model=reactor -O3 -z stack-size=4096 -Wl,--initial-memory=65536 -Wl,--export=__data_end -Wl,--export=__heap_base,--export=malloc,--export=free -o /tmp/output/runcomponent-p1.wasm /tmp/host/components/component.c /tmp/host/components/runcomponent.c  /tmp/host/components/runcomponent_component_type.o
+
+    # Build AOT for Wasmtime; note that Wasmtime does not support
+    # interpreting, so its wasm binary is secretly an AOT binary.
+    cargo run -p hyperlight-wasm-aot compile ${OUTPUT_DIR}/runcomponent-p1.wasm ${OUTPUT_DIR}/runcomponent.aot
+    cp ${OUTPUT_DIR}/runcomponent.aot ${OUTPUT_DIR}/runcomponent.wasm
 fi
 
 popd

src/wasmsamples/components/component.c

@@ -0,0 +1,11 @@
+#include "runcomponent.h"
+#include <stdlib.h>
+#include <string.h>
+
+void exports_example_runcomponent_guest_echo(runcomponent_string_t *msg, runcomponent_string_t *ret)
+{
+  ret->len = msg->len;
+  ret->ptr = (uint8_t *) malloc(ret->len);
+  memcpy(ret->ptr, msg->ptr, ret->len);
+  runcomponent_string_free(msg);
+}

src/wasmsamples/components/runcomponent.c

@@ -0,0 +1,78 @@
+// Generated by `wit-bindgen` 0.38.0. DO NOT EDIT!
+#include "runcomponent.h"
+#include <stdlib.h>
+#include <string.h>
+
+// Imported Functions from `example:runcomponent/host@0.1.0`
+
+__attribute__((__import_module__("example:runcomponent/host@0.1.0"), __import_name__("get-time-since-boot-microsecond")))
+extern int64_t __wasm_import_example_runcomponent_host_get_time_since_boot_microsecond(void);
+
+// Exported Functions from `example:runcomponent/guest@0.1.0`
+
+__attribute__((__weak__, __export_name__("cabi_post_example:runcomponent/guest@0.1.0#echo")))
+void __wasm_export_exports_example_runcomponent_guest_echo_post_return(uint8_t * arg0) {
+  if ((*((size_t*) (arg0 + 4))) > 0) {
+    free(*((uint8_t **) (arg0 + 0)));
+  }
+}
+
+// Canonical ABI intrinsics
+
+__attribute__((__weak__, __export_name__("cabi_realloc")))
+void *cabi_realloc(void *ptr, size_t old_size, size_t align, size_t new_size) {
+  (void) old_size;
+  if (new_size == 0) return (void*) align;
+  void *ret = realloc(ptr, new_size);
+  if (!ret) abort();
+  return ret;
+}
+
+// Helper Functions
+
+void runcomponent_string_set(runcomponent_string_t *ret, const char*s) {
+  ret->ptr = (uint8_t*) s;
+  ret->len = strlen(s);
+}
+
+void runcomponent_string_dup(runcomponent_string_t *ret, const char*s) {
+  ret->len = strlen(s);
+  ret->ptr = (uint8_t*) cabi_realloc(NULL, 0, 1, ret->len * 1);
+  memcpy(ret->ptr, s, ret->len * 1);
+}
+
+void runcomponent_string_free(runcomponent_string_t *ret) {
+  if (ret->len > 0) {
+    free(ret->ptr);
+  }
+  ret->ptr = NULL;
+  ret->len = 0;
+}
+
+// Component Adapters
+
+__attribute__((__aligned__(4)))
+static uint8_t RET_AREA[8];
+
+int64_t example_runcomponent_host_get_time_since_boot_microsecond(void) {
+  int64_t ret = __wasm_import_example_runcomponent_host_get_time_since_boot_microsecond();
+  return ret;
+}
+
+__attribute__((__export_name__("example:runcomponent/guest@0.1.0#echo")))
+uint8_t * __wasm_export_exports_example_runcomponent_guest_echo(uint8_t * arg, size_t arg0) {
+  runcomponent_string_t arg1 = (runcomponent_string_t) { (uint8_t*)(arg), (arg0) };
+  runcomponent_string_t ret;
+  exports_example_runcomponent_guest_echo(&arg1, &ret);
+  uint8_t *ptr = (uint8_t *) &RET_AREA;
+  *((size_t*)(ptr + 4)) = (ret).len;
+  *((uint8_t **)(ptr + 0)) = (uint8_t *) (ret).ptr;
+  return ptr;
+}
+
+// Ensure that the *_component_type.o object is linked in
+
+extern void __component_type_object_force_link_runcomponent(void);
+void __component_type_object_force_link_runcomponent_public_use_in_this_compilation_unit(void) {
+  __component_type_object_force_link_runcomponent();
+}

src/wasmsamples/components/runcomponent.h

@@ -0,0 +1,39 @@
+// Generated by `wit-bindgen` 0.38.0. DO NOT EDIT!
+#ifndef __BINDINGS_RUNCOMPONENT_H
+#define __BINDINGS_RUNCOMPONENT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct runcomponent_string_t {
+  uint8_t*ptr;
+  size_t len;
+} runcomponent_string_t;
+
+// Imported Functions from `example:runcomponent/host@0.1.0`
+extern int64_t example_runcomponent_host_get_time_since_boot_microsecond(void);
+
+// Exported Functions from `example:runcomponent/guest@0.1.0`
+void exports_example_runcomponent_guest_echo(runcomponent_string_t *msg, runcomponent_string_t *ret);
+
+// Helper Functions
+
+// Transfers ownership of `s` into the string `ret`
+void runcomponent_string_set(runcomponent_string_t *ret, const char*s);
+
+// Creates a copy of the input nul-terminate string `s` and
+// stores it into the component model string `ret`.
+void runcomponent_string_dup(runcomponent_string_t *ret, const char*s);
+
+// Deallocates the string pointed to by `ret`, deallocating
+// the memory behind the string.
+void runcomponent_string_free(runcomponent_string_t *ret);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

src/wasmsamples/components/runcomponent.wit

@@ -0,0 +1,14 @@
+package example:runcomponent@0.1.0;
+
+interface guest {
+    echo: func(msg: string) -> string;
+}
+
+interface host {
+    get-time-since-boot-microsecond: func() -> s64;
+}
+
+world runcomponent {
+    export guest;
+    import host;
+}