Feat: use cuMemHostLaunch instead of cuStreamAddCallback internally

Author: RDambrosio016

crates/cust/CHANGELOG.md

@@ -17,6 +17,7 @@ overall simplifying the context handling APIs. This does mean that the API chang
 The old context handling is fully present in `cust::context::legacy` for anyone who needs it for specific reasons. If you use `quick_init` you don't need to worry about
 any breaking changes, the API is the same.
 
+- `Stream::add_callback` now internally uses `cuLaunchHostFunc` anticipating the deprecation and removal of `cuStreamAddCallback` per the driver docs. This does however mean that the function no longer takes a device status as a parameter and does not execute on context error.
 - Added `cust::memory::LockedBox`, same as `LockedBuffer` except for single elements.
 - Added `cust::memory::cuda_malloc_async`.
 - Added `cust::memory::cuda_free_async`.

crates/cust/src/stream.rs

@@ -13,7 +13,7 @@
 use crate::error::{CudaResult, DropResult, ToResult};
 use crate::event::Event;
 use crate::function::{BlockSize, Function, GridSize};
-use crate::sys::{self as cuda, cudaError_enum, CUstream};
+use crate::sys::{self as cuda, CUstream};
 use std::ffi::c_void;
 use std::mem;
 use std::panic;
@@ -147,9 +147,6 @@ impl Stream {
     ///
     /// Callbacks must not make any CUDA API calls.
     ///
-    /// The callback will be passed a `CudaResult<()>` indicating the
-    /// current state of the device with `Ok(())` denoting normal operation.
-    ///
     /// # Examples
     ///
     /// ```
@@ -163,23 +160,22 @@ impl Stream {
     ///
     /// // ... queue up some work on the stream
     ///
-    /// stream.add_callback(Box::new(|status| {
-    ///     println!("Device status is {:?}", status);
+    /// stream.add_callback(Box::new(|| {
+    ///     println!("Work is done!");
     /// }));
     ///
     /// // ... queue up some more work on the stream
     /// # Ok(())
     /// # }
     pub fn add_callback<T>(&self, callback: Box<T>) -> CudaResult<()>
     where
-        T: FnOnce(CudaResult<()>) + Send,
+        T: FnOnce() + Send,
     {
         unsafe {
-            cuda::cuStreamAddCallback(
+            cuda::cuLaunchHostFunc(
                 self.inner,
                 Some(callback_wrapper::<T>),
                 Box::into_raw(callback) as *mut c_void,
-                0,
             )
             .to_result()
         }
@@ -339,16 +335,13 @@ impl Drop for Stream {
         }
     }
 }
-unsafe extern "C" fn callback_wrapper<T>(
-    _stream: CUstream,
-    status: cudaError_enum,
-    callback: *mut c_void,
-) where
-    T: FnOnce(CudaResult<()>) + Send,
+unsafe extern "C" fn callback_wrapper<T>(callback: *mut c_void)
+where
+    T: FnOnce() + Send,
 {
     // Stop panics from unwinding across the FFI
     let _ = panic::catch_unwind(|| {
         let callback: Box<T> = Box::from_raw(callback as *mut T);
-        callback(status.to_result());
+        callback();
     });
 }