Feat: impl Send + Sync for most cust structs

Author: RDambrosio016

crates/cust/CHANGELOG.md

@@ -28,6 +28,8 @@ any breaking changes, the API is the same.
 - Added `drop_async` to `DeviceBox`.
 - Added `new_async` to `DeviceBox`.
 - `Linker::complete` now only returns the built cubin, and not the cubin and a duration.
+- `Stream`, `Module`, `Linker`, `Function`, `Event`, `UnifiedBox`, `ArrayObject`, `LockedBuffer`, `LockedBox`, `DeviceSlice`, `DeviceBuffer`, and `DeviceBox` all now impl `Send` and `Sync`, this makes
+it much easier to write multigpu code. The CUDA API is fully thread-safe except for graph objects.
 
 ## 0.2.2 - 12/5/21
 

crates/cust/src/context/mod.rs

@@ -166,6 +166,9 @@ pub struct Context {
     device: cuda::CUdevice,
 }
 
+unsafe impl Send for Context {}
+unsafe impl Sync for Context {}
+
 impl Clone for Context {
     fn clone(&self) -> Self {
         // because we already retained a context on this device successfully (self), it is

crates/cust/src/event.rs

@@ -67,6 +67,9 @@ pub enum EventStatus {
 #[derive(Debug)]
 pub struct Event(CUevent);
 
+unsafe impl Send for Event {}
+unsafe impl Sync for Event {}
+
 impl Event {
     /// Create a new event with the specified flags.
     ///

crates/cust/src/function.rs

@@ -205,6 +205,10 @@ pub struct Function<'a> {
     inner: CUfunction,
     module: PhantomData<&'a Module>,
 }
+
+unsafe impl Send for Function<'_> {}
+unsafe impl Sync for Function<'_> {}
+
 impl<'a> Function<'a> {
     pub(crate) fn new(inner: CUfunction, _module: &Module) -> Function {
         Function {

crates/cust/src/link.rs

@@ -15,6 +15,9 @@ pub struct Linker {
     raw: cuda::CUlinkState,
 }
 
+unsafe impl Send for Linker {}
+unsafe impl Sync for Linker {}
+
 impl Linker {
     /// Creates a new linker.
     pub fn new() -> CudaResult<Self> {

crates/cust/src/memory/array.rs

@@ -305,6 +305,9 @@ pub struct ArrayObject {
     pub(crate) handle: CUarray,
 }
 
+unsafe impl Send for ArrayObject {}
+unsafe impl Sync for ArrayObject {}
+
 impl ArrayObject {
     pub(crate) fn into_raw(self) -> CUarray {
         ManuallyDrop::new(self).handle

crates/cust/src/memory/device/device_box.rs

@@ -18,6 +18,10 @@ use std::os::raw::c_void;
 pub struct DeviceBox<T> {
     pub(crate) ptr: DevicePointer<T>,
 }
+
+unsafe impl<T: Send> Send for DeviceBox<T> {}
+unsafe impl<T: Sync> Sync for DeviceBox<T> {}
+
 impl<T: DeviceCopy> DeviceBox<T> {
     /// Allocate device memory and place val into it.
     ///

crates/cust/src/memory/device/device_buffer.rs

@@ -16,6 +16,10 @@ pub struct DeviceBuffer<T> {
     buf: DevicePointer<T>,
     capacity: usize,
 }
+
+unsafe impl<T: Send> Send for DeviceBuffer<T> {}
+unsafe impl<T: Sync> Sync for DeviceBuffer<T> {}
+
 impl<T> DeviceBuffer<T> {
     /// Allocate a new device buffer large enough to hold `size` `T`'s, but without
     /// initializing the contents.

crates/cust/src/memory/device/device_slice.rs

@@ -19,6 +19,9 @@ use std::slice::{self, Chunks, ChunksMut};
 #[repr(C)]
 pub struct DeviceSlice<T>([T]);
 
+unsafe impl<T: Send> Send for DeviceSlice<T> {}
+unsafe impl<T: Sync> Sync for DeviceSlice<T> {}
+
 impl<T: DeviceCopy + Default + Clone> DeviceSlice<T> {
     pub fn as_host_vec(&self) -> CudaResult<Vec<T>> {
         let mut vec = vec![T::default(); self.len()];

crates/cust/src/memory/locked/locked_box.rs

@@ -30,6 +30,9 @@ pub struct LockedBox<T: DeviceCopy> {
     pub(crate) ptr: *mut T,
 }
 
+unsafe impl<T: Send + DeviceCopy> Send for LockedBox<T> {}
+unsafe impl<T: Sync + DeviceCopy> Sync for LockedBox<T> {}
+
 impl<T: DeviceCopy> LockedBox<T> {
     /// Creates an uninitialized [`LockedBox`]. The contents must
     /// not be read until the box is written to.