Fix clippy findings

Author: bratpiorka

sycl/sycl-rs-sys/build.rs

@@ -54,7 +54,7 @@ fn main() {
         "include/kernel-bundle.hpp",
     ];
 
-    cxx_build::bridges(&rust_sources)
+    cxx_build::bridges(rust_sources)
         .compiler(&compiler_path)
         .flag("-fsycl")
         .files(&cpp_sources)

sycl/sycl-rs-sys/src/event-sys.rs

@@ -10,6 +10,7 @@ use std::sync::{Arc, atomic::Ordering::Relaxed};
 
 use crate::types::SharedWaker;
 
+#[allow(clippy::missing_safety_doc)]
 #[cxx::bridge(namespace = "sycl_shims::event")]
 pub mod ffi {
     #[namespace = "sycl_shims"]
@@ -29,6 +30,10 @@ pub mod ffi {
 
         fn wait(event: &mut UniquePtr<Event>) -> Result<()>;
 
+        /// # Safety
+        ///
+        /// `waker` must come from `Arc::into_raw` and transfer one strong reference to the
+        /// callback, which will consume it after the event completes.
         unsafe fn register_callback(
             queue: &mut UniquePtr<Queue>,
             event: &Event,
@@ -41,12 +46,17 @@ pub mod ffi {
 
     extern "Rust" {
         type SharedWaker;
+        /// # Safety
+        ///
+        /// `ptr` must come from `Arc::into_raw` and represent a strong reference owned by this
+        /// callback.
         unsafe fn wake(ptr: *const SharedWaker);
     }
 }
 
-// Safety: SharedWaker must by a pointer created by Arc::into_raw. The caller must increment the
-// SharedWaker's strong reference count before calling.
+/// # Safety
+///
+/// `ptr` must come from `Arc::into_raw` and represent a strong reference owned by this callback.
 unsafe fn wake(ptr: *const SharedWaker) {
     unsafe {
         (*ptr).done.store(true, Relaxed);

sycl/sycl-rs-sys/src/queue-sys.rs

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+#[allow(clippy::missing_safety_doc)]
 #[cxx::bridge(namespace = "sycl_shims::queue")]
 pub mod ffi {
     #[namespace = "sycl_shims"]
@@ -44,6 +45,10 @@ pub mod ffi {
 
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
 
+        /// # Safety
+        ///
+        /// `ptr` must be valid for writes of `num_bytes` bytes and remain valid until the
+        /// returned event completes. The memory must not be accessed concurrently.
         unsafe fn memset(
             queue: &mut UniquePtr<Queue>,
             ptr: *mut u8,
@@ -52,6 +57,11 @@ pub mod ffi {
             dep_events: Vec<EventPtr>,
         ) -> Result<UniquePtr<Event>>;
 
+        /// # Safety
+        ///
+        /// `src` and `dest` must be valid for reads and writes, respectively, of `num_bytes`
+        /// bytes and remain valid until the returned event completes. The regions must not
+        /// overlap or be accessed concurrently.
         unsafe fn memcpy(
             queue: &mut UniquePtr<Queue>,
             dest: *mut u8,
@@ -67,6 +77,10 @@ pub mod ffi {
 
         fn wait(queue: &mut UniquePtr<Queue>) -> Result<()>;
 
+        /// # Safety
+        ///
+        /// Each entry in `args` must match the corresponding kernel parameter's size, layout,
+        /// and alignment.
         unsafe fn launch_1d(
             queue: &mut UniquePtr<Queue>,
             global_size: Range1,
@@ -75,6 +89,10 @@ pub mod ffi {
             args: &[&[u8]],
         ) -> Result<UniquePtr<Event>>;
 
+        /// # Safety
+        ///
+        /// Each entry in `args` must match the corresponding kernel parameter's size, layout,
+        /// and alignment.
         unsafe fn launch_2d(
             queue: &mut UniquePtr<Queue>,
             global_size: Range2,
@@ -83,6 +101,10 @@ pub mod ffi {
             args: &[&[u8]],
         ) -> Result<UniquePtr<Event>>;
 
+        /// # Safety
+        ///
+        /// Each entry in `args` must match the corresponding kernel parameter's size, layout,
+        /// and alignment.
         unsafe fn launch_3d(
             queue: &mut UniquePtr<Queue>,
             global_size: Range3,

sycl/sycl-rs-sys/src/types-sys.rs

@@ -24,6 +24,12 @@ impl SharedWaker {
     }
 }
 
+impl Default for SharedWaker {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[cxx::bridge(namespace = "sycl_shims")]
 pub mod ffi {
     unsafe extern "C++" {

sycl/sycl-rs-sys/src/usm-sys.rs

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+#[allow(clippy::missing_safety_doc)]
 #[cxx::bridge(namespace = "sycl_shims::usm")]
 pub mod ffi {
     unsafe extern "C++" {
@@ -15,21 +16,37 @@ pub mod ffi {
 
     extern "C++" {
         include!("sycl-rs-sys/include/usm.hpp");
+        /// # Safety
+        ///
+        /// `queue` must refer to a valid SYCL queue and `alignment` must be a supported power of
+        /// two. The returned allocation must be released with `free` using a compatible queue.
         unsafe fn aligned_alloc_device(
             alignment: usize,
             num_bytes: usize,
             queue: &Queue,
         ) -> Result<*mut u8>;
+        /// # Safety
+        ///
+        /// `queue` must refer to a valid SYCL queue and `alignment` must be a supported power of
+        /// two. The returned allocation must be released with `free` using a compatible queue.
         unsafe fn aligned_alloc_host(
             alignment: usize,
             num_bytes: usize,
             queue: &Queue,
         ) -> Result<*mut u8>;
+        /// # Safety
+        ///
+        /// `queue` must refer to a valid SYCL queue and `alignment` must be a supported power of
+        /// two. The returned allocation must be released with `free` using a compatible queue.
         unsafe fn aligned_alloc_shared(
             alignment: usize,
             num_bytes: usize,
             queue: &Queue,
         ) -> Result<*mut u8>;
+        /// # Safety
+        ///
+        /// `ptr` must be a live USM allocation associated with `queue` and must not be used after
+        /// this call.
         unsafe fn free(ptr: *mut u8, queue: &Queue);
     }
 }

sycl/sycl-rs/examples/kernel_launch.rs

@@ -37,7 +37,7 @@ async fn main() -> sycl_rs::Result<()> {
         queue.launch(
             NdRange::new([1024], [16]),
             &kernel,
-            (f16::from_f32(3.14), &mut device_array),
+            (f16::from_f32(std::f32::consts::PI), &mut device_array),
         )
     }?
     .await?;

sycl/sycl-rs/examples/kernel_launch_derive.rs

@@ -42,7 +42,7 @@ fn main() -> sycl_rs::Result<()> {
             NdRange::new([1024], [16]),
             &kernel,
             IotaArgs {
-                start: 3.14_f32,
+                start: std::f32::consts::PI,
                 ptr: &mut array,
             },
         )

sycl/sycl-rs/src/event.rs

@@ -60,7 +60,7 @@ impl Future for EventFuture {
         let this = self.project();
 
         // Set the callback on first Future poll (Futures can't be active until polled)
-        if *this.set_callback == false {
+        if !*this.set_callback {
             *this.set_callback = true;
             let mut queue = Queue::new_immediate();
             this.shared.waker.register(cx.waker());

sycl/sycl-rs/src/kernel.rs

@@ -51,12 +51,16 @@ impl From<cxx::UniquePtr<types::ffi::Kernel>> for Kernel {
 
 /// Types which can be passed as SYCL kernel arguments.
 ///
-/// Safety: a type implement this trait must mirror the representation and alignment of the
+/// # Safety
+///
+/// A type implementing this trait must mirror the representation and alignment of the
 /// corresponding SYCL kernel argument structure.
 pub unsafe trait KernelArgument {
     /// Converts self to a raw byte representation.
     ///
-    /// Safety: This function returns a reference to raw bytes. These bytes will be passed to FFI
+    /// # Safety
+    ///
+    /// This function returns a reference to raw bytes. These bytes will be passed to FFI
     /// functions. The caller must make sure these functions respect Rust's aliasing rules.
     unsafe fn as_raw_arg(&self) -> &[u8];
 }
@@ -69,12 +73,16 @@ unsafe impl<T: Pod> KernelArgument for T {
 
 /// Types which describe an argument list for a SYCL kernel.
 ///
-/// Safety: a type implement this trait must mirror the representation and alignment of each
+/// # Safety
+///
+/// A type implementing this trait must mirror the representation and alignment of each
 /// corresponding SYCL kernel argument inside the returned array.
 pub unsafe trait KernelArgumentList<const ARGC: usize> {
     /// Converts each struct member to a raw byte representation.
     ///
-    /// Safety: This function returns references to raw bytes. These bytes will be passed to FFI
+    /// # Safety
+    ///
+    /// This function returns references to raw bytes. These bytes will be passed to FFI
     /// functions. The caller must make sure these functions respect Rust's aliasing rules.
     unsafe fn as_raw_arg_list(&self) -> [&[u8]; ARGC];
 }

sycl/sycl-rs/src/queue.rs

@@ -28,6 +28,12 @@ use crate::{
 /// a kernel.
 pub struct Queue(pub(crate) cxx::UniquePtr<ffi::Queue>);
 
+impl Default for Queue {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Queue {
     /// Construct a `Queue` based on the device returned from the default selector.
     pub fn new() -> Self {
@@ -77,28 +83,40 @@ impl Queue {
     }
 
     /// Allocates memory and creates a host-side [`UsmBox`] that can store an array of T.
-    /// Safety: the array contents are uninitialized.
+    ///
+    /// # Safety
+    ///
+    /// The array contents are uninitialized and must not be read before they are initialized.
     pub unsafe fn alloc_uninit_host<T>(&self, len: usize) -> HostUsmBox<T> {
         let allocator = UsmAllocator::from(self);
         unsafe { UsmBox::new(allocator, len) }
     }
 
     /// Allocates memory and creates a shared [`UsmBox`] that can store an array of T.
-    /// Safety: the array contents are uninitialized.
+    ///
+    /// # Safety
+    ///
+    /// The array contents are uninitialized and must not be read before they are initialized.
     pub unsafe fn alloc_uninit_shared<T>(&self, len: usize) -> SharedUsmBox<T> {
         let allocator = UsmAllocator::from(self);
         unsafe { UsmBox::new(allocator, len) }
     }
 
     /// Allocates memory and creates a device-side [`UsmBox`] that can store an array of T.
-    /// Safety: the array contents are uninitialized.
+    ///
+    /// # Safety
+    ///
+    /// The array contents are uninitialized and must not be read before they are initialized.
     pub unsafe fn alloc_uninit_device<T>(&self, len: usize) -> DeviceUsmBox<T> {
         let allocator = UsmAllocator::from(self);
         unsafe { UsmBox::new(allocator, len) }
     }
 
     /// Sets memory allocated with USM allocations.
-    /// Safety: the caller must make sure the underlying memory isn't being aliased somewhere else.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the underlying memory is not aliased elsewhere.
     pub unsafe fn memset<T, A: UsmAlloc>(
         &mut self,
         array: &mut UsmBox<T, A>,
@@ -108,7 +126,10 @@ impl Queue {
     }
 
     /// Sets memory allocated with USM allocations after all specified events finish.
-    /// Safety: the caller must make sure the underlying memory isn't being aliased somewhere else.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the underlying memory is not aliased elsewhere.
     pub unsafe fn memset_with_deps<T, A: UsmAlloc>(
         &mut self,
         array: &mut UsmBox<T, A>,
@@ -128,7 +149,7 @@ impl Queue {
 
     /// Submits a barrier to the queue.
     pub fn barrier(&mut self) -> Result<Event> {
-        self.barrier_with_deps(&[]).map(Into::into)
+        self.barrier_with_deps(&[])
     }
 
     /// Submits a barrier to the queue after all specified events finish.
@@ -153,7 +174,9 @@ impl Queue {
     /// Enqueues a kernel object to the queue as an ND-range kernel, using the number of work-items
     /// specified by the [`NdRange`] nd_range.
     ///
-    /// Safety: The caller must make sure each argument matches the launched SYCL kernel's
+    /// # Safety
+    ///
+    /// The caller must make sure each argument matches the launched SYCL kernel's
     /// signature, including their respective size, layout and alignment.
     pub unsafe fn launch<const ARGC: usize, const DIMENSIONS: usize>(
         &mut self,