From fbedbe101cf35589d8f220b2af14bdc4bc04c8ea Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 6 Aug 2026 12:08:54 +0000
Subject: [PATCH 01/11] Add Result return type to C++ queue bindings

---
 oneapi-rs-sys/src/queue-sys.rs | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 5e77ef0..3de169d 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -45,8 +45,12 @@ pub mod ffi {
             dep_events: Vec<EventPtr>,
         ) -> UniquePtr<Event>;
 
-        fn barrier(queue: &mut UniquePtr<Queue>, dep_events: Vec<EventPtr>) -> UniquePtr<Event>;
-        fn wait(queue: &mut UniquePtr<Queue>);
+        fn barrier(
+            queue: &mut UniquePtr<Queue>,
+            dep_events: Vec<EventPtr>,
+        ) -> Result<UniquePtr<Event>>;
+
+        fn wait(queue: &mut UniquePtr<Queue>) -> Result<()>;
 
         unsafe fn launch_1d(
             queue: &mut UniquePtr<Queue>,
@@ -54,7 +58,7 @@ pub mod ffi {
             local_size: Range1,
             kernel: &Kernel,
             args: &[&[u8]],
-        ) -> UniquePtr<Event>;
+        ) -> Result<UniquePtr<Event>>;
 
         unsafe fn launch_2d(
             queue: &mut UniquePtr<Queue>,
@@ -62,7 +66,7 @@ pub mod ffi {
             local_size: Range2,
             kernel: &Kernel,
             args: &[&[u8]],
-        ) -> UniquePtr<Event>;
+        ) -> Result<UniquePtr<Event>>;
 
         unsafe fn launch_3d(
             queue: &mut UniquePtr<Queue>,
@@ -70,7 +74,7 @@ pub mod ffi {
             local_size: Range3,
             kernel: &Kernel,
             args: &[&[u8]],
-        ) -> UniquePtr<Event>;
+        ) -> Result<UniquePtr<Event>>;
 
         unsafe fn memcpy(
             queue: &mut UniquePtr<Queue>,

From b7a2f7c4f25d11625ac5f0787dd55616bf2c7a4c Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 6 Aug 2026 12:21:25 +0000
Subject: [PATCH 02/11] Add cxx result wrappers

---
 oneapi-rs/src/lib.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/oneapi-rs/src/lib.rs b/oneapi-rs/src/lib.rs
index 46e5dad..68b11ef 100644
--- a/oneapi-rs/src/lib.rs
+++ b/oneapi-rs/src/lib.rs
@@ -103,6 +103,9 @@ pub mod queue;
 pub mod range;
 pub mod usm;
 
+pub type SyclError = cxx::Exception;
+pub type Result<T> = std::result::Result<T, SyclError>;
+
 mod private {
     pub trait Sealed {}
 }

From dad050826592676aa003fe9611b5ae65b88ea3c4 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 6 Aug 2026 12:21:38 +0000
Subject: [PATCH 03/11] Add result return type to Rust bindings

---
 oneapi-rs/src/queue.rs | 15 ++++++++-------
 oneapi-rs/src/range.rs | 15 ++++++++-------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 6235cdf..2ff117a 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use crate::Result;
 use bytemuck::Pod;
 use oneapi_rs_sys::{queue::ffi, types::ffi::EventPtr};
 
@@ -121,24 +122,24 @@ impl Queue {
     }
 
     /// Submits a barrier to the queue.
-    pub fn barrier(&mut self) -> Event {
-        self.barrier_with_deps(&[])
+    pub fn barrier(&mut self) -> Result<Event> {
+        self.barrier_with_deps(&[]).map(Into::into)
     }
 
     /// Submits a barrier to the queue after all specified events finish.
-    pub fn barrier_with_deps(&mut self, dep_events: &[&Event]) -> Event {
+    pub fn barrier_with_deps(&mut self, dep_events: &[&Event]) -> Result<Event> {
         let dep_events = dep_events
             .iter()
             .map(|e| EventPtr {
                 ptr: (*e).clone().0,
             })
             .collect::<Vec<_>>();
-        ffi::barrier(&mut self.0, dep_events).into()
+        ffi::barrier(&mut self.0, dep_events).map(Into::into)
     }
 
     /// Performs a blocking wait for the completion of all enqueued tasks in the queue.
-    pub fn wait(&mut self) {
-        ffi::wait(&mut self.0);
+    pub fn wait(&mut self) -> Result<()> {
+        ffi::wait(&mut self.0)
     }
 
     /// Enqueues a kernel object to the queue as an ND-range kernel, using the number of work-items
@@ -148,7 +149,7 @@ impl Queue {
         nd_range: NdRange<DIMENSIONS>,
         kernel: &Kernel,
         args: impl KernelArgumentList<ARGC>,
-    ) -> Event
+    ) -> Result<Event>
     where
         NdRange<DIMENSIONS>: ValidDimension,
     {
diff --git a/oneapi-rs/src/range.rs b/oneapi-rs/src/range.rs
index f461a0a..b7cb998 100644
--- a/oneapi-rs/src/range.rs
+++ b/oneapi-rs/src/range.rs
@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use crate::Result;
 use oneapi_rs_sys::types;
 
 use crate::{
@@ -46,7 +47,7 @@ pub trait ValidDimension: Sealed {
         queue: &mut Queue,
         kernel: &Kernel,
         args: impl KernelArgumentList<ARGC>,
-    ) -> Event;
+    ) -> Result<Event>;
 }
 
 impl Sealed for NdRange<1> {}
@@ -56,7 +57,7 @@ impl ValidDimension for NdRange<1> {
         queue: &mut Queue,
         kernel: &Kernel,
         args: impl KernelArgumentList<ARGC>,
-    ) -> Event {
+    ) -> Result<Event> {
         unsafe {
             oneapi_rs_sys::queue::ffi::launch_1d(
                 &mut queue.0,
@@ -70,7 +71,7 @@ impl ValidDimension for NdRange<1> {
                 &args.as_raw_arg_list(),
             )
         }
-        .into()
+        .map(Into::into)
     }
 }
 
@@ -81,7 +82,7 @@ impl ValidDimension for NdRange<2> {
         queue: &mut Queue,
         kernel: &Kernel,
         args: impl KernelArgumentList<ARGC>,
-    ) -> Event {
+    ) -> Result<Event> {
         unsafe {
             oneapi_rs_sys::queue::ffi::launch_2d(
                 &mut queue.0,
@@ -95,7 +96,7 @@ impl ValidDimension for NdRange<2> {
                 &args.as_raw_arg_list(),
             )
         }
-        .into()
+        .map(Into::into)
     }
 }
 
@@ -106,7 +107,7 @@ impl ValidDimension for NdRange<3> {
         queue: &mut Queue,
         kernel: &Kernel,
         args: impl KernelArgumentList<ARGC>,
-    ) -> Event {
+    ) -> Result<Event> {
         unsafe {
             oneapi_rs_sys::queue::ffi::launch_3d(
                 &mut queue.0,
@@ -120,6 +121,6 @@ impl ValidDimension for NdRange<3> {
                 &args.as_raw_arg_list(),
             )
         }
-        .into()
+        .map(Into::into)
     }
 }

From 40e73794b752dd2896f39c3dd904742c98088d60 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 7 Aug 2026 10:12:06 +0000
Subject: [PATCH 04/11] Add Result return type to C++ event binding

---
 oneapi-rs-sys/src/event-sys.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index 6158ac8..52bf7a1 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -25,7 +25,7 @@ pub mod ffi {
         #[namespace = "sycl_shims"]
         type Queue = crate::types::ffi::Queue;
 
-        fn wait(event: &mut UniquePtr<Event>);
+        fn wait(event: &mut UniquePtr<Event>) -> Result<()>;
         unsafe fn register_callback(
             queue: &mut UniquePtr<Queue>,
             event: &Event,

From 3bd7f47f3f94e47afff69a58d0106acdd6eb0caf Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 7 Aug 2026 10:12:45 +0000
Subject: [PATCH 05/11] Add Result return type to Rust event bindings

---
 oneapi-rs/src/buffer.rs | 12 ++++++------
 oneapi-rs/src/event.rs  | 16 +++++++++-------
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/oneapi-rs/src/buffer.rs b/oneapi-rs/src/buffer.rs
index fb4cfae..be86382 100644
--- a/oneapi-rs/src/buffer.rs
+++ b/oneapi-rs/src/buffer.rs
@@ -19,6 +19,7 @@ use bytemuck::Pod;
 use pin_project::pin_project;
 
 use crate::{
+    Result,
     event::{Event, EventFuture},
     kernel::KernelArgument,
     usm::{
@@ -121,9 +122,8 @@ impl<T, A: UsmAlloc> EnqueuedBuffer<T, A> {
 
 impl<T, A: UsmAlloc> EnqueuedBuffer<T, A> {
     /// Waits for [`Buffer`] initialization to finish.
-    pub fn wait(mut self) -> Buffer<T, A> {
-        self.event.wait();
-        self.buffer
+    pub fn wait(mut self) -> Result<Buffer<T, A>> {
+        self.event.wait().map(|_| self.buffer)
     }
 }
 
@@ -140,17 +140,17 @@ pub struct BufferFuture<T, A: UsmAlloc> {
 }
 
 impl<T, A: UsmAlloc> Future for BufferFuture<T, A> {
-    type Output = Buffer<T, A>;
+    type Output = Result<Buffer<T, A>>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
         this.event_future
             .poll(cx)
-            .map(|_| this.buffer.take().unwrap())
+            .map(|result| result.map(|_| this.buffer.take().unwrap()))
     }
 }
 
 impl<T, A: UsmAlloc> IntoFuture for EnqueuedBuffer<T, A> {
-    type Output = Buffer<T, A>;
+    type Output = Result<Buffer<T, A>>;
     type IntoFuture = BufferFuture<T, A>;
 
     fn into_future(self) -> Self::IntoFuture {
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index 9e8e1c3..f2a9af1 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -16,13 +16,13 @@ use oneapi_rs_sys::{event::ffi, types::SharedWaker};
 
 use pin_project::pin_project;
 
-use crate::{info::InfoTarget, private::Sealed, queue::Queue};
+use crate::{Result, info::InfoTarget, private::Sealed, queue::Queue};
 
 pub struct Event(pub(crate) cxx::UniquePtr<ffi::Event>);
 
 impl Event {
-    pub fn wait(&mut self) {
-        ffi::wait(&mut self.0);
+    pub fn wait(&mut self) -> Result<()> {
+        ffi::wait(&mut self.0)
     }
 }
 
@@ -50,7 +50,7 @@ pub struct EventFuture {
 }
 
 impl Future for EventFuture {
-    type Output = ();
+    type Output = Result<()>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -67,7 +67,8 @@ impl Future for EventFuture {
         } else {
             // Quick check before registering to avoid wasting time
             if this.shared.done.load(Relaxed) {
-                return Poll::Ready(());
+                // The event finished - waiting for it returns immediately
+                return Poll::Ready(this.event.wait());
             }
 
             this.shared.waker.register(cx.waker());
@@ -76,7 +77,8 @@ impl Future for EventFuture {
         // Check the event again to avoid a race condition
         // https://docs.rs/futures/latest/futures/task/struct.AtomicWaker.html#examples
         if this.shared.done.load(Relaxed) {
-            Poll::Ready(())
+            // The event finished - waiting for it returns immediately
+            Poll::Ready(this.event.wait())
         } else {
             Poll::Pending
         }
@@ -84,7 +86,7 @@ impl Future for EventFuture {
 }
 
 impl IntoFuture for Event {
-    type Output = ();
+    type Output = Result<()>;
     type IntoFuture = EventFuture;
 
     fn into_future(self) -> Self::IntoFuture {

From d8569044353cbbdfad90c2549b0ee72632c80a0f Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 7 Aug 2026 10:18:52 +0000
Subject: [PATCH 06/11] Add Result return type to C++ kernel bundle bindings

---
 oneapi-rs-sys/src/kernel-bundle-sys.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/oneapi-rs-sys/src/kernel-bundle-sys.rs b/oneapi-rs-sys/src/kernel-bundle-sys.rs
index 2e53ab4..832f8ff 100644
--- a/oneapi-rs-sys/src/kernel-bundle-sys.rs
+++ b/oneapi-rs-sys/src/kernel-bundle-sys.rs
@@ -26,11 +26,15 @@ pub mod ffi {
         fn create_kernel_bundle_from_source(
             ctxt: &Context,
             source: &str,
-        ) -> UniquePtr<SourceKernelBundle>;
-        fn build(source: &mut UniquePtr<SourceKernelBundle>) -> UniquePtr<ExecutableKernelBundle>;
+        ) -> Result<UniquePtr<SourceKernelBundle>>;
+
+        fn build(
+            source: &mut UniquePtr<SourceKernelBundle>,
+        ) -> Result<UniquePtr<ExecutableKernelBundle>>;
+
         fn get_kernel(
             bundle: &mut UniquePtr<ExecutableKernelBundle>,
             name: &str,
-        ) -> UniquePtr<Kernel>;
+        ) -> Result<UniquePtr<Kernel>>;
     }
 }

From d7ca27697a6a8f0ee2df1b757b69aabab4e21eb1 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 7 Aug 2026 10:20:34 +0000
Subject: [PATCH 07/11] Add Result return type to Rust kernel bindings

---
 oneapi-rs/src/context.rs | 6 +++---
 oneapi-rs/src/kernel.rs  | 9 +++++----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/oneapi-rs/src/context.rs b/oneapi-rs/src/context.rs
index 0dfff64..17f7a42 100644
--- a/oneapi-rs/src/context.rs
+++ b/oneapi-rs/src/context.rs
@@ -8,7 +8,7 @@
 
 use oneapi_rs_sys::{context::ffi, kernel_bundle, types::ffi::DevicePtr};
 
-use crate::{device::Device, kernel::SourceKernelBundle};
+use crate::{Result, device::Device, kernel::SourceKernelBundle};
 
 /// A context represents the runtime data structures and state required by a SYCL backend API
 /// to interact with a group of devices associated with a platform.
@@ -32,7 +32,7 @@ impl Context {
         ffi::new_context(devices).into()
     }
 
-    pub fn create_kernel_bundle_from_source(&self, source: &str) -> SourceKernelBundle {
-        kernel_bundle::ffi::create_kernel_bundle_from_source(&self.0, source).into()
+    pub fn create_kernel_bundle_from_source(&self, source: &str) -> Result<SourceKernelBundle> {
+        kernel_bundle::ffi::create_kernel_bundle_from_source(&self.0, source).map(Into::into)
     }
 }
diff --git a/oneapi-rs/src/kernel.rs b/oneapi-rs/src/kernel.rs
index 60b425e..7d82819 100644
--- a/oneapi-rs/src/kernel.rs
+++ b/oneapi-rs/src/kernel.rs
@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use crate::Result;
 use bytemuck::Pod;
 use oneapi_rs_sys::{kernel_bundle::ffi, types};
 
@@ -19,8 +20,8 @@ impl From<cxx::UniquePtr<types::ffi::SourceKernelBundle>> for SourceKernelBundle
 }
 
 impl SourceKernelBundle {
-    pub fn build(&mut self) -> ExecutableKernelBundle {
-        ffi::build(&mut self.0).into()
+    pub fn build(&mut self) -> Result<ExecutableKernelBundle> {
+        ffi::build(&mut self.0).map(Into::into)
     }
 }
 
@@ -34,8 +35,8 @@ impl From<cxx::UniquePtr<types::ffi::ExecutableKernelBundle>> for ExecutableKern
 }
 
 impl ExecutableKernelBundle {
-    pub fn get_kernel(&mut self, name: &str) -> Kernel {
-        ffi::get_kernel(&mut self.0, name).into()
+    pub fn get_kernel(&mut self, name: &str) -> Result<Kernel> {
+        ffi::get_kernel(&mut self.0, name).map(Into::into)
     }
 }
 

From d31af5055de0865616e6f6d065641e19a430b3ec Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 7 Aug 2026 10:21:00 +0000
Subject: [PATCH 08/11] Update examples

---
 oneapi-rs/examples/kernel_launch.rs        | 20 +++++++++++---------
 oneapi-rs/examples/kernel_launch_derive.rs | 16 +++++++++-------
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/oneapi-rs/examples/kernel_launch.rs b/oneapi-rs/examples/kernel_launch.rs
index ce8aa2c..9de73df 100644
--- a/oneapi-rs/examples/kernel_launch.rs
+++ b/oneapi-rs/examples/kernel_launch.rs
@@ -22,15 +22,15 @@ void iota(float start, float *ptr) {
 "#;
 
 #[tokio::main]
-async fn main() {
+async fn main() -> oneapi_rs::Result<()> {
     let mut queue = Queue::new();
-    let mut device_buffer = queue.alloc_device::<f32>(1024).await;
+    let mut device_buffer = queue.alloc_device::<f32>(1024).await?;
 
     let kernel = queue
         .get_context()
-        .create_kernel_bundle_from_source(IOTA_SRC)
-        .build()
-        .get_kernel("iota");
+        .create_kernel_bundle_from_source(IOTA_SRC)?
+        .build()?
+        .get_kernel("iota")?;
 
     unsafe {
         queue.launch(
@@ -38,15 +38,17 @@ async fn main() {
             &kernel,
             (3.14_f32, &mut device_buffer),
         )
-    }
-    .await;
+    }?
+    .await?;
 
-    let mut host_buffer = queue.alloc_host::<f32>(1024).await;
+    let mut host_buffer = queue.alloc_host::<f32>(1024).await?;
 
-    queue.copy(&device_buffer, &mut host_buffer).await;
+    queue.copy(&device_buffer, &mut host_buffer).await?;
 
     for e in host_buffer.iter() {
         print!("{e} ");
     }
     println!();
+
+    Ok(())
 }
diff --git a/oneapi-rs/examples/kernel_launch_derive.rs b/oneapi-rs/examples/kernel_launch_derive.rs
index 66e628d..c763f7d 100644
--- a/oneapi-rs/examples/kernel_launch_derive.rs
+++ b/oneapi-rs/examples/kernel_launch_derive.rs
@@ -27,15 +27,15 @@ struct IotaArgs<'a> {
     ptr: &'a mut SharedBuffer<f32>,
 }
 
-fn main() {
+fn main() -> oneapi_rs::Result<()> {
     let mut queue = Queue::new();
-    let mut buffer = queue.alloc_shared::<f32>(1024).wait();
+    let mut buffer = queue.alloc_shared::<f32>(1024).wait()?;
 
     let kernel = queue
         .get_context()
-        .create_kernel_bundle_from_source(IOTA_SRC)
-        .build()
-        .get_kernel("iota");
+        .create_kernel_bundle_from_source(IOTA_SRC)?
+        .build()?
+        .get_kernel("iota")?;
 
     unsafe {
         queue.launch(
@@ -46,11 +46,13 @@ fn main() {
                 ptr: &mut buffer,
             },
         )
-    }
-    .wait();
+    }?
+    .wait()?;
 
     for e in buffer.iter() {
         print!("{e} ");
     }
     println!();
+
+    Ok(())
 }

From 08e671510ed71abd0189e9975b5d7b7234cc5c79 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Mon, 10 Aug 2026 09:23:21 +0000
Subject: [PATCH 09/11] Make callback registration fallible

---
 oneapi-rs-sys/src/event-sys.rs |  4 +++-
 oneapi-rs/src/event.rs         | 12 ++++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index 52bf7a1..59727e3 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -26,11 +26,13 @@ pub mod ffi {
         type Queue = crate::types::ffi::Queue;
 
         fn wait(event: &mut UniquePtr<Event>) -> Result<()>;
+
         unsafe fn register_callback(
             queue: &mut UniquePtr<Queue>,
             event: &Event,
             waker: *const SharedWaker,
-        );
+        ) -> Result<()>;
+
         fn get_command_execution_status(event: &Event) -> EventCommandStatus;
         fn clone(event: &Event) -> UniquePtr<Event>;
     }
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index f2a9af1..8256f6c 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -62,8 +62,16 @@ impl Future for EventFuture {
             this.shared.waker.register(cx.waker());
             // Safety: the SharedWaker will always outlive the C++ host task.
             // Safety: the Future which holds the SharedWaker is pinned - the pointer will remain valid.
-            unsafe { ffi::register_callback(&mut queue.0, &this.event.0, this.shared) };
-            this.queue.replace(queue);
+            let result =
+                unsafe { ffi::register_callback(&mut queue.0, &this.event.0, this.shared) };
+            match result {
+                Ok(_) => {
+                    this.queue.replace(queue);
+                }
+                Err(_) => {
+                    return Poll::Ready(result);
+                }
+            }
         } else {
             // Quick check before registering to avoid wasting time
             if this.shared.done.load(Relaxed) {

From f575327f00e0baf7b6de3839d4bbb521d6036424 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Mon, 10 Aug 2026 09:38:32 +0000
Subject: [PATCH 10/11] Add Result return type to memset

---
 oneapi-rs-sys/src/queue-sys.rs             |  2 +-
 oneapi-rs/examples/kernel_launch.rs        |  4 ++--
 oneapi-rs/examples/kernel_launch_derive.rs |  2 +-
 oneapi-rs/src/queue.rs                     | 24 +++++++++++-----------
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 3de169d..6323462 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -43,7 +43,7 @@ pub mod ffi {
             value: i32,
             num_bytes: usize,
             dep_events: Vec<EventPtr>,
-        ) -> UniquePtr<Event>;
+        ) -> Result<UniquePtr<Event>>;
 
         fn barrier(
             queue: &mut UniquePtr<Queue>,
diff --git a/oneapi-rs/examples/kernel_launch.rs b/oneapi-rs/examples/kernel_launch.rs
index 9de73df..16635d4 100644
--- a/oneapi-rs/examples/kernel_launch.rs
+++ b/oneapi-rs/examples/kernel_launch.rs
@@ -24,7 +24,7 @@ void iota(float start, float *ptr) {
 #[tokio::main]
 async fn main() -> oneapi_rs::Result<()> {
     let mut queue = Queue::new();
-    let mut device_buffer = queue.alloc_device::<f32>(1024).await?;
+    let mut device_buffer = queue.alloc_device::<f32>(1024)?.await?;
 
     let kernel = queue
         .get_context()
@@ -41,7 +41,7 @@ async fn main() -> oneapi_rs::Result<()> {
     }?
     .await?;
 
-    let mut host_buffer = queue.alloc_host::<f32>(1024).await?;
+    let mut host_buffer = queue.alloc_host::<f32>(1024)?.await?;
 
     queue.copy(&device_buffer, &mut host_buffer).await?;
 
diff --git a/oneapi-rs/examples/kernel_launch_derive.rs b/oneapi-rs/examples/kernel_launch_derive.rs
index c763f7d..5795935 100644
--- a/oneapi-rs/examples/kernel_launch_derive.rs
+++ b/oneapi-rs/examples/kernel_launch_derive.rs
@@ -29,7 +29,7 @@ struct IotaArgs<'a> {
 
 fn main() -> oneapi_rs::Result<()> {
     let mut queue = Queue::new();
-    let mut buffer = queue.alloc_shared::<f32>(1024).wait()?;
+    let mut buffer = queue.alloc_shared::<f32>(1024)?.wait()?;
 
     let kernel = queue
         .get_context()
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 2ff117a..2fd6c7b 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -45,29 +45,29 @@ impl Queue {
     }
 
     /// Allocates zeroed memory and creates a host-side [`Buffer`] that can store an array of T.
-    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> EnqueuedHostBuffer<T> {
+    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> Result<EnqueuedHostBuffer<T>> {
         unsafe {
             let mut buffer = self.alloc_uninit_host(len);
-            let event = self.memset(&mut buffer, 0);
-            EnqueuedBuffer::new(buffer, event)
+            self.memset(&mut buffer, 0)
+                .map(|event| EnqueuedBuffer::new(buffer, event))
         }
     }
 
     /// Allocates zeroed memory and creates a shared [`Buffer`] that can store an array of T.
-    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> EnqueuedSharedBuffer<T> {
+    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> Result<EnqueuedSharedBuffer<T>> {
         unsafe {
             let mut buffer = self.alloc_uninit_shared(len);
-            let event = self.memset(&mut buffer, 0);
-            EnqueuedBuffer::new(buffer, event)
+            self.memset(&mut buffer, 0)
+                .map(|event| EnqueuedBuffer::new(buffer, event))
         }
     }
 
     /// Allocates zeroed memory and creates a device [`Buffer`] that can store an array of T.
-    pub fn alloc_device<T: Pod>(&mut self, len: usize) -> EnqueuedDeviceBuffer<T> {
+    pub fn alloc_device<T: Pod>(&mut self, len: usize) -> Result<EnqueuedDeviceBuffer<T>> {
         unsafe {
             let mut buffer = self.alloc_uninit_device(len);
-            let event = self.memset(&mut buffer, 0);
-            EnqueuedBuffer::new(buffer, event)
+            self.memset(&mut buffer, 0)
+                .map(|event| EnqueuedBuffer::new(buffer, event))
         }
     }
 
@@ -98,7 +98,7 @@ impl Queue {
         &mut self,
         buffer: &mut Buffer<T, A>,
         value: i32,
-    ) -> Event {
+    ) -> Result<Event> {
         unsafe { self.memset_with_deps(buffer, value, &[]) }
     }
 
@@ -109,7 +109,7 @@ impl Queue {
         buffer: &mut Buffer<T, A>,
         value: i32,
         dep_events: &[&Event],
-    ) -> Event {
+    ) -> Result<Event> {
         let ptr = buffer.get_byte_ptr();
         let num_bytes = buffer.get_byte_size();
         let dep_events = dep_events
@@ -118,7 +118,7 @@ impl Queue {
                 ptr: (*e).clone().0,
             })
             .collect::<Vec<_>>();
-        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.into()
+        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.map(Into::into)
     }
 
     /// Submits a barrier to the queue.

From 924a3c82a0eea65fb029ab9083f0b1f53ca26336 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Mon, 10 Aug 2026 09:44:14 +0000
Subject: [PATCH 11/11] Add Result return type to memcpy

---
 oneapi-rs-sys/src/queue-sys.rs      | 16 ++++++++--------
 oneapi-rs/examples/kernel_launch.rs |  2 +-
 oneapi-rs/src/queue.rs              |  6 +++---
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 6323462..9677fdd 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -45,6 +45,14 @@ pub mod ffi {
             dep_events: Vec<EventPtr>,
         ) -> Result<UniquePtr<Event>>;
 
+        unsafe fn memcpy(
+            queue: &mut UniquePtr<Queue>,
+            dest: *mut u8,
+            src: *const u8,
+            num_bytes: usize,
+            dep_events: Vec<EventPtr>,
+        ) -> Result<UniquePtr<Event>>;
+
         fn barrier(
             queue: &mut UniquePtr<Queue>,
             dep_events: Vec<EventPtr>,
@@ -75,13 +83,5 @@ pub mod ffi {
             kernel: &Kernel,
             args: &[&[u8]],
         ) -> Result<UniquePtr<Event>>;
-
-        unsafe fn memcpy(
-            queue: &mut UniquePtr<Queue>,
-            dest: *mut u8,
-            src: *const u8,
-            num_bytes: usize,
-            dep_events: Vec<EventPtr>,
-        ) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs/examples/kernel_launch.rs b/oneapi-rs/examples/kernel_launch.rs
index 16635d4..a4a1325 100644
--- a/oneapi-rs/examples/kernel_launch.rs
+++ b/oneapi-rs/examples/kernel_launch.rs
@@ -43,7 +43,7 @@ async fn main() -> oneapi_rs::Result<()> {
 
     let mut host_buffer = queue.alloc_host::<f32>(1024)?.await?;
 
-    queue.copy(&device_buffer, &mut host_buffer).await?;
+    queue.copy(&device_buffer, &mut host_buffer)?.await?;
 
     for e in host_buffer.iter() {
         print!("{e} ");
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 2fd6c7b..297bcc4 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -159,7 +159,7 @@ impl Queue {
     /// Copies the contents of the source buffer to the destination buffer.
     ///
     /// Panics if the source and destination buffer lengths differ.
-    pub fn copy<T, A1, A2>(&mut self, src: &Buffer<T, A1>, dst: &mut Buffer<T, A2>) -> Event
+    pub fn copy<T, A1, A2>(&mut self, src: &Buffer<T, A1>, dst: &mut Buffer<T, A2>) -> Result<Event>
     where
         T: Pod,
         A1: UsmAlloc,
@@ -177,7 +177,7 @@ impl Queue {
         src: &Buffer<T, A1>,
         dst: &mut Buffer<T, A2>,
         dep_events: &[&Event],
-    ) -> Event
+    ) -> Result<Event>
     where
         T: Pod,
         A1: UsmAlloc,
@@ -207,7 +207,7 @@ impl Queue {
                 dep_events,
             )
         }
-        .into()
+        .map(Into::into)
     }
 }