Dev/wasmtime

.github/workflows/cargo-tests.yaml

@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       # test different available compute engines with different system engines
       matrix:
-        compute_driver: [ mmu, wasm ]
+        compute_driver: [ mmu, wasm, wasmtime-jit, wasmtime-precomp ]
         system_driver: [ hyper_io ]
     steps:
     # check out the code

README.md

@@ -96,4 +96,7 @@ RUSTFLAGS='-C target-feature=+crt-static -C link-arg=-Wl,-fuse-ld=lld,--image-ba
 Also make sure that shared memory objects are executable:
 ```
 sudo mount -o remount,exec /dev/shm
-```
+```
+
+### MMU worker path
+To use a `mmu_worker` that is not at the original location it was built in, set the `PROCESS_WORKER_PATH` environment variable to point to the desired binary

dandelion_commons/src/lib.rs

@@ -23,6 +23,8 @@ pub enum DandelionError {
     ContextMissmatch,
     /// domain could not be allocated because there is no space available
     OutOfMemory,
+    /// memory size is not allowed, e.g. Wasm memory must be <= 4GiB
+    InvalidMemorySize,
     /// context can't fit additional memory
     ContextFull,
     /// read buffer was misaligned for requested data type

dispatcher/Cargo.toml

@@ -11,8 +11,11 @@ dandelion_commons = {path = "../dandelion_commons"}
 machine_interface = {path = "../machine_interface"}
 futures = {version = "0.3.28", default-features = false}
 itertools = {version = "0.11", default-features = false, features = ["use_alloc"]}
+async-lock = "3.1"
 
 [features]
 cheri = ["machine_interface/cheri"]
+mmu = ["machine_interface/mmu"]
 wasm = ["machine_interface/wasm"]
-mmu = ["machine_interface/mmu"]
+wasmtime-jit = ["machine_interface/wasmtime-jit"]
+wasmtime-precomp = ["machine_interface/wasmtime-precomp"]

dispatcher/src/function_registry.rs

@@ -1,3 +1,4 @@
+use async_lock::RwLock;
 use dandelion_commons::{DandelionError, DandelionResult, EngineTypeId, FunctionId};
 use machine_interface::{
     function_driver::{Driver, Function, FunctionConfig},

dispatcher/tests/dispatcher_tests.rs

@@ -1,4 +1,4 @@
-#[cfg(all(test, any(feature = "cheri", feature = "mmu", feature = "wasm")))]
+#[cfg(all(test, any(feature = "cheri", feature = "mmu", feature = "wasm", feature = "wasmtime-jit", feature = "wasmtime-precomp")))]
 mod dispatcher_tests {
     mod function_tests;
     mod registry_tests;
@@ -190,4 +190,13 @@ mod dispatcher_tests {
         #[cfg(target_arch = "aarch64")]
         dispatcherTests!(sysld_wasm_aarch64; WasmMemoryDomain; Vec::new(); WasmDriver {}; vec![ComputeResource::CPU(1)]);
     }
+
+    #[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+    mod wasmtime {
+        use machine_interface::{
+            function_driver::{compute_driver::wasmtime::WasmtimeDriver, ComputeResource},
+            memory_domain::wasmtime::WasmtimeMemoryDomain,
+        };
+        dispatcherTests!(wasm; WasmtimeMemoryDomain; Vec::new(); WasmtimeDriver {}; vec![ComputeResource::CPU(1)]);
+    }
 }

machine_interface/Cargo.toml

@@ -9,6 +9,8 @@ cheri = ["std"]
 mmu = ["std"]
 hyper_io = ["std", "dep:hyper"]
 wasm = ["std"]
+wasmtime-jit = ["std", "dep:wasmtime"]
+wasmtime-precomp = ["std", "dep:wasmtime"]
 
 [build-dependencies]
 cmake = "0.1"
@@ -32,6 +34,7 @@ tokio = { version = "1", features = ["full"] }
 hyper = { version = "0.14", optional = true, features = ["http1", "http2", "client", "runtime"]}
 libloading = { version = "0.8.1" }
 log = "0.4.20"
+wasmtime = { version = "15.0.1", optional = true, default-features = false, features = ["cranelift", "cache"]}
 
 # disable benchmarks in library, to not run all unit tests on every benchmark
 # also needs to be disabled for criterion flags to work that are not available for tests

machine_interface/build.rs

@@ -0,0 +1,21 @@
+fn main() {
+    // check if cheri is enabled and build library if so
+    #[cfg(feature = "cheri")]
+    {
+        use cmake::Config;
+        // cmake configure and build all
+        let _all = Config::new("c_machine_libraries")
+            .define("FORCE_BUILD_CHERI", "")
+            .build_target("all")
+            .build();
+        // run tests tests
+        let _test = Config::new("c_machine_libraries")
+            .build_target("test")
+            .build();
+        // install
+        let install = Config::new("c_machine_libraries").build();
+        // passing cmake information to c
+        println!("cargo:rustc-link-search=native={}", install.display());
+        println!("cargo:rustc-link-lib=static=cheri_lib");
+    }
+}

machine_interface/src/function_driver.rs

@@ -1,18 +1,25 @@
 use crate::{
-    memory_domain::{Context, MemoryDomain},
+    memory_domain::{Context, ContextType, MemoryDomain},
     DataRequirementList, Position,
 };
 use core::pin::Pin;
-use dandelion_commons::{records::Recorder, DandelionResult};
+use dandelion_commons::{records::Recorder, DandelionResult, DandelionError};
 use std::{future::Future, sync::Arc};
 
+#[cfg(feature = "wasm")]
 use libloading::Library;
 
+#[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+use wasmtime;
+#[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+use crate::function_driver::compute_driver::wasmtime as wasmtime_driver;
+
 pub mod compute_driver;
 mod load_utils;
 pub mod system_driver;
 mod thread_utils;
 
+#[cfg(any(feature = "mmu", feature = "cheri"))]
 #[derive(Clone)]
 pub struct ElfConfig {
     // TODO change to positions
@@ -28,6 +35,7 @@ pub enum SystemFunction {
     HTTP,
 }
 
+#[cfg(feature = "wasm")]
 #[derive(Clone)]
 pub struct WasmConfig {
     lib: Arc<Library>,
@@ -37,11 +45,25 @@ pub struct WasmConfig {
     system_data_struct_offset: usize,
 }
 
+#[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+#[derive(Clone)]
+pub struct WasmtimeConfig {
+    precompiled_module: Vec<u8>,
+    total_mem_size: usize,
+    sdk_heap_base: usize,
+    system_data_struct_offset: usize,
+    wasmtime_engine: wasmtime::Engine,  // engine can be shared across threads
+}
+
 #[derive(Clone)]
 pub enum FunctionConfig {
+    #[cfg(any(feature = "mmu", feature = "cheri"))]
     ElfConfig(ElfConfig),
     SysConfig(SystemFunction),
+    #[cfg(feature = "wasm")]
     WasmConfig(WasmConfig),
+    #[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+    WasmtimeConfig(WasmtimeConfig),
 }
 
 pub struct Function {
@@ -53,15 +75,21 @@ pub struct Function {
 impl Function {
     pub fn load(&self, domain: &Box<dyn MemoryDomain>) -> DandelionResult<Context> {
         return match &self.config {
+            #[cfg(any(feature = "mmu", feature = "cheri"))]
             FunctionConfig::ElfConfig(_) => {
                 load_utils::load_static(domain, &self.context, &self.requirements)
-            }
+            },
             FunctionConfig::SysConfig(_) => domain.acquire_context(self.requirements.size),
+            #[cfg(feature = "wasm")]
             FunctionConfig::WasmConfig(c) => {
                 let mut context = domain.acquire_context(c.wasm_mem_size)?;
                 context.occupy_space(0, c.sdk_heap_base)?;
                 Ok(context)
-            }
+            },
+            #[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+            FunctionConfig::WasmtimeConfig(c) => {
+                wasmtime_driver::load_context(c, domain)
+            },
         };
     }
 }

machine_interface/src/function_driver/compute_driver.rs

@@ -7,5 +7,8 @@ pub mod mmu;
 #[cfg(feature = "wasm")]
 pub mod wasm;
 
+#[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+pub mod wasmtime;
+
 #[cfg(test)]
 mod compute_driver_tests;

machine_interface/src/function_driver/compute_driver/compute_driver_tests.rs

@@ -1,4 +1,4 @@
-#[cfg(all(test, any(feature = "cheri", feature = "mmu", feature = "wasm")))]
+#[cfg(all(test, any(feature = "cheri", feature = "mmu", feature = "wasm", feature = "wasmtime-jit", feature = "wasmtime-precomp")))]
 mod compute_driver_tests {
     use crate::{
         function_driver::{ComputeResource, Driver, Engine, FunctionConfig},
@@ -630,4 +630,47 @@ mod compute_driver_tests {
             ComputeResource::GPU(0),
         ]);
     }
-}
+
+    #[cfg(any(feature = "wasmtime-jit", feature = "wasmtime-precomp"))]
+    mod wasmtime {
+        use crate::function_driver::compute_driver::wasmtime::WasmtimeDriver;
+        use crate::function_driver::ComputeResource;
+        use crate::memory_domain::wasmtime::WasmtimeMemoryDomain;
+
+        #[cfg(feature = "wasmtime-jit")]
+        driverTests!(wasm; WasmtimeMemoryDomain; Vec::new(); WasmtimeDriver {};
+        vec![
+            ComputeResource::CPU(1),
+            ComputeResource::CPU(2),
+            ComputeResource::CPU(3),
+        ];
+        vec![
+            ComputeResource::CPU(255),
+            ComputeResource::GPU(0),
+        ]);
+
+        #[cfg(all(feature = "wasmtime-precomp", target_arch = "x86_64"))]
+        driverTests!(wasmtime_x86_64; WasmtimeMemoryDomain; Vec::new(); WasmtimeDriver {};
+        vec![
+            ComputeResource::CPU(1),
+            ComputeResource::CPU(2),
+            ComputeResource::CPU(3),
+        ];
+        vec![
+            ComputeResource::CPU(255),
+            ComputeResource::GPU(0),
+        ]);
+
+        #[cfg(all(feature = "wasmtime-precomp", target_arch = "aarch64"))]
+        driverTests!(wasmtime_aarch64; WasmtimeMemoryDomain; Vec::new(); WasmtimeDriver {};
+        vec![
+            ComputeResource::CPU(1),
+            ComputeResource::CPU(2),
+            ComputeResource::CPU(3),
+        ];
+        vec![
+            ComputeResource::CPU(255),
+            ComputeResource::GPU(0),
+        ]);
+    }
+}

machine_interface/src/function_driver/compute_driver/mmu.rs

@@ -165,8 +165,7 @@ fn mmu_run_static(
     // that will not collide with those used by user's function
 
     // this trick gives the desired path of mmu_worker for packages within the workspace
-    // TODO: replace with a more general solution (e.g. environment variable)
-    let path = format!(
+    let path = std::env::var("PROCESS_WORKER_PATH").unwrap_or(format!(
         "{}/../target/{}-unknown-linux-gnu/{}/mmu_worker",
         env!("CARGO_MANIFEST_DIR"),
         std::env::consts::ARCH,
@@ -175,7 +174,7 @@ fn mmu_run_static(
         } else {
             "release"
         },
-    );
+    ));
 
     // create a new address space (child process) and pass the shared memory
     let mut worker = Command::new(path)

machine_interface/src/function_driver/compute_driver/wasm.rs

@@ -20,11 +20,12 @@ use libloading::{Library, Symbol};
 use log::error;
 use std::sync::{Arc, Mutex};
 
-type WasmEntryPoint = fn(&mut [u8]) -> Option<i32>;
+type WasmEntryPoint = fn(&mut [u8], usize) -> Option<i32>;
 
 struct WasmCommand {
     lib: Arc<Library>,
     context: Arc<Mutex<Option<Context>>>,
+    sysdata_offset: usize,
 }
 unsafe impl Send for WasmCommand {}
 
@@ -45,7 +46,8 @@ impl ThreadPayload for WasmCommand {
                 };
 
                 // call entry point
-                let ret = entry_point(&mut wasm_context.mem);
+                let ret = entry_point(&mut wasm_context.mem, self.sysdata_offset);
+
                 // put context back
                 *guard = Some(ctx);
 
@@ -140,6 +142,7 @@ impl Engine for WasmEngine {
             WasmCommand {
                 context: context_.clone(),
                 lib: wasm_config.lib.clone(),
+                sysdata_offset: wasm_config.system_data_struct_offset,
             },
         );