Add synchronous and asynchronous events

oneapi-rs-sys/build.rs

@@ -19,13 +19,15 @@ fn main() {
         "src/device-sys.rs",
         "src/queue-sys.rs",
         "src/usm-sys.rs",
+        "src/event-sys.rs",
     ];
 
     let cpp_sources = [
         "src/platform.cpp",
         "src/device.cpp",
         "src/queue.cpp",
         "src/usm.cpp",
+        "src/event.cpp",
     ];
 
     let cpp_headers = [
@@ -34,6 +36,7 @@ fn main() {
         "include/device.hpp",
         "include/queue.hpp",
         "include/usm.hpp",
+        "include/event.hpp",
     ];
 
     cxx_build::bridges(&rust_sources)

oneapi-rs-sys/include/event.hpp

@@ -0,0 +1,26 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+#pragma once
+
+#include "oneapi-rs-sys/include/types.hpp"
+#include "oneapi-rs-sys/src/event-sys.rs.h"
+#include "rust/cxx.h"
+
+#include <memory>
+
+namespace sycl_shims {
+enum class EventCommandStatus : std::uint8_t;
+} // namespace sycl_shims
+
+namespace sycl_shims::event {
+void wait(std::unique_ptr<Event> &);
+void register_callback(std::unique_ptr<Queue> &, Event const &, rust::Box<Waker>);
+EventCommandStatus get_command_execution_status(Event const &);
+std::unique_ptr<Event> clone(Event const &);
+} // namespace sycl_shims::event

oneapi-rs-sys/include/queue.hpp

@@ -13,7 +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,
+  rust::Vec<EventPtr>
+);
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &, rust::Vec<EventPtr>);
+void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue

oneapi-rs-sys/include/types.hpp

@@ -14,4 +14,5 @@ namespace sycl_shims {
 using Device = sycl::device;
 using Platform = sycl::platform;
 using Queue = sycl::queue;
+using Event = sycl::event;
 }

oneapi-rs-sys/src/event-sys.rs

@@ -0,0 +1,42 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+use crate::types::Waker;
+
+#[cxx::bridge(namespace = "sycl_shims::event")]
+pub mod ffi {
+    #[namespace = "sycl_shims"]
+    extern "C++" {
+        include!("oneapi-rs-sys/src/types-sys.rs.h");
+        type EventCommandStatus = crate::types::ffi::EventCommandStatus;
+    }
+
+    unsafe extern "C++" {
+        include!("oneapi-rs-sys/include/event.hpp");
+
+        #[namespace = "sycl_shims"]
+        type Event = crate::types::ffi::Event;
+
+        #[namespace = "sycl_shims"]
+        type Queue = crate::types::ffi::Queue;
+
+        fn wait(event: &mut UniquePtr<Event>);
+        fn register_callback(queue: &mut UniquePtr<Queue>, event: &Event, waker: Box<Waker>);
+        fn get_command_execution_status(event: &Event) -> EventCommandStatus;
+        fn clone(event: &Event) -> UniquePtr<Event>;
+    }
+
+    extern "Rust" {
+        type Waker;
+        fn wake(waker: &Box<Waker>);
+    }
+}
+
+fn wake(waker: &Box<Waker>) {
+    waker.0.wake_by_ref();
+}

oneapi-rs-sys/src/event.cpp

@@ -0,0 +1,41 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+#include "oneapi-rs-sys/include/event.hpp"
+
+using sycl::info::event_command_status;
+
+namespace syclintel = sycl::ext::intel;
+
+namespace sycl_shims::event {
+void wait(std::unique_ptr<Event> & event) {
+  event->wait();
+}
+std::unique_ptr<Event> clone(Event const & event) {
+  return std::make_unique<Event>(sycl::event(event));
+}
+EventCommandStatus get_command_execution_status(Event const & event) {
+  auto status = event.get_info<sycl::info::event::command_execution_status>();
+  switch (status) {
+    case event_command_status::submitted:
+      return EventCommandStatus::Submitted;
+    case event_command_status::running:
+      return EventCommandStatus::Running;
+    case event_command_status::complete:
+      return EventCommandStatus::Complete;
+    default:
+      return EventCommandStatus::Unknown;
+  }
+}
+void register_callback(std::unique_ptr<Queue> & queue, Event const & event, rust::Box<Waker> waker) {
+  queue->submit([waker = std::move(waker), event](sycl::handler& cgh) {
+    cgh.depends_on(event);
+    cgh.host_task([&]() { wake(waker); });
+  });
+}
+} // namespace sycl_shims::event

