Dev/gpu

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "unity/source"]
 	path = machine_interface/c_machine_libraries/unity/source
-	url = https://github.com/ThrowTheSwitch/Unity.git
+	url = git@github.com:ThrowTheSwitch/Unity.git
 [submodule "http"]
 	path = net/http
-	url = https://github.com/cesanta/mongoose.git
+	url = git@github.com:cesanta/mongoose.git

README.md

@@ -111,3 +111,22 @@ 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
+
+## GPU worker build
+
+The `gpu_worker` binary required by the `gpu_process` is assumed to be present in corresponding `target` directory:
+```
+cargo build --bin gpu_worker --features gpu_process --target $(arch)-unknown-linux-gnu [--release]
+```
+
+Also make sure that shared memory objects are executable:
+```
+sudo mount -o remount,exec /dev/shm
+```
+
+### GPU worker path
+
+To use a `gpu_worker` that is not at the original location it was built in, set the `GPU_WORKER_PATH` environment variable to point to the desired binary
+
+## GPU engine library path
+`DANDELION_LIBRARY_PATH` overwrites the directory where the GPU engines will look for kernel libraries. If the variable is unset the engines will look in `machine_interface/tests/libs/`.

dandelion_commons/src/lib.rs

@@ -124,6 +124,15 @@ pub enum DandelionError {
     // Frontend errors
     /// Error in the frontend receiveing requests
     RequestError(FrontendError),
+    // GPU engine specfific errors
+    /// error from HIP Runtime
+    HipError(String),
+    /// identifier used in config file was not declared before
+    UndeclaredIdentifier(String),
+    /// argument given to the FromInput sizing was out of bounds
+    FromInputOutOfBounds,
+    /// could not deserialise JSON for config
+    ParsingJSONError(String),
 }
 
 // Implement display to be compliant with core::error::Error

dispatcher/src/dispatcher.rs

@@ -476,6 +476,7 @@ impl Dispatcher {
                 }
             }
         }
