Add synchronous and asynchronous events

oneapi-rs-sys/Cargo.toml

@@ -6,6 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 cxx = "1.0.194"
+futures = "0.3.33"
 
 [build-dependencies]
 cxx-build = "1.0.194"

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 &, SharedWaker const *);
+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,38 @@
+//
+// 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::SharedWaker;
+
+#[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>);
+        unsafe fn register_callback(queue: &mut UniquePtr<Queue>, event: &Event, waker: *const SharedWaker);
+        fn get_command_execution_status(event: &Event) -> EventCommandStatus;
+        fn clone(event: &Event) -> UniquePtr<Event>;
+    }
+
+    extern "Rust" {
+        type SharedWaker;
+        fn wake(&self);
+    }
+}

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, SharedWaker const * waker) {
+  queue->submit([=](sycl::handler& cgh) {
+    cgh.depends_on(event);
+    cgh.host_task([=]() { waker->wake(); });
+  });
+}
+} // 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;