oneapi-rs-sys/src/lib.rs

@@ -20,3 +20,6 @@ pub mod queue;
 
 #[path = "usm-sys.rs"]
 pub mod usm;
+
+#[path = "event-sys.rs"]
+pub mod event;

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

@@ -8,15 +8,34 @@
 
 #[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");
 
         #[namespace = "sycl_shims"]
         type Queue = crate::types::ffi::Queue;
         #[namespace = "sycl_shims"]
         type Device = crate::types::ffi::Device;
+        #[namespace = "sycl_shims"]
+        type Event = crate::types::ffi::Event;
 
         fn new_queue() -> UniquePtr<Queue>;
+        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,
+            dep_events: Vec<EventPtr>
+        ) -> UniquePtr<Event>;
+        fn barrier(queue: &mut UniquePtr<Queue>, dep_events: Vec<EventPtr>) -> UniquePtr<Event>;
+        fn wait(queue: &mut UniquePtr<Queue>);
     }
 }

oneapi-rs-sys/src/queue.cpp

@@ -9,11 +9,46 @@
 #include "oneapi-rs-sys/include/queue.hpp"
 #include "oneapi-rs-sys/src/queue-sys.rs.h"
 
+using sycl::property::queue::in_order;
+using sycl::ext::intel::property::queue::immediate_command_list;
+
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue() {
-  return std::make_unique<Queue>(sycl::queue());
+  return std::make_unique<Queue>(sycl::queue({
+    in_order()
+  }));
+}
+std::unique_ptr<Queue> new_queue_immediate() {
+  return std::make_unique<Queue>(sycl::queue({
+    in_order(),
+    immediate_command_list()
+  }));
 }
 std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
-  return std::make_unique<Queue>(sycl::queue(device));
+  return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
+}
+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,
+  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, 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->ext_oneapi_submit_barrier(deps));
+}
+void wait(std::unique_ptr<Queue> & queue) {
+  queue->wait();
 }
 } // namespace sycl_shims::queue

oneapi-rs-sys/src/types-sys.rs

@@ -6,13 +6,22 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+// cxx requires Rust opaque types to be defined in the current crate.
+pub struct Waker(pub std::task::Waker);
+impl From<std::task::Waker> for Waker {
+    fn from(value: std::task::Waker) -> Self {
+        Waker(value)
+    }
+}
+
 #[cxx::bridge(namespace = "sycl_shims")]
 pub mod ffi {
     unsafe extern "C++" {
         include!("oneapi-rs-sys/include/types.hpp");
         type Device;
         type Platform;
         type Queue;
+        type Event;
     }
 
     // This is a workaround - cxx currently doesn't support passing
@@ -26,6 +35,10 @@ pub mod ffi {
     struct PlatformPtr {
         ptr: UniquePtr<Platform>
     }
+
+    struct EventPtr {
+        ptr: UniquePtr<Event>
+    }
 
     #[derive(Debug)]
     enum DeviceType {
@@ -38,10 +51,20 @@ pub mod ffi {
         Unimplemented
     }
 
+    #[derive(Debug)]
+    enum EventCommandStatus {
+        Submitted,
+        Running,
+        Complete,
+        Unknown
+    }
+
     impl UniquePtr<Device> {}
     impl UniquePtr<Platform> {}
     impl UniquePtr<Queue> {}
+    impl UniquePtr<Event> {}
 
     impl Vec<DevicePtr> {}
     impl Vec<PlatformPtr> {}
+    impl Vec<EventPtr> {}
 }