+
         for (function_set, context_set) in inputs {
             if static_sets.contains(&function_set) {
                 trace!(

machine_interface/Cargo.toml

@@ -12,12 +12,15 @@ reqwest_io = ["std", "dep:reqwest", "dep:http", "dep:bytes"]
 bytes_context = ["std", "dep:bytes"]
 wasm = ["std"]
 timestamp = ["dandelion_commons/timestamp"]
+gpu = ["std"]
+gpu_process = ["gpu"]
+gpu_thread = ["gpu"]
 
 [build-dependencies]
 cmake = "0.1"
 
 [dev-dependencies]
-criterion = "0.4"
+criterion = { version = "0.4", features = ["html_reports"] }
 # need to lock this to older version, because morello does not yet have rustc 1.6
 regex = "1.7.1"
 
@@ -27,16 +30,17 @@ dandelion_commons = { path = "../dandelion_commons" }
 libc = "0.2"
 nix = "0.26"
 rand = "0.8"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
 core_affinity = { version = "0.8"}
 futures = { version = "0.3.28" }
-tokio = { version = "1", features = ["full"] }
+tokio = { version = ">=1.3.7, <2.0.0", features = ["full"] } # need at least 1.3.7 for Semaphore.forget_tickets()
 reqwest = { version = "0.12", optional = true }
 http = { version = "1.1", optional = true }
 bytes = { version = "1.6", optional = true}
 libloading = { version = "0.8.1" }
 log = "0.4.20"
+lazy_static = "1.4.0"
 
 # 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
@@ -47,10 +51,14 @@ bench = false
 name = "mmu_worker"
 required-features = ["mmu"]
 
+[[bin]]
+name = "gpu_worker"
+required-features = ["gpu"]
+
 [[bench]]
 name = "cheri_benchmark"
 harness = false
 
 [[bench]]
 name = "mmu_benchmark"
-harness = false
+harness = false

machine_interface/build.rs

@@ -1,21 +1,33 @@
-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");
-    }
-}
+use cmake::Config;
+
+fn cmake_libraries() -> () {
+    // 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");
+}
+
+fn libraries_gpu() {
+    // Link with HIP Runtime 5.7.1
+    println!("cargo:rustc-link-search=/opt/rocm-5.7.1/lib");
+    println!("cargo:rustc-link-lib=amdhip64");
+}
+
+fn main() {
+    // check if cheri is enabled and build library if so
+    #[cfg(feature = "cheri")]
+    cmake_libraries();
+
+    #[cfg(feature = "gpu")]
+    libraries_gpu();
+}

machine_interface/src/bin/gpu_worker.rs

@@ -0,0 +1,54 @@
+use std::io;
+
+use core_affinity::CoreId;
+use dandelion_commons::DandelionResult;
+use machine_interface::{
+    function_driver::{
+        compute_driver::gpu::{gpu_utils::SendFunctionArgs, GpuLoop},
+        thread_utils::EngineLoop,
+        ComputeResource, FunctionConfig,
+    },
+    memory_domain::Context,
+};
+
+fn main() {
+    // parse args
+    let args: Vec<String> = std::env::args().collect();
+    assert_eq!(args.len(), 3);
+    let core_id: u8 = args[1].parse().expect("Invalid core ID");
+    let gpu_id: u8 = args[2].parse().expect("Invalid GPU ID");
+
+    // set cpu affinity
+    assert!(core_affinity::set_for_current(CoreId {
+        id: core_id as usize
+    }));
+
+    // setup worker struct
+    let mut worker = GpuLoop::init(ComputeResource::GPU(core_id, gpu_id))
+        .expect("Should be able to create worker");
+
+    // unwrap okay, as all lines are valid Strings
+    for inp in io::stdin().lines().map(|l| l.unwrap()) {
+        match execute(&mut worker, inp) {
+            Ok(()) => {
+                println!("__OK__");
+            }
+            Err(e) => {
+                println!("__ERROR__ {:?}", e);
+            }
+        }
+    }
+}
+
+fn execute(worker: &mut GpuLoop, inp: String) -> DandelionResult<()> {
+    let SendFunctionArgs {
+        config,
+        context,
+        output_sets,
+    } = serde_json::from_str(&inp).expect("Parsing function args failed");
+
+    let config = FunctionConfig::GpuConfig(config);
+    let context: Context = context.try_into()?;
+
+    worker.run(config, context, output_sets).map(|_| ())
+}

machine_interface/src/function_driver.rs

@@ -1,5 +1,8 @@
+use std::{collections::HashMap, sync::Mutex};
+
 use crate::{
-    memory_domain::{Context, MemoryDomain},
+    interface::DandelionSystemData,
+    memory_domain::{transfer_memory, Context, MemoryDomain},
     DataRequirementList, Position,
 };
 extern crate alloc;
@@ -8,13 +11,18 @@ use dandelion_commons::{records::Recorder, DandelionError, DandelionResult};
 
 #[cfg(feature = "wasm")]
 use libloading::Library;
+use serde::{Deserialize, Serialize};
+
+#[cfg(feature = "gpu")]
+use self::compute_driver::gpu::{config_parsing::ExecutionBlueprint, hip::FunctionT};
 
 pub mod compute_driver;
 mod load_utils;
 pub mod system_driver;
+
 #[cfg(test)]
 mod test_queue;
-mod thread_utils;
+pub mod thread_utils;
 
 #[derive(Clone)]
 pub struct ElfConfig {
@@ -49,11 +57,21 @@ pub struct WasmConfig {
     system_data_struct_offset: usize,
 }
 
+#[derive(Clone, Serialize, Deserialize)]
+pub struct GpuConfig {
+    pub system_data_struct_offset: usize,
+    pub code_object_offset: usize,
+    pub kernels: Arc<Vec<String>>,
+    #[cfg(feature = "gpu")]
+    pub blueprint: Arc<ExecutionBlueprint>,
+}
+
 #[derive(Clone)]
 pub enum FunctionConfig {
     ElfConfig(ElfConfig),
     SysConfig(SystemFunction),
     WasmConfig(WasmConfig),
+    GpuConfig(GpuConfig),
 }
 
 pub struct Function {
@@ -68,7 +86,7 @@ impl Function {
         domain: &'static dyn MemoryDomain,
         ctx_size: usize,
     ) -> DandelionResult<Context> {
-        return match &self.config {
+        match &self.config {
             FunctionConfig::ElfConfig(_) => {
                 load_utils::load_static(domain, &self.context, &self.requirements, ctx_size)
             }
@@ -81,14 +99,34 @@ impl Function {
                 context.occupy_space(0, c.sdk_heap_base)?;
                 Ok(context)
             }
-        };
+            // no need to occupy space or anything like that as long as context is only inputs/outputs
+            FunctionConfig::GpuConfig(cfg) => {
+                let mut ctxt = domain.acquire_context(ctx_size)?;
+                // Make sure sysdata struct isn't overwritten, 0 = system_data_offset
+                ctxt.occupy_space(
+                    cfg.system_data_struct_offset,
+                    std::mem::size_of::<DandelionSystemData<usize, usize>>(),
+                )?;
+                // Transfer code object
+                transfer_memory(
+                    &mut ctxt,
+                    &self.context,
+                    cfg.code_object_offset,
+                    0,
+                    self.context.size,
+                )?;
+                // Mark code object storage as occupied
+                ctxt.occupy_space(cfg.code_object_offset, self.context.size)?;
+                Ok(ctxt)
+            }
+        }
     }
 }
 
 #[derive(Debug, Clone, Copy)]
 pub enum ComputeResource {
     CPU(u8),
-    GPU(u8),
+    GPU(u8, u8), // TODO change back to GPU(u8) once Driver.start_engine() takes a vec of ComputeResources
 }
 
 pub enum WorkToDo {
@@ -169,7 +207,7 @@ pub trait Driver: Send + Sync {
         &self,
         resource: ComputeResource,
         // TODO check out why this can't be impl instead of Box<dyn
-        queue: Box<dyn WorkQueue + Send>,
+        queue: Box<dyn WorkQueue + Send + Sync>,
     ) -> DandelionResult<()>;
 
     // parses an executable,

machine_interface/src/function_driver/compute_driver.rs

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

machine_interface/src/function_driver/compute_driver/compute_driver_tests.rs

@@ -1,5 +1,9 @@
-#[cfg(all(test, any(feature = "cheri", feature = "mmu", feature = "wasm")))]
-mod compute_driver_tests {
+#[cfg(all(
+    test,
+    any(feature = "cheri", feature = "mmu", feature = "wasm", feature = "gpu")
+))]
+#[allow(clippy::module_inception)]
+pub(crate) mod compute_driver_tests {
     use crate::{
         function_driver::{
             test_queue::TestQueue, ComputeResource, Driver, FunctionConfig, WorkToDo,
@@ -44,7 +48,7 @@ mod compute_driver_tests {
         }
     }
 
-    fn prepare_engine_and_function<Dom: MemoryDomain>(
+    pub fn prepare_engine_and_function<Dom: MemoryDomain>(
         filename: &str,
         dom_init: MemoryResource,
         driver: &Box<dyn Driver>,
@@ -64,7 +68,7 @@ mod compute_driver_tests {
         return (function_context, function.config, queue);
     }
 
-    fn engine_minimal<Dom: MemoryDomain>(
+    pub fn engine_minimal<Dom: MemoryDomain>(
         filename: &str,
         dom_init: MemoryResource,
         driver: Box<dyn Driver>,
@@ -154,7 +158,7 @@ mod compute_driver_tests {
         assert_eq!(4, read_buffer[1]);
     }
 
-    fn get_expected_mat(size: usize) -> Vec<i64> {
+    pub fn get_expected_mat(size: usize) -> Vec<i64> {
         let mut in_mat_vec = Vec::<i64>::new();
         for i in 0..(size * size) {
             in_mat_vec.push(i as i64);
@@ -624,7 +628,7 @@ mod compute_driver_tests {
                     .collect())).expect("Should have at least one core");
         vec![
             ComputeResource::CPU(255),
-            ComputeResource::GPU(0)
+            ComputeResource::GPU(0, 0)
         ]);
         #[cfg(target_arch = "aarch64")]
         driverTests!(elf_mmu_aarch64; MmuMemoryDomain; MemoryResource::None; MmuDriver {};
@@ -657,7 +661,7 @@ mod compute_driver_tests {
                     .collect())).expect("Should have at least one core");
         vec![
             ComputeResource::CPU(255),
-            ComputeResource::GPU(0),
+            ComputeResource::GPU(0, 0),
         ]);
 
         #[cfg(target_arch = "aarch64")]