Try switching from rustacuda to cust

Author: juntyr

.github/workflows/rustdoc.yml

@@ -37,9 +37,9 @@ jobs:
             --enable-index-page \
             --extern-html-root-url const_type_layout=https://docs.rs/const-type-layout/0.3.2/ \
             --extern-html-root-url final=https://docs.rs/final/0.1.1/ \
-            --extern-html-root-url rustacuda=https://docs.rs/rustacuda/0.1.3/ \
-            --extern-html-root-url rustacuda_core=https://docs.rs/rustacuda_core/0.1.2/ \
-            --extern-html-root-url rustacuda_derive=https://docs.rs/rustacuda_derive/0.1.2/ \
+            --extern-html-root-url cust=https://docs.rs/cust/0.3.2/ \
+            --extern-html-root-url cust_core=https://docs.rs/cust_core/0.1/ \
+            --extern-html-root-url cust_derive=https://docs.rs/cust_derive/0.2/ \
             -Zunstable-options \
           " cargo doc \
             --all-features \

Cargo.toml

@@ -19,26 +19,22 @@ rust-version = "1.81" # nightly
 
 [features]
 default = []
-derive = ["dep:rustacuda_derive", "dep:rust-cuda-derive"]
+derive = ["dep:cust_derive", "dep:rust-cuda-derive"]
 device = []
 final = ["dep:final"]
-host = ["dep:rustacuda", "dep:regex", "dep:oneshot", "dep:safer_owning_ref"]
+host = ["dep:cust", "dep:regex", "dep:oneshot", "dep:safer_owning_ref"]
 kernel = ["dep:rust-cuda-kernel"]
 
 [dependencies]
-rustacuda_core = { git = "https://github.com/juntyr/RustaCUDA", rev = "c6ea7cc" }
-
-rustacuda = { git = "https://github.com/juntyr/RustaCUDA", rev = "c6ea7cc", optional = true }
-rustacuda_derive = { git = "https://github.com/juntyr/RustaCUDA", rev = "c6ea7cc", optional = true }
-
-regex = { version = "1.10", optional = true }
-
-const-type-layout = { version = "0.3.2", features = ["derive"] }
-
-safer_owning_ref = { version = "0.5", optional = true }
-oneshot = { version = "0.1", optional = true, features = ["std", "async"] }
-
-final = { version = "0.1.1", optional = true }
-
-rust-cuda-derive = { path = "rust-cuda-derive", optional = true }
-rust-cuda-kernel = { path = "rust-cuda-kernel", optional = true }
+const-type-layout = { version = "0.3.2", default-features = false, features = ["derive"] }
+# FIXME: cust fails to compile without the `bytemuck` feature
+cust = { version = "0.3.2", default-features = false, features = ["bytemuck"], optional = true }
+cust_core = { version = "0.1", default-features = false }
+cust_derive = { version = "0.2", default-features = false, optional = true }
+final = { version = "0.1.1", default-features = false, optional = true }
+oneshot = { version = "0.1", default-features = false, features = ["std", "async"], optional = true }
+regex = { version = "1.10", default-features = false, optional = true }
+safer_owning_ref = { version = "0.5", default-features = false, optional = true }
+
+rust-cuda-derive = { path = "rust-cuda-derive", default-features = false, optional = true }
+rust-cuda-kernel = { path = "rust-cuda-kernel", default-features = false, optional = true }

examples/print/src/main.rs

@@ -2,38 +2,38 @@
 
 use print::{kernel, link, Action};
 
