Add dependent events support for memset

Author: szymon-zadworny

oneapi-rs-sys/include/queue.hpp

@@ -13,12 +13,22 @@
 
 #include <memory>
 
+namespace sycl_shims {
+struct EventPtr;
+} // namespace sycl_shims
+
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue();
 std::unique_ptr<Queue> new_queue_immediate();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
-std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
+std::unique_ptr<Event> memset(
+  std::unique_ptr<Queue> &,
+  std::uint8_t * ptr,
+  int value,
+  std::size_t num_bytes,
+  rust::Vec<EventPtr> dep_events
+);
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &);
 void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue

oneapi-rs-sys/src/queue-sys.rs

@@ -8,6 +8,12 @@
 
 #[cxx::bridge(namespace = "sycl_shims::queue")]
 pub mod ffi {
+    #[namespace = "sycl_shims"]
+    extern "C++" {
+        include!("oneapi-rs-sys/src/types-sys.rs.h");
+        type EventPtr = crate::types::ffi::EventPtr;
+    }
+
     unsafe extern "C++" {
         include!("oneapi-rs-sys/include/queue.hpp");
 
@@ -22,7 +28,13 @@ pub mod ffi {
         fn new_queue_immediate() -> UniquePtr<Queue>;
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
-        unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
+        unsafe fn memset(
+            queue: &mut UniquePtr<Queue>,
+            ptr: *mut u8,
+            value: i32,
+            num_bytes: usize,
+            dep_events: Vec<EventPtr>
+        ) -> UniquePtr<Event>;
         fn barrier(queue: &mut UniquePtr<Queue>) -> UniquePtr<Event>;
         fn wait(queue: &mut UniquePtr<Queue>);
     }

oneapi-rs-sys/src/queue.cpp

@@ -30,8 +30,17 @@ std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
 std::unique_ptr<Queue> clone(Queue const & queue) {
   return std::make_unique<Queue>(sycl::queue(queue));
 }
-std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr, int value, std::size_t num_bytes) {
-  return std::make_unique<Event>(queue->memset(ptr, value, num_bytes));
+std::unique_ptr<Event> memset(
+  std::unique_ptr<Queue> & queue,
+  std::uint8_t * ptr,
+  int value,
+  std::size_t num_bytes,
+  rust::Vec<EventPtr> dep_events
+) {
+  std::vector<sycl::event> deps;
+  for (auto&& e: dep_events)
+    deps.push_back(std::move(*e.ptr.release()));
+  return std::make_unique<Event>(queue->memset(ptr, value, num_bytes, deps));
 }
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue) {
   return std::make_unique<Event>(queue->ext_oneapi_submit_barrier());

oneapi-rs/src/queue.rs

@@ -7,7 +7,7 @@
 //
 
 use bytemuck::Pod;
-use oneapi_rs_sys::queue::ffi;
+use oneapi_rs_sys::{queue::ffi, types::ffi::EventPtr};
 
 use crate::{buffer::{Buffer, BufferInProgress}, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
 
@@ -60,9 +60,22 @@ impl Queue {
     }
 
     pub unsafe fn memset<T, A: UsmAlloc>(&mut self, buffer: &mut Buffer<T, A>, value: i32) -> Event {
+        unsafe { self.memset_with_deps(buffer, value, &[]) }
+    }
+
+    pub unsafe fn memset_with_deps<T, A: UsmAlloc>(
+        &mut self,
+        buffer: &mut Buffer<T, A>,
+        value: i32,
+        dep_events: &[&Event]
+    ) -> Event {
         let ptr = buffer.get_byte_ptr();
         let num_bytes = buffer.get_byte_size();
-        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes) }.into()
+        let dep_events = dep_events
+            .iter()
+            .map(|e| EventPtr { ptr: (*e).clone().0 })
+            .collect::<Vec<_>>();
+        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.into()
     }
 
     pub fn barrier(&mut self) -> Event {