-fn main() -> rust_cuda::deps::rustacuda::error::CudaResult<()> {
+fn main() -> rust_cuda::deps::cust::error::CudaResult<()> {
     // Link the non-generic CUDA kernel
     struct KernelPtx;
     link! { impl kernel for KernelPtx }
 
     // Initialize the CUDA API
-    rust_cuda::deps::rustacuda::init(rust_cuda::deps::rustacuda::CudaFlags::empty())?;
+    rust_cuda::deps::cust::init(rust_cuda::deps::cust::CudaFlags::empty())?;
 
     // Get the first CUDA GPU device
-    let device = rust_cuda::deps::rustacuda::device::Device::get_device(0)?;
+    let device = rust_cuda::deps::cust::device::Device::get_device(0)?;
 
     // Create a CUDA context associated to this device
     let _context = rust_cuda::host::CudaDropWrapper::from(
-        rust_cuda::deps::rustacuda::context::Context::create_and_push(
-            rust_cuda::deps::rustacuda::context::ContextFlags::MAP_HOST
-                | rust_cuda::deps::rustacuda::context::ContextFlags::SCHED_AUTO,
+        rust_cuda::deps::cust::context::Context::create_and_push(
+            rust_cuda::deps::cust::context::ContextFlags::MAP_HOST
+                | rust_cuda::deps::cust::context::ContextFlags::SCHED_AUTO,
             device,
         )?,
     );
 
     // Create a new CUDA stream to submit kernels to
     let mut stream =
-        rust_cuda::host::CudaDropWrapper::from(rust_cuda::deps::rustacuda::stream::Stream::new(
-            rust_cuda::deps::rustacuda::stream::StreamFlags::NON_BLOCKING,
+        rust_cuda::host::CudaDropWrapper::from(rust_cuda::deps::cust::stream::Stream::new(
+            rust_cuda::deps::cust::stream::StreamFlags::NON_BLOCKING,
             None,
         )?);
 
     // Create a new instance of the CUDA kernel and prepare the launch config
     let mut kernel = rust_cuda::kernel::TypedPtxKernel::<kernel>::new::<KernelPtx>(None);
     let config = rust_cuda::kernel::LaunchConfig {
-        grid: rust_cuda::deps::rustacuda::function::GridSize::x(1),
-        block: rust_cuda::deps::rustacuda::function::BlockSize::x(4),
+        grid: rust_cuda::deps::cust::function::GridSize::x(1),
+        block: rust_cuda::deps::cust::function::BlockSize::x(4),
         ptx_jit: false,
     };
 

rust-cuda-derive/src/rust_to_cuda/impl.rs

@@ -84,7 +84,7 @@ pub fn rust_to_cuda_trait(
             unsafe fn borrow<CudaAllocType: #crate_path::alloc::CudaAlloc>(
                 &self,
                 alloc: CudaAllocType,
-            ) -> #crate_path::deps::rustacuda::error::CudaResult<(
+            ) -> #crate_path::deps::cust::error::CudaResult<(
                 #crate_path::utils::ffi::DeviceAccessible<Self::CudaRepresentation>,
                 #crate_path::alloc::CombinedCudaAlloc<Self::CudaAllocation, CudaAllocType>
             )> {
@@ -107,7 +107,7 @@ pub fn rust_to_cuda_trait(
                 alloc: #crate_path::alloc::CombinedCudaAlloc<
                     Self::CudaAllocation, CudaAllocType
                 >,
-            ) -> #crate_path::deps::rustacuda::error::CudaResult<CudaAllocType> {
+            ) -> #crate_path::deps::cust::error::CudaResult<CudaAllocType> {
                 let (alloc_front, alloc_tail) = alloc.split();
 
                 #(#r2c_field_destructors)*
@@ -192,7 +192,7 @@ pub fn rust_to_cuda_async_trait(
                 &self,
                 alloc: CudaAllocType,
                 stream: #crate_path::host::Stream<'stream>,
-            ) -> #crate_path::deps::rustacuda::error::CudaResult<(
+            ) -> #crate_path::deps::cust::error::CudaResult<(
                 #crate_path::utils::r#async::Async<
                     '_, 'stream,
                     #crate_path::utils::ffi::DeviceAccessible<Self::CudaRepresentation>,
@@ -220,7 +220,7 @@ pub fn rust_to_cuda_async_trait(
                     Self::CudaAllocationAsync, CudaAllocType
                 >,
                 stream: #crate_path::host::Stream<'stream>,
-            ) -> #crate_path::deps::rustacuda::error::CudaResult<(
+            ) -> #crate_path::deps::cust::error::CudaResult<(
                 #crate_path::utils::r#async::Async<
                     'a, 'stream,
                     #crate_path::deps::owning_ref::BoxRefMut<'a, CudaRestoreOwner, Self>,

src/deps.rs

@@ -7,6 +7,6 @@ pub extern crate const_type_layout;
 pub extern crate owning_ref;
 
 #[cfg(feature = "host")]
-pub extern crate rustacuda;
+pub extern crate cust;
 
-pub extern crate rustacuda_core;
+pub extern crate cust_core;

src/host/mod.rs

@@ -5,13 +5,14 @@ use std::{
 };
 
 use const_type_layout::TypeGraphLayout;
-use rustacuda::{
+use cust::{
     context::Context,
     error::CudaError,
     event::Event,
     memory::{CopyDestination, DeviceBox, DeviceBuffer, LockedBox, LockedBuffer},
     module::Module,
 };
+use cust_core::DeviceCopy;
 
 use crate::{
     safety::PortableBitSemantics,
@@ -30,12 +31,12 @@ type InvariantLifetime<'brand> = PhantomData<fn(&'brand ()) -> &'brand ()>;
 #[derive(Copy, Clone)]
 #[repr(transparent)]
 pub struct Stream<'stream> {
-    stream: &'stream rustacuda::stream::Stream,
+    stream: &'stream cust::stream::Stream,
     _brand: InvariantLifetime<'stream>,
 }
 
 impl<'stream> Deref for Stream<'stream> {
-    type Target = rustacuda::stream::Stream;
+    type Target = cust::stream::Stream;
 
     fn deref(&self) -> &Self::Target {
         self.stream
@@ -65,7 +66,7 @@ impl<'stream> Stream<'stream> {
     /// }
     /// ```
     pub fn with<O>(
-        stream: &mut rustacuda::stream::Stream,
+        stream: &mut cust::stream::Stream,
         inner: impl for<'new_stream> FnOnce(Stream<'new_stream>) -> O,
     ) -> O {
         inner(Stream {
@@ -77,7 +78,7 @@ impl<'stream> Stream<'stream> {
 
 pub trait CudaDroppable: Sized {
     #[expect(clippy::missing_errors_doc)]
-    fn drop(val: Self) -> Result<(), (rustacuda::error::CudaError, Self)>;
+    fn drop(val: Self) -> Result<(), (cust::error::CudaError, Self)>;
 }
 
 #[repr(transparent)]
@@ -112,25 +113,27 @@ impl<C: CudaDroppable> DerefMut for CudaDropWrapper<C> {
     }
 }
 
-impl<T> CudaDroppable for DeviceBox<T> {
+impl<T: DeviceCopy> CudaDroppable for DeviceBox<T> {
     fn drop(val: Self) -> Result<(), (CudaError, Self)> {
         Self::drop(val)
     }
 }
 
-impl<T: rustacuda_core::DeviceCopy> CudaDroppable for DeviceBuffer<T> {
+impl<T: cust_core::DeviceCopy> CudaDroppable for DeviceBuffer<T> {
     fn drop(val: Self) -> Result<(), (CudaError, Self)> {
         Self::drop(val)
     }
 }
 
-impl<T> CudaDroppable for LockedBox<T> {
+impl<T: DeviceCopy> CudaDroppable for LockedBox<T> {
     fn drop(val: Self) -> Result<(), (CudaError, Self)> {
-        Self::drop(val)
+        // FIXME: cust's LockedBox no longer has a fallible drop
+        std::mem::drop(val);
+        Ok(())
     }
 }
 
-impl<T: rustacuda_core::DeviceCopy> CudaDroppable for LockedBuffer<T> {
+impl<T: cust_core::DeviceCopy> CudaDroppable for LockedBuffer<T> {
     fn drop(val: Self) -> Result<(), (CudaError, Self)> {
         Self::drop(val)
     }
@@ -147,7 +150,7 @@ macro_rules! impl_sealed_drop_value {
 }
 
 impl_sealed_drop_value!(Module);
-impl_sealed_drop_value!(rustacuda::stream::Stream);
+impl_sealed_drop_value!(cust::stream::Stream);
 impl_sealed_drop_value!(Context);
 impl_sealed_drop_value!(Event);
 
@@ -207,7 +210,7 @@ impl<'a, T: PortableBitSemantics + TypeGraphLayout> HostAndDeviceMutRef<'a, T> {
         'a: 'b,
     {
         DeviceMutRef {
-            pointer: DeviceMutPointer(self.device_box.as_device_ptr().as_raw_mut().cast()),
+            pointer: DeviceMutPointer(self.device_box.as_device_ptr().as_mut_ptr().cast()),
             reference: PhantomData,
         }
     }
@@ -322,10 +325,10 @@ impl<'a, T: PortableBitSemantics + TypeGraphLayout> HostAndDeviceConstRef<'a, T>
     where
         'a: 'b,
     {
-        let mut hack = ManuallyDrop::new(unsafe { std::ptr::read(self.device_box) });
+        let hack = ManuallyDrop::new(unsafe { std::ptr::read(self.device_box) });
 
         DeviceConstRef {
-            pointer: DeviceConstPointer(hack.as_device_ptr().as_raw().cast()),
+            pointer: DeviceConstPointer(hack.as_device_ptr().as_ptr().cast()),
             reference: PhantomData,
         }
     }
@@ -390,7 +393,7 @@ impl<'a, T: PortableBitSemantics + TypeGraphLayout> HostAndDeviceOwned<'a, T> {
     #[must_use]
     pub(crate) fn for_device(self) -> DeviceOwnedRef<'a, T> {
         DeviceOwnedRef {
-            pointer: DeviceOwnedPointer(self.device_box.as_device_ptr().as_raw_mut().cast()),
+            pointer: DeviceOwnedPointer(self.device_box.as_device_ptr().as_mut_ptr().cast()),
             marker: PhantomData::<T>,
             reference: PhantomData::<&'a mut ()>,
         }

src/kernel/mod.rs

@@ -1,3 +1,4 @@
+use core::str;
 #[cfg(feature = "host")]
 use std::{
     ffi::{CStr, CString},
@@ -6,8 +7,9 @@ use std::{
     ptr::NonNull,
 };
 
+use cust::module::{ModuleJitOption, OptLevel};
 #[cfg(feature = "host")]
-use rustacuda::{
+use cust::{
     error::{CudaError, CudaResult},
     function::Function,
     module::Module,
@@ -42,12 +44,7 @@ mod sealed {
 
 #[cfg(all(feature = "host", not(doc)))]
 #[doc(hidden)]
-pub trait WithNewAsync<
-    'stream,
-    P: ?Sized + CudaKernelParameter,
-    O,
-    E: From<rustacuda::error::CudaError>,
->
+pub trait WithNewAsync<'stream, P: ?Sized + CudaKernelParameter, O, E: From<cust::error::CudaError>>
 {
     fn with<'b>(self, param: P::AsyncHostType<'stream, 'b>) -> Result<O, E>
     where
@@ -59,7 +56,7 @@ impl<
         'stream,
         P: ?Sized + CudaKernelParameter,
         O,
-        E: From<rustacuda::error::CudaError>,
+        E: From<cust::error::CudaError>,
         F: for<'b> FnOnce(P::AsyncHostType<'stream, 'b>) -> Result<O, E>,
     > WithNewAsync<'stream, P, O, E> for F
 {
@@ -109,7 +106,7 @@ pub trait CudaKernelParameter: sealed::Sealed {
 
     #[cfg(feature = "host")]
     #[expect(clippy::missing_errors_doc)] // FIXME
-    fn with_new_async<'stream, 'b, O, E: From<rustacuda::error::CudaError>>(
+    fn with_new_async<'stream, 'b, O, E: From<cust::error::CudaError>>(
         param: Self::SyncHostType,
         stream: crate::host::Stream<'stream>,
         #[cfg(not(doc))] inner: impl WithNewAsync<'stream, Self, O, E>,
@@ -139,7 +136,7 @@ pub trait CudaKernelParameter: sealed::Sealed {
 
     #[doc(hidden)]
     #[cfg(feature = "host")]
-    fn async_to_ffi<'stream, 'b, E: From<rustacuda::error::CudaError>>(
+    fn async_to_ffi<'stream, 'b, E: From<cust::error::CudaError>>(
         param: Self::AsyncHostType<'stream, 'b>,
         token: sealed::Token,
     ) -> Result<Self::FfiType<'stream, 'b>, E>
@@ -286,8 +283,8 @@ impl<'stream, 'kernel, Kernel> Launcher<'stream, 'kernel, Kernel> {
 #[cfg(feature = "host")]
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LaunchConfig {
-    pub grid: rustacuda::function::GridSize,
-    pub block: rustacuda::function::BlockSize,
+    pub grid: cust::function::GridSize,
+    pub block: cust::function::BlockSize,
     pub ptx_jit: bool,
 }
 
@@ -305,9 +302,15 @@ impl RawPtxKernel {
     /// Returns a [`CudaError`] if `ptx` is not a valid PTX source, or it does
     ///  not contain an entry point named `entry_point`.
     pub fn new(ptx: &CStr, entry_point: &CStr) -> CudaResult<Self> {
-        let module: Box<Module> = Box::new(Module::load_from_string(ptx)?);
-
-        let function = unsafe { &*std::ptr::from_ref(module.as_ref()) }.get_function(entry_point);
+        let module: Box<Module> = Box::new(Module::from_ptx_cstr(
+            ptx,
+            &[ModuleJitOption::OptLevel(OptLevel::O4)],
+        )?);
+
+        // FIXME: cust's Module::get_function takes a str and turns it back into
+        //        a CString immediately
+        let function = unsafe { &*std::ptr::from_ref(module.as_ref()) }
+            .get_function(unsafe { str::from_utf8_unchecked(entry_point.to_bytes()) });
 
         let function = match function {
             Ok(function) => function,