Convert CUDA performance lib statuses to Rust result types (#444)

These changes replicate how the main library is handled. cuDNN still needs to have zluda_bindgen run and zluda_dump_common updated

.github/workflows/rocm_setup_build.sh

@@ -11,7 +11,7 @@ echo deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.c
 echo -e 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600' \
     | tee /etc/apt/preferences.d/rocm-pin-600
 DEBIAN_FRONTEND=noninteractive apt update -y
-DEBIAN_FRONTEND=noninteractive apt install -y --no-install-recommends rocm-smi-lib rocm-llvm-dev hip-runtime-amd hip-dev rocblas
+DEBIAN_FRONTEND=noninteractive apt install -y --no-install-recommends rocm-smi-lib rocm-llvm-dev hip-runtime-amd hip-dev rocblas-dev
 echo 'export PATH="$PATH:/opt/rocm/bin"' |  tee /etc/profile.d/rocm.sh
 echo "/opt/rocm/lib" | tee /etc/ld.so.conf.d/rocm.conf
 ldconfig

Cargo.lock

@@ -317,6 +317,7 @@ dependencies = [
  "bitflags 2.9.1",
  "cuda_macros",
  "hip_runtime-sys",
+ "rocblas-sys",
 ]
 
 [[package]]

cuda_types/Cargo.toml

@@ -8,3 +8,4 @@ edition = "2021"
 cuda_macros = { path = "../cuda_macros" }
 hip_runtime-sys = { path = "../ext/hip_runtime-sys" }
 bitflags = "2.9.1"
+rocblas-sys = { path = "../ext/rocblas-sys" }

cuda_types/src/cublas.rs

@@ -17,40 +17,6 @@ pub const CUBLAS_VER_MINOR: u32 = 8;
 pub const CUBLAS_VER_PATCH: u32 = 4;
 pub const CUBLAS_VER_BUILD: u32 = 1;
 pub const CUBLAS_VERSION: u32 = 120804;
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_SUCCESS: cublasStatus_t = cublasStatus_t(0);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_NOT_INITIALIZED: cublasStatus_t = cublasStatus_t(1);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_ALLOC_FAILED: cublasStatus_t = cublasStatus_t(3);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_INVALID_VALUE: cublasStatus_t = cublasStatus_t(7);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_ARCH_MISMATCH: cublasStatus_t = cublasStatus_t(8);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_MAPPING_ERROR: cublasStatus_t = cublasStatus_t(11);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_EXECUTION_FAILED: cublasStatus_t = cublasStatus_t(13);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_INTERNAL_ERROR: cublasStatus_t = cublasStatus_t(14);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_NOT_SUPPORTED: cublasStatus_t = cublasStatus_t(15);
-}
-impl cublasStatus_t {
-    pub const CUBLAS_STATUS_LICENSE_ERROR: cublasStatus_t = cublasStatus_t(16);
-}
-#[repr(transparent)]
-#[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct cublasStatus_t(pub ::core::ffi::c_uint);
 impl cublasFillMode_t {
     pub const CUBLAS_FILL_MODE_LOWER: cublasFillMode_t = cublasFillMode_t(0);
 }
@@ -322,3 +288,76 @@ pub type cublasHandle_t = *mut cublasContext;
 pub type cublasLogCallback = ::core::option::Option<
     unsafe extern "C" fn(msg: *const ::core::ffi::c_char),
 >;
+impl cublasError_t {
+    pub const r#NOT_INITIALIZED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const r#ALLOC_FAILED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const r#INVALID_VALUE: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const r#ARCH_MISMATCH: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const r#MAPPING_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+    pub const r#EXECUTION_FAILED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(13)
+    });
+    pub const r#INTERNAL_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(14)
+    });
+    pub const r#NOT_SUPPORTED: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(15)
+    });
+    pub const r#LICENSE_ERROR: cublasError_t = cublasError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(16)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cublasError_t(pub ::core::num::NonZeroU32);
+pub trait cublasStatus_tConsts {
+    const SUCCESS: cublasStatus_t = cublasStatus_t::Ok(());
+    const ERROR_NOT_INITIALIZED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#NOT_INITIALIZED,
+    );
+    const ERROR_ALLOC_FAILED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#ALLOC_FAILED,
+    );
+    const ERROR_INVALID_VALUE: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#INVALID_VALUE,
+    );
+    const ERROR_ARCH_MISMATCH: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#ARCH_MISMATCH,
+    );
+    const ERROR_MAPPING_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#MAPPING_ERROR,
+    );
+    const ERROR_EXECUTION_FAILED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#EXECUTION_FAILED,
+    );
+    const ERROR_INTERNAL_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#INTERNAL_ERROR,
+    );
+    const ERROR_NOT_SUPPORTED: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#NOT_SUPPORTED,
+    );
+    const ERROR_LICENSE_ERROR: cublasStatus_t = cublasStatus_t::Err(
+        cublasError_t::r#LICENSE_ERROR,
+    );
+}
+impl cublasStatus_tConsts for cublasStatus_t {}
+#[must_use]
+pub type cublasStatus_t = ::core::result::Result<(), cublasError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cublasStatus_t, u32>;
+};
+impl From<rocblas_sys::rocblas_error> for cublasError_t {
+    fn from(error: rocblas_sys::rocblas_error) -> Self {
+        Self(error.0)
+    }
+}

cuda_types/src/cuda.rs

@@ -4333,9 +4333,6 @@ pub struct CUlibraryHostUniversalFunctionAndDataTable_st {
     pub dataWindowSize: usize,
 }
 pub type CUlibraryHostUniversalFunctionAndDataTable = CUlibraryHostUniversalFunctionAndDataTable_st;
-/// Error codes
-#[must_use]
-pub type cudaError_enum = ::core::ffi::c_uint;
 impl CUdevice_P2PAttribute_enum {
     ///< A relative value indicating the performance of the link between two devices
     pub const CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: CUdevice_P2PAttribute_enum = CUdevice_P2PAttribute_enum(

cuda_types/src/cufft.rs

@@ -50,62 +50,6 @@ pub struct cudaLibXtDesc_t {
     pub libDescriptor: *mut ::core::ffi::c_void,
 }
 pub type cudaLibXtDesc = cudaLibXtDesc_t;
-impl cufftResult_t {
-    pub const CUFFT_SUCCESS: cufftResult_t = cufftResult_t(0);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_PLAN: cufftResult_t = cufftResult_t(1);
-}
-impl cufftResult_t {
-    pub const CUFFT_ALLOC_FAILED: cufftResult_t = cufftResult_t(2);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_TYPE: cufftResult_t = cufftResult_t(3);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_VALUE: cufftResult_t = cufftResult_t(4);
-}
-impl cufftResult_t {
-    pub const CUFFT_INTERNAL_ERROR: cufftResult_t = cufftResult_t(5);
-}
-impl cufftResult_t {
-    pub const CUFFT_EXEC_FAILED: cufftResult_t = cufftResult_t(6);
-}
-impl cufftResult_t {
-    pub const CUFFT_SETUP_FAILED: cufftResult_t = cufftResult_t(7);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_SIZE: cufftResult_t = cufftResult_t(8);
-}
-impl cufftResult_t {
-    pub const CUFFT_UNALIGNED_DATA: cufftResult_t = cufftResult_t(9);
-}
-impl cufftResult_t {
-    pub const CUFFT_INCOMPLETE_PARAMETER_LIST: cufftResult_t = cufftResult_t(10);
-}
-impl cufftResult_t {
-    pub const CUFFT_INVALID_DEVICE: cufftResult_t = cufftResult_t(11);
-}
-impl cufftResult_t {
-    pub const CUFFT_PARSE_ERROR: cufftResult_t = cufftResult_t(12);
-}
-impl cufftResult_t {
-    pub const CUFFT_NO_WORKSPACE: cufftResult_t = cufftResult_t(13);
-}
-impl cufftResult_t {
-    pub const CUFFT_NOT_IMPLEMENTED: cufftResult_t = cufftResult_t(14);
-}
-impl cufftResult_t {
-    pub const CUFFT_LICENSE_ERROR: cufftResult_t = cufftResult_t(15);
-}
-impl cufftResult_t {
-    pub const CUFFT_NOT_SUPPORTED: cufftResult_t = cufftResult_t(16);
-}
-#[repr(transparent)]
-#[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct cufftResult_t(pub ::core::ffi::c_uint);
-pub use self::cufftResult_t as cufftResult;
 pub type cufftReal = f32;
 pub type cufftDoubleReal = f64;
 pub type cufftComplex = super::cuda::cuComplex;
@@ -425,3 +369,109 @@ pub type cufftJITCallbackStoreD = ::core::option::Option<
         sharedPointer: *mut ::core::ffi::c_void,
     ),
 >;
+impl cufftError_t {
+    pub const r#INVALID_PLAN: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const r#ALLOC_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(2)
+    });
+    pub const r#INVALID_TYPE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const r#INVALID_VALUE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(4)
+    });
+    pub const r#INTERNAL_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(5)
+    });
+    pub const r#EXEC_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(6)
+    });
+    pub const r#SETUP_FAILED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const r#INVALID_SIZE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const r#UNALIGNED_DATA: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(9)
+    });
+    pub const r#INCOMPLETE_PARAMETER_LIST: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(10)
+    });
+    pub const r#INVALID_DEVICE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+    pub const r#PARSE_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(12)
+    });
+    pub const r#NO_WORKSPACE: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(13)
+    });
+    pub const r#NOT_IMPLEMENTED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(14)
+    });
+    pub const r#LICENSE_ERROR: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(15)
+    });
+    pub const r#NOT_SUPPORTED: cufftError_t = cufftError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(16)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cufftError_t(pub ::core::num::NonZeroU32);
+pub trait cufftResultConsts {
+    const SUCCESS: cufftResult = cufftResult::Ok(());
+    const ERROR_INVALID_PLAN: cufftResult = cufftResult::Err(
+        cufftError_t::r#INVALID_PLAN,
+    );
+    const ERROR_ALLOC_FAILED: cufftResult = cufftResult::Err(
+        cufftError_t::r#ALLOC_FAILED,
+    );
+    const ERROR_INVALID_TYPE: cufftResult = cufftResult::Err(
+        cufftError_t::r#INVALID_TYPE,
+    );
+    const ERROR_INVALID_VALUE: cufftResult = cufftResult::Err(
+        cufftError_t::r#INVALID_VALUE,
+    );
+    const ERROR_INTERNAL_ERROR: cufftResult = cufftResult::Err(
+        cufftError_t::r#INTERNAL_ERROR,
+    );
+    const ERROR_EXEC_FAILED: cufftResult = cufftResult::Err(cufftError_t::r#EXEC_FAILED);
+    const ERROR_SETUP_FAILED: cufftResult = cufftResult::Err(
+        cufftError_t::r#SETUP_FAILED,
+    );
+    const ERROR_INVALID_SIZE: cufftResult = cufftResult::Err(
+        cufftError_t::r#INVALID_SIZE,
+    );
+    const ERROR_UNALIGNED_DATA: cufftResult = cufftResult::Err(
+        cufftError_t::r#UNALIGNED_DATA,
+    );
+    const ERROR_INCOMPLETE_PARAMETER_LIST: cufftResult = cufftResult::Err(
+        cufftError_t::r#INCOMPLETE_PARAMETER_LIST,
+    );
+    const ERROR_INVALID_DEVICE: cufftResult = cufftResult::Err(
+        cufftError_t::r#INVALID_DEVICE,
+    );
+    const ERROR_PARSE_ERROR: cufftResult = cufftResult::Err(cufftError_t::r#PARSE_ERROR);
+    const ERROR_NO_WORKSPACE: cufftResult = cufftResult::Err(
+        cufftError_t::r#NO_WORKSPACE,
+    );
+    const ERROR_NOT_IMPLEMENTED: cufftResult = cufftResult::Err(
+        cufftError_t::r#NOT_IMPLEMENTED,
+    );
+    const ERROR_LICENSE_ERROR: cufftResult = cufftResult::Err(
+        cufftError_t::r#LICENSE_ERROR,
+    );
+    const ERROR_NOT_SUPPORTED: cufftResult = cufftResult::Err(
+        cufftError_t::r#NOT_SUPPORTED,
+    );
+}
+impl cufftResultConsts for cufftResult {}
+#[must_use]
+pub type cufftResult = ::core::result::Result<(), cufftError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cufftResult, u32>;
+};

cuda_types/src/cusparse.rs

@@ -85,50 +85,6 @@ pub struct pruneInfo {
     _unused: [u8; 0],
 }
 pub type pruneInfo_t = *mut pruneInfo;
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_SUCCESS: cusparseStatus_t = cusparseStatus_t(0);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_NOT_INITIALIZED: cusparseStatus_t = cusparseStatus_t(1);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ALLOC_FAILED: cusparseStatus_t = cusparseStatus_t(2);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INVALID_VALUE: cusparseStatus_t = cusparseStatus_t(3);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ARCH_MISMATCH: cusparseStatus_t = cusparseStatus_t(4);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_MAPPING_ERROR: cusparseStatus_t = cusparseStatus_t(5);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_EXECUTION_FAILED: cusparseStatus_t = cusparseStatus_t(6);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INTERNAL_ERROR: cusparseStatus_t = cusparseStatus_t(7);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t(
-        8,
-    );
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_ZERO_PIVOT: cusparseStatus_t = cusparseStatus_t(9);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t(10);
-}
-impl cusparseStatus_t {
-    pub const CUSPARSE_STATUS_INSUFFICIENT_RESOURCES: cusparseStatus_t = cusparseStatus_t(
-        11,
-    );
-}
-#[repr(transparent)]
-#[must_use]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct cusparseStatus_t(pub ::core::ffi::c_uint);
 impl cusparsePointerMode_t {
     pub const CUSPARSE_POINTER_MODE_HOST: cusparsePointerMode_t = cusparsePointerMode_t(
         0,
@@ -530,3 +486,83 @@ impl cusparseSpMMOpAlg_t {
 #[repr(transparent)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct cusparseSpMMOpAlg_t(pub ::core::ffi::c_uint);
+impl cusparseError_t {
+    pub const r#NOT_INITIALIZED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(1)
+    });
+    pub const r#ALLOC_FAILED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(2)
+    });
+    pub const r#INVALID_VALUE: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(3)
+    });
+    pub const r#ARCH_MISMATCH: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(4)
+    });
+    pub const r#MAPPING_ERROR: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(5)
+    });
+    pub const r#EXECUTION_FAILED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(6)
+    });
+    pub const r#INTERNAL_ERROR: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(7)
+    });
+    pub const r#MATRIX_TYPE_NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(8)
+    });
+    pub const r#ZERO_PIVOT: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(9)
+    });
+    pub const r#NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(10)
+    });
+    pub const r#INSUFFICIENT_RESOURCES: cusparseError_t = cusparseError_t(unsafe {
+        ::core::num::NonZeroU32::new_unchecked(11)
+    });
+}
+#[repr(transparent)]
+#[derive(Debug, Hash, Copy, Clone, PartialEq, Eq)]
+pub struct cusparseError_t(pub ::core::num::NonZeroU32);
+pub trait cusparseStatus_tConsts {
+    const SUCCESS: cusparseStatus_t = cusparseStatus_t::Ok(());
+    const ERROR_NOT_INITIALIZED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#NOT_INITIALIZED,
+    );
+    const ERROR_ALLOC_FAILED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#ALLOC_FAILED,
+    );
+    const ERROR_INVALID_VALUE: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#INVALID_VALUE,
+    );
+    const ERROR_ARCH_MISMATCH: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#ARCH_MISMATCH,
+    );
+    const ERROR_MAPPING_ERROR: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#MAPPING_ERROR,
+    );
+    const ERROR_EXECUTION_FAILED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#EXECUTION_FAILED,
+    );
+    const ERROR_INTERNAL_ERROR: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#INTERNAL_ERROR,
+    );
+    const ERROR_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#MATRIX_TYPE_NOT_SUPPORTED,
+    );
+    const ERROR_ZERO_PIVOT: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#ZERO_PIVOT,
+    );
+    const ERROR_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#NOT_SUPPORTED,
+    );
+    const ERROR_INSUFFICIENT_RESOURCES: cusparseStatus_t = cusparseStatus_t::Err(
+        cusparseError_t::r#INSUFFICIENT_RESOURCES,
+    );
+}
+impl cusparseStatus_tConsts for cusparseStatus_t {}
+#[must_use]
+pub type cusparseStatus_t = ::core::result::Result<(), cusparseError_t>;
+const _: fn() = || {
+    let _ = std::mem::transmute::<cusparseStatus_t, u32>;
+};

cuda_types/src/nvml.rs

@@ -2140,8 +2140,6 @@ impl nvmlInforomObject_enum {
 pub struct nvmlInforomObject_enum(pub ::core::ffi::c_uint);
 /// Available infoROM objects.
 pub use self::nvmlInforomObject_enum as nvmlInforomObject_t;
-/// Return values for NVML API calls.
-pub type nvmlReturn_enum = ::core::ffi::c_uint;
 impl nvmlMemoryLocation_enum {
     ///!< GPU L1 Cache
     pub const NVML_MEMORY_LOCATION_L1_CACHE: nvmlMemoryLocation_enum = nvmlMemoryLocation_enum(

ext/rocblas-sys/src/lib.rs

@@ -254,8 +254,6 @@ impl rocblas_computetype_ {
 pub struct rocblas_computetype_(pub ::core::ffi::c_uint);
 /// \brief Indicates the compute precision mode.
 pub use self::rocblas_computetype_ as rocblas_computetype;
-///   @brief rocblas status codes definition
-pub type rocblas_status_ = ::core::ffi::c_uint;
 impl rocblas_pointer_mode_ {
     /// \brief Scalar values affected by this variable are located on the host.
     pub const rocblas_pointer_mode_host: rocblas_pointer_mode_ = rocblas_pointer_mode_(

format/src/format_generated_blas.rs

@@ -1,48 +1,6 @@
 // Generated automatically by zluda_bindgen
 // DO NOT EDIT MANUALLY
 #![allow(warnings)]
-impl crate::CudaDisplay for cuda_types::cublas::cublasStatus_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_SUCCESS => {
-                writer.write_all(stringify!(CUBLAS_STATUS_SUCCESS).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_NOT_INITIALIZED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_NOT_INITIALIZED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INVALID_VALUE => {
-                writer.write_all(stringify!(CUBLAS_STATUS_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_ARCH_MISMATCH => {
-                writer.write_all(stringify!(CUBLAS_STATUS_ARCH_MISMATCH).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_MAPPING_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_MAPPING_ERROR).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_EXECUTION_FAILED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_EXECUTION_FAILED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUBLAS_STATUS_NOT_SUPPORTED).as_bytes())
-            }
-            &cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_LICENSE_ERROR => {
-                writer.write_all(stringify!(CUBLAS_STATUS_LICENSE_ERROR).as_bytes())
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cublas::cublasFillMode_t {
     fn write(
         &self,
@@ -30267,3 +30225,29 @@ pub fn write_cublasUint8gemmBias(
     crate::CudaDisplay::write(&C_shift, "cublasUint8gemmBias", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cublas::cublasStatus_t {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUBLAS_STATUS_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUBLAS_STATUS_NOT_INITIALIZED".as_bytes()),
+                    3 => writer.write_all("CUBLAS_STATUS_ALLOC_FAILED".as_bytes()),
+                    7 => writer.write_all("CUBLAS_STATUS_INVALID_VALUE".as_bytes()),
+                    8 => writer.write_all("CUBLAS_STATUS_ARCH_MISMATCH".as_bytes()),
+                    11 => writer.write_all("CUBLAS_STATUS_MAPPING_ERROR".as_bytes()),
+                    13 => writer.write_all("CUBLAS_STATUS_EXECUTION_FAILED".as_bytes()),
+                    14 => writer.write_all("CUBLAS_STATUS_INTERNAL_ERROR".as_bytes()),
+                    15 => writer.write_all("CUBLAS_STATUS_NOT_SUPPORTED".as_bytes()),
+                    16 => writer.write_all("CUBLAS_STATUS_LICENSE_ERROR".as_bytes()),
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

format/src/format_generated_fft.rs

@@ -61,69 +61,6 @@ impl crate::CudaDisplay for cuda_types::cufft::cudaLibXtDesc_t {
         writer.write_all(b" }")
     }
 }
-impl crate::CudaDisplay for cuda_types::cufft::cufftResult_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cufft::cufftResult_t::CUFFT_SUCCESS => {
-                writer.write_all(stringify!(CUFFT_SUCCESS).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_PLAN => {
-                writer.write_all(stringify!(CUFFT_INVALID_PLAN).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUFFT_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_TYPE => {
-                writer.write_all(stringify!(CUFFT_INVALID_TYPE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_VALUE => {
-                writer.write_all(stringify!(CUFFT_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUFFT_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_EXEC_FAILED => {
-                writer.write_all(stringify!(CUFFT_EXEC_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_SETUP_FAILED => {
-                writer.write_all(stringify!(CUFFT_SETUP_FAILED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_SIZE => {
-                writer.write_all(stringify!(CUFFT_INVALID_SIZE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_UNALIGNED_DATA => {
-                writer.write_all(stringify!(CUFFT_UNALIGNED_DATA).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INCOMPLETE_PARAMETER_LIST => {
-                writer.write_all(stringify!(CUFFT_INCOMPLETE_PARAMETER_LIST).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_INVALID_DEVICE => {
-                writer.write_all(stringify!(CUFFT_INVALID_DEVICE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_PARSE_ERROR => {
-                writer.write_all(stringify!(CUFFT_PARSE_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NO_WORKSPACE => {
-                writer.write_all(stringify!(CUFFT_NO_WORKSPACE).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NOT_IMPLEMENTED => {
-                writer.write_all(stringify!(CUFFT_NOT_IMPLEMENTED).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_LICENSE_ERROR => {
-                writer.write_all(stringify!(CUFFT_LICENSE_ERROR).as_bytes())
-            }
-            &cuda_types::cufft::cufftResult_t::CUFFT_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUFFT_NOT_SUPPORTED).as_bytes())
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cufft::cufftType_t {
     fn write(
         &self,
@@ -2232,3 +2169,36 @@ pub fn write_cufftXtSetWorkAreaPolicy(
     crate::CudaDisplay::write(&workSize, "cufftXtSetWorkAreaPolicy", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cufft::cufftResult {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUFFT_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUFFT_INVALID_PLAN".as_bytes()),
+                    2 => writer.write_all("CUFFT_ALLOC_FAILED".as_bytes()),
+                    3 => writer.write_all("CUFFT_INVALID_TYPE".as_bytes()),
+                    4 => writer.write_all("CUFFT_INVALID_VALUE".as_bytes()),
+                    5 => writer.write_all("CUFFT_INTERNAL_ERROR".as_bytes()),
+                    6 => writer.write_all("CUFFT_EXEC_FAILED".as_bytes()),
+                    7 => writer.write_all("CUFFT_SETUP_FAILED".as_bytes()),
+                    8 => writer.write_all("CUFFT_INVALID_SIZE".as_bytes()),
+                    9 => writer.write_all("CUFFT_UNALIGNED_DATA".as_bytes()),
+                    10 => writer.write_all("CUFFT_INCOMPLETE_PARAMETER_LIST".as_bytes()),
+                    11 => writer.write_all("CUFFT_INVALID_DEVICE".as_bytes()),
+                    12 => writer.write_all("CUFFT_PARSE_ERROR".as_bytes()),
+                    13 => writer.write_all("CUFFT_NO_WORKSPACE".as_bytes()),
+                    14 => writer.write_all("CUFFT_NOT_IMPLEMENTED".as_bytes()),
+                    15 => writer.write_all("CUFFT_LICENSE_ERROR".as_bytes()),
+                    16 => writer.write_all("CUFFT_NOT_SUPPORTED".as_bytes()),
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

format/src/format_generated_sparse.rs

@@ -155,60 +155,6 @@ impl crate::CudaDisplay for cuda_types::cusparse::pruneInfo_t {
         }
     }
 }
-impl crate::CudaDisplay for cuda_types::cusparse::cusparseStatus_t {
-    fn write(
-        &self,
-        _fn_name: &'static str,
-        _index: usize,
-        writer: &mut (impl std::io::Write + ?Sized),
-    ) -> std::io::Result<()> {
-        match self {
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_SUCCESS => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_SUCCESS).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_NOT_INITIALIZED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_NOT_INITIALIZED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ALLOC_FAILED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ALLOC_FAILED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INVALID_VALUE => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_INVALID_VALUE).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ARCH_MISMATCH => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ARCH_MISMATCH).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_MAPPING_ERROR => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_MAPPING_ERROR).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_EXECUTION_FAILED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_EXECUTION_FAILED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INTERNAL_ERROR => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_INTERNAL_ERROR).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED => {
-                writer
-                    .write_all(
-                        stringify!(CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED).as_bytes(),
-                    )
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_ZERO_PIVOT => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_ZERO_PIVOT).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_NOT_SUPPORTED => {
-                writer.write_all(stringify!(CUSPARSE_STATUS_NOT_SUPPORTED).as_bytes())
-            }
-            &cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INSUFFICIENT_RESOURCES => {
-                writer
-                    .write_all(
-                        stringify!(CUSPARSE_STATUS_INSUFFICIENT_RESOURCES).as_bytes(),
-                    )
-            }
-            _ => write!(writer, "{}", self.0),
-        }
-    }
-}
 impl crate::CudaDisplay for cuda_types::cusparse::cusparsePointerMode_t {
     fn write(
         &self,
@@ -31120,3 +31066,41 @@ pub fn write_cusparseSpMMOp_destroyPlan(
     crate::CudaDisplay::write(&plan, "cusparseSpMMOp_destroyPlan", arg_idx, writer)?;
     writer.write_all(b")")
 }
+impl crate::CudaDisplay for cuda_types::cusparse::cusparseStatus_t {
+    fn write(
+        &self,
+        _fn_name: &'static str,
+        _index: usize,
+        writer: &mut (impl std::io::Write + ?Sized),
+    ) -> std::io::Result<()> {
+        match self {
+            Ok(()) => writer.write_all(b"CUSPARSE_STATUS_SUCCESS"),
+            Err(err) => {
+                match err.0.get() {
+                    1 => writer.write_all("CUSPARSE_STATUS_NOT_INITIALIZED".as_bytes()),
+                    2 => writer.write_all("CUSPARSE_STATUS_ALLOC_FAILED".as_bytes()),
+                    3 => writer.write_all("CUSPARSE_STATUS_INVALID_VALUE".as_bytes()),
+                    4 => writer.write_all("CUSPARSE_STATUS_ARCH_MISMATCH".as_bytes()),
+                    5 => writer.write_all("CUSPARSE_STATUS_MAPPING_ERROR".as_bytes()),
+                    6 => writer.write_all("CUSPARSE_STATUS_EXECUTION_FAILED".as_bytes()),
+                    7 => writer.write_all("CUSPARSE_STATUS_INTERNAL_ERROR".as_bytes()),
+                    8 => {
+                        writer
+                            .write_all(
+                                "CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED".as_bytes(),
+                            )
+                    }
+                    9 => writer.write_all("CUSPARSE_STATUS_ZERO_PIVOT".as_bytes()),
+                    10 => writer.write_all("CUSPARSE_STATUS_NOT_SUPPORTED".as_bytes()),
+                    11 => {
+                        writer
+                            .write_all(
+                                "CUSPARSE_STATUS_INSUFFICIENT_RESOURCES".as_bytes(),
+                            )
+                    }
+                    err => write!(writer, "{}", err),
+                }
+            }
+        }
+    }
+}

zluda_bindgen/src/main.rs

@@ -152,6 +152,7 @@ fn generate_cufft(crate_root: &PathBuf) {
         .allowlist_function("^cufft.*")
         .allowlist_var("^CUFFT_.*")
         .must_use_type("cufftResult_t")
+        .constified_enum("cufftResult_t")
         .allowlist_recursively(false)
         .clang_args(["-I/usr/local/cuda/include"])
         .generate()
@@ -164,13 +165,23 @@ fn generate_cufft(crate_root: &PathBuf) {
         &["..", "cuda_macros", "src", "cufft.rs"],
         &module,
     );
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "cufftResult",
+        underlying_type: "cufftResult_t",
+        new_error_type: "cufftError_t",
+        error_prefix: ("CUFFT_", "ERROR_"),
+        success: ("CUFFT_SUCCESS", "SUCCESS"),
+        hip_type: None,
+    };
     generate_types_library(
+        Some(&result_options),
         Some(LibraryOverride::CuFft),
         &crate_root,
         &["..", "cuda_types", "src", "cufft.rs"],
         &module,
     );
     generate_display_perflib(
+        Some(&result_options),
         &crate_root,
         &["..", "format", "src", "format_generated_fft.rs"],
         &["cuda_types", "cufft"],
@@ -207,6 +218,7 @@ fn generate_cusparse(crate_root: &PathBuf) {
         .allowlist_function("^cusparse.*")
         .allowlist_var("^CUSPARSE_.*")
         .must_use_type("cusparseStatus_t")
+        .constified_enum("cusparseStatus_t")
         .allowlist_recursively(false)
         .clang_args(["-I/usr/local/cuda/include"])
         .generate()
@@ -219,13 +231,23 @@ fn generate_cusparse(crate_root: &PathBuf) {
         &["..", "cuda_macros", "src", "cusparse.rs"],
         &module,
     );
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "cusparseStatus_t",
+        underlying_type: "cusparseStatus_t",
+        new_error_type: "cusparseError_t",
+        error_prefix: ("CUSPARSE_STATUS_", "ERROR_"),
+        success: ("CUSPARSE_STATUS_SUCCESS", "SUCCESS"),
+        hip_type: None,
+    };
     generate_types_library(
+        Some(&result_options),
         None,
         &crate_root,
         &["..", "cuda_types", "src", "cusparse.rs"],
         &module,
     );
     generate_display_perflib(
+        Some(&result_options),
         &crate_root,
         &["..", "format", "src", "format_generated_sparse.rs"],
         &["cuda_types", "cusparse"],
@@ -240,13 +262,22 @@ fn generate_cudnn(crate_root: &PathBuf) {
         .allowlist_function("^cudnn.*")
         .allowlist_var("^CUDNN_.*")
         .must_use_type("cudnnStatus_t")
+        .constified_enum("cudnnStatus_t")
         .allowlist_recursively(false)
         .clang_args(["-I/usr/local/cuda/include"])
         .generate()
         .unwrap()
         .to_string();
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "cudnnStatus_t",
+        underlying_type: "cudnnStatus_t",
+        new_error_type: "cudnnError_",
+        error_prefix: ("CUDNN_STATUS_", "ERROR_"),
+        success: ("CUDNN_STATUS_SUCCESS", "SUCCESS"),
+        hip_type: None,
+    };
     let cudnn9_module: syn::File = syn::parse_str(&cudnn9).unwrap();
-    let cudnn9_types = generate_types_library_impl(&cudnn9_module);
+    let cudnn9_types = generate_types_library_impl(Some(&result_options), &cudnn9_module);
     let mut current_dir = PathBuf::from(file!());
     current_dir.pop();
     let cudnn8 = new_builder()
@@ -264,7 +295,7 @@ fn generate_cudnn(crate_root: &PathBuf) {
         .unwrap()
         .to_string();
     let cudnn8_module: syn::File = syn::parse_str(&cudnn8).unwrap();
-    let cudnn8_types = generate_types_library_impl(&cudnn8_module);
+    let cudnn8_types = generate_types_library_impl(Some(&result_options), &cudnn8_module);
     merge_types(
         &crate_root,
         &["..", "cuda_types", "src", "cudnn.rs"],
@@ -286,6 +317,7 @@ fn generate_cudnn(crate_root: &PathBuf) {
         &cudnn9_module,
     );
     generate_display_perflib(
+        Some(&result_options),
         &crate_root,
         &["..", "format", "src", "format_generated_dnn9.rs"],
         &["cuda_types", "cudnn9"],
@@ -625,6 +657,7 @@ fn generate_cublas(crate_root: &PathBuf) {
         .allowlist_function("^cublas.*")
         .allowlist_var("^CUBLAS_.*")
         .must_use_type("cublasStatus_t")
+        .constified_enum("cublasStatus_t")
         .allowlist_recursively(false)
         .clang_args(["-I/usr/local/cuda/include", "-x", "c++"])
         .generate()
@@ -637,13 +670,23 @@ fn generate_cublas(crate_root: &PathBuf) {
         &["..", "cuda_macros", "src", "cublas.rs"],
         &module,
     );
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "cublasStatus_t",
+        underlying_type: "cublasStatus_t",
+        new_error_type: "cublasError_t",
+        error_prefix: ("CUBLAS_STATUS_", "ERROR_"),
+        success: ("CUBLAS_STATUS_SUCCESS", "SUCCESS"),
+        hip_type: Some(syn::parse_str("rocblas_sys::rocblas_error").unwrap()),
+    };
     generate_types_library(
+        Some(&result_options),
         None,
         &crate_root,
         &["..", "cuda_types", "src", "cublas.rs"],
         &module,
     );
     generate_display_perflib(
+        Some(&result_options),
         &crate_root,
         &["..", "format", "src", "format_generated_blas.rs"],
         &["cuda_types", "cublas"],
@@ -710,18 +753,21 @@ fn generate_cublaslt(crate_root: &PathBuf) {
         &module_blas,
     );
     generate_types_library(
+        None,
         Some(LibraryOverride::CuBlasLt),
         &crate_root,
         &["..", "cuda_types", "src", "cublaslt.rs"],
         &module_blas,
     );
     generate_display_perflib(
+        None,
         &crate_root,
         &["..", "format", "src", "format_generated_blaslt.rs"],
         &["cuda_types", "cublaslt"],
         &module_blas,
     );
     generate_display_perflib(
+        None,
         &crate_root,
         &["..", "format", "src", "format_generated_blaslt_internal.rs"],
         &["cuda_types", "cublaslt"],
@@ -758,12 +804,22 @@ fn generate_cuda(crate_root: &PathBuf) -> Vec<Ident> {
         &["..", "cuda_macros", "src", "cuda.rs"],
         &module,
     ));
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "CUresult",
+        underlying_type: "cudaError_enum",
+        new_error_type: "CUerror",
+        error_prefix: ("CUDA_ERROR_", "ERROR_"),
+        success: ("CUDA_SUCCESS", "SUCCESS"),
+        hip_type: Some(syn::parse_str("hip_runtime_sys::hipErrorCode_t").unwrap()),
+    };
     generate_types_cuda(
+        &result_options,
         &crate_root,
         &["..", "cuda_types", "src", "cuda.rs"],
         &module,
     );
     generate_display_cuda(
+        &result_options,
         &crate_root,
         &["..", "format", "src", "format_generated.rs"],
         &["cuda_types", "cuda"],
@@ -784,33 +840,23 @@ fn generate_ml(crate_root: &PathBuf) {
         .generate()
         .unwrap()
         .to_string();
-    let mut module: syn::File = syn::parse_str(&ml_header).unwrap();
+    let module: syn::File = syn::parse_str(&ml_header).unwrap();
-    let mut converter = ConvertIntoRustResult {
-        type_: "nvmlReturn_t",
-        underlying_type: "nvmlReturn_enum",
-        new_error_type: "nvmlError_t",
-        error_prefix: ("NVML_ERROR_", "ERROR_"),
-        success: ("NVML_SUCCESS", "SUCCESS"),
-        constants: Vec::new(),
-    };
-    module.items = module
-        .items
-        .into_iter()
-        .filter_map(|item| match item {
-            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
-            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
-            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
-            item => Some(item),
-        })
-        .collect::<Vec<_>>();
-    converter.flush(&mut module.items);
     generate_functions(
         &crate_root,
         "nvml",
         &["..", "cuda_macros", "src", "nvml.rs"],
         &module,
     );
+    let result_options = ConvertIntoRustResultOptions {
+        type_: "nvmlReturn_t",
+        underlying_type: "nvmlReturn_enum",
+        new_error_type: "nvmlError_t",
+        error_prefix: ("NVML_ERROR_", "ERROR_"),
+        success: ("NVML_SUCCESS", "SUCCESS"),
+        hip_type: None,
+    };
     generate_types_library(
+        Some(&result_options),
         None,
         &crate_root,
         &["..", "cuda_types", "src", "nvml.rs"],
@@ -819,12 +865,13 @@ fn generate_ml(crate_root: &PathBuf) {
 }
 
 fn generate_types_library(
+    result_options: Option<&ConvertIntoRustResultOptions>,
     override_: Option<LibraryOverride>,
     crate_root: &PathBuf,
     path: &[&str],
     module: &syn::File,
 ) {
-    let module = generate_types_library_impl(module);
+    let module = generate_types_library_impl(result_options, module);
     let mut output = crate_root.clone();
     output.extend(path);
     let mut text =
@@ -849,7 +896,10 @@ enum LibraryOverride {
     CuFft,
 }
 
-fn generate_types_library_impl(module: &syn::File) -> syn::File {
+fn generate_types_library_impl(
+    result_options: Option<&ConvertIntoRustResultOptions>,
+    module: &syn::File,
+) -> syn::File {
     let known_reexports: Punctuated<syn::Item, syn::parse::Nothing> = parse_quote! {
         pub type __half = u16;
         pub type __nv_bfloat16 = u16;
@@ -863,11 +913,28 @@ fn generate_types_library_impl(module: &syn::File) -> syn::File {
         pub type cudaAsyncNotificationType = super::cuda::CUasyncNotificationType_enum;
         pub type cudaGraph_t = super::cuda::CUgraph;
     };
-    let non_fn = module.items.iter().filter_map(|item| match item {
+    let remove_functions = |item| match item {
         Item::ForeignMod(_) => None,
         _ => Some(item),
-    });
+    };
-    let items = known_reexports.iter().chain(non_fn);
+    let non_fn = if let Some(options) = result_options {
+        let mut converter = ConvertIntoRustResult::new(options.clone());
+        let mut non_fn = converter
+            .convert(module.items.clone())
+            .filter_map(remove_functions)
+            .collect::<Vec<_>>();
+        converter.flush(&mut non_fn);
+        non_fn
+    } else {
+        let non_fn = module
+            .items
+            .clone()
+            .into_iter()
+            .filter_map(remove_functions)
+            .collect::<Vec<_>>();
+        non_fn
+    };
+    let items = known_reexports.into_iter().chain(non_fn);
     parse_quote! {
         #(#items)*
     }
@@ -890,24 +957,15 @@ fn generate_hip_runtime(output: &PathBuf, path: &[&str]) {
         .unwrap()
         .to_string();
     let mut module: syn::File = syn::parse_str(&hiprt_header).unwrap();
-    let mut converter = ConvertIntoRustResult {
+    let mut converter = ConvertIntoRustResult::new(ConvertIntoRustResultOptions {
         type_: "hipError_t",
         underlying_type: "hipError_t",
         new_error_type: "hipErrorCode_t",
         error_prefix: ("hipError", "Error"),
         success: ("hipSuccess", "Success"),
-        constants: Vec::new(),
+        hip_type: None,
-    };
+    });
-    module.items = module
+    module.items = converter.convert(module.items).collect::<Vec<Item>>();
-        .items
-        .into_iter()
-        .filter_map(|item| match item {
-            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
-            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
-            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
-            item => Some(item),
-        })
-        .collect::<Vec<_>>();
     converter.flush(&mut module.items);
     add_send_sync(
         &mut module.items,
@@ -941,30 +999,27 @@ fn generate_rocblas(output: &PathBuf, path: &[&str]) {
     remove_type(&mut module, "ihipStream_t");
     remove_type(&mut module, "hipEvent_t");
     remove_type(&mut module, "ihipEvent_t");
-    let mut converter = ConvertIntoRustResult {
+    let result_options = ConvertIntoRustResultOptions {
         type_: "rocblas_status",
         underlying_type: "rocblas_status_",
         new_error_type: "rocblas_error",
         error_prefix: ("rocblas_status_", "error_"),
         success: ("rocblas_status_success", "success"),
-        constants: Vec::new(),
+        hip_type: None,
     };
-    module.items = module
+    let mut converter = ConvertIntoRustResult::new(result_options);
-        .items
+    module.items = converter
-        .into_iter()
+        .convert(module.items)
-        .filter_map(|item| match item {
+        .map(|item| match item {
-            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
-            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
-            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
             Item::ForeignMod(mut extern_) => {
                 extern_.attrs.push(
                     parse_quote!(#[cfg_attr(windows, link(name = "rocblas", kind = "raw-dylib"))]),
                 );
-                Some(Item::ForeignMod(extern_))
+                Item::ForeignMod(extern_)
             }
-            item => Some(item),
+            item => item,
         })
-        .collect::<Vec<_>>();
+        .collect();
     converter.flush(&mut module.items);
     add_send_sync(&mut module.items, &["rocblas_handle"]);
     let mut output = output.clone();
@@ -1051,24 +1106,18 @@ fn generate_functions(
      */
 }
 
-fn generate_types_cuda(output: &PathBuf, path: &[&str], module: &syn::File) {
+fn generate_types_cuda(
+    options: &ConvertIntoRustResultOptions,
+    output: &PathBuf,
+    path: &[&str],
+    module: &syn::File,
+) {
     let mut module = module.clone();
-    let mut converter = ConvertIntoRustResult {
+    let mut converter = ConvertIntoRustResult::new(options.clone());
-        type_: "CUresult",
+    module.items = converter
-        underlying_type: "cudaError_enum",
+        .convert(module.items)
-        new_error_type: "CUerror",
-        error_prefix: ("CUDA_ERROR_", "ERROR_"),
-        success: ("CUDA_SUCCESS", "SUCCESS"),
-        constants: Vec::new(),
-    };
-    module.items = module
-        .items
-        .into_iter()
         .filter_map(|item| match item {
             Item::ForeignMod(_) => None,
-            Item::Const(const_) => converter.get_const(const_).map(Item::Const),
-            Item::Use(use_) => converter.get_use(use_).map(Item::Use),
-            Item::Type(type_) => converter.get_type(type_).map(Item::Type),
             Item::Struct(mut struct_) => {
                 let ident_string = struct_.ident.to_string();
                 match &*ident_string {
@@ -1090,13 +1139,6 @@ fn generate_types_cuda(output: &PathBuf, path: &[&str], module: &syn::File) {
         })
         .collect::<Vec<_>>();
     converter.flush(&mut module.items);
-    module.items.push(parse_quote! {
-        impl From<hip_runtime_sys::hipErrorCode_t> for CUerror {
-            fn from(error: hip_runtime_sys::hipErrorCode_t) -> Self {
-                Self(error.0)
-            }
-        }
-    });
     add_send_sync(
         &mut module.items,
         &[
@@ -1121,19 +1163,33 @@ fn write_rust_to_file(path: impl AsRef<std::path::Path>, content: &str) {
     file.write(content.as_bytes()).unwrap();
 }
 
-struct ConvertIntoRustResult {
+#[derive(Clone)]
+struct ConvertIntoRustResultOptions {
     type_: &'static str,
     underlying_type: &'static str,
     new_error_type: &'static str,
     error_prefix: (&'static str, &'static str),
     success: (&'static str, &'static str),
+    // TODO: this should no longer be an Option once all hip perf libraries are present
+    hip_type: Option<Path>,
+}
+
+struct ConvertIntoRustResult {
+    options: ConvertIntoRustResultOptions,
     constants: Vec<syn::ItemConst>,
 }
 
 impl ConvertIntoRustResult {
+    fn new(options: ConvertIntoRustResultOptions) -> Self {
+        Self {
+            options,
+            constants: vec![],
+        }
+    }
+
     fn get_const(&mut self, const_: syn::ItemConst) -> Option<syn::ItemConst> {
         let name = const_.ident.to_string();
-        if name.starts_with(self.underlying_type) {
+        if name.starts_with(self.options.underlying_type) {
             self.constants.push(const_);
             None
         } else {
@@ -1144,7 +1200,7 @@ impl ConvertIntoRustResult {
     fn get_use(&mut self, use_: ItemUse) -> Option<ItemUse> {
         if let UseTree::Path(ref path) = use_.tree {
             if let UseTree::Rename(ref rename) = &*path.tree {
-                if rename.rename == self.type_ {
+                if rename.rename == self.options.type_ {
                     return None;
                 }
             }
@@ -1153,22 +1209,26 @@ impl ConvertIntoRustResult {
     }
 
     fn flush(self, items: &mut Vec<Item>) {
-        let type_ = format_ident!("{}", self.type_);
+        let type_ = format_ident!("{}", self.options.type_);
-        let type_trait = format_ident!("{}Consts", self.type_);
+        let type_trait = format_ident!("{}Consts", self.options.type_);
-        let new_error_type = format_ident!("{}", self.new_error_type);
+        let new_error_type = format_ident!("{}", self.options.new_error_type);
-        let success = format_ident!("{}", self.success.1);
+        let success = format_ident!("{}", self.options.success.1);
         let mut result_variants = Vec::new();
         let mut error_variants = Vec::new();
         for const_ in self.constants.iter() {
             let ident = const_.ident.to_string();
-            if ident.ends_with(self.success.0) {
+            if ident.ends_with(self.options.success.0) {
                 result_variants.push(quote! {
                     const #success: #type_ = #type_::Ok(());
                 });
             } else {
-                let old_prefix_len = self.underlying_type.len() + 1 + self.error_prefix.0.len();
+                let old_prefix_len =
-                let variant_ident =
+                    self.options.underlying_type.len() + 1 + self.options.error_prefix.0.len();
-                    format_ident!("{}{}", self.error_prefix.1, &ident[old_prefix_len..]);
+                let variant_ident = format_ident!(
+                    "{}{}",
+                    self.options.error_prefix.1,
+                    &ident[old_prefix_len..]
+                );
                 let error_ident = format_ident!("r#{}", &ident[old_prefix_len..]);
                 let expr = &const_.expr;
                 result_variants.push(quote! {
@@ -1198,15 +1258,35 @@ impl ConvertIntoRustResult {
             };
         };
         items.extend(extra_items);
+        if let Some(hip_error_path) = self.options.hip_type {
+            items.push(
+                parse_quote! {impl From<#hip_error_path> for #new_error_type {
+                    fn from(error: #hip_error_path) -> Self {
+                        Self(error.0)
+                    }
+                }},
+            );
+        }
     }
 
     fn get_type(&self, type_: syn::ItemType) -> Option<syn::ItemType> {
-        if type_.ident.to_string() == self.type_ {
+        if type_.ident.to_string() == self.options.type_
+            || type_.ident.to_string() == self.options.underlying_type
+        {
             None
         } else {
             Some(type_)
         }
     }
+
+    fn convert(&mut self, items: Vec<Item>) -> impl Iterator<Item = Item> + use<'_> {
+        items.into_iter().filter_map(|item| match item {
+            Item::Const(const_) => self.get_const(const_).map(Item::Const),
+            Item::Use(use_) => self.get_use(use_).map(Item::Use),
+            Item::Type(type_) => self.get_type(type_).map(Item::Type),
+            item => Some(item),
+        })
+    }
 }
 
 struct FixAbi;
@@ -1263,6 +1343,7 @@ impl VisitMut for ExplicitReturnType {
 }
 
 fn generate_display_cuda(
+    result_options: &ConvertIntoRustResultOptions,
     output: &PathBuf,
     path: &[&str],
     types_crate: &[&'static str],
@@ -1319,9 +1400,16 @@ fn generate_display_cuda(
     let mut items = module
         .items
         .iter()
-        .filter_map(|i| cuda_derive_display_trait_for_item(types_crate, &mut derive_state, i))
+        .filter_map(|i| {
+            cuda_derive_display_trait_for_item(
+                Some(result_options),
+                types_crate,
+                &mut derive_state,
+                i,
+            )
+        })
         .collect::<Vec<_>>();
-    items.push(curesult_display_trait(&derive_state));
+    items.push(result_display_trait(result_options, &derive_state));
     let mut output = output.clone();
     output.extend(path);
     write_rust_to_file(
@@ -1335,6 +1423,7 @@ fn generate_display_cuda(
 }
 
 fn generate_display_perflib(
+    result_options: Option<&ConvertIntoRustResultOptions>,
     output: &PathBuf,
     path: &[&str],
     types_crate: &[&'static str],
@@ -1361,11 +1450,16 @@ fn generate_display_perflib(
         &ignore_functions,
         &count_selectors,
     );
-    let items = module
+    let mut items = module
         .items
         .iter()
-        .filter_map(|i| cuda_derive_display_trait_for_item(types_crate, &mut derive_state, i))
+        .filter_map(|i| {
+            cuda_derive_display_trait_for_item(result_options, types_crate, &mut derive_state, i)
+        })
         .collect::<Vec<_>>();
+    if let Some(result_options) = result_options {
+        items.push(result_display_trait(result_options, &derive_state));
+    }
     let mut output = output.clone();
     output.extend(path);
     write_rust_to_file(
@@ -1436,6 +1530,7 @@ impl<'a> DeriveDisplayState<'a> {
 }
 
 fn cuda_derive_display_trait_for_item<'a>(
+    result_options: Option<&ConvertIntoRustResultOptions>,
     path: &[&str],
     state: &mut DeriveDisplayState<'a>,
     item: &'a Item,
@@ -1450,8 +1545,10 @@ fn cuda_derive_display_trait_for_item<'a>(
     };
     match item {
         Item::Const(const_) => {
-            if const_.ty.to_token_stream().to_string() == "cudaError_enum" {
+            if let Some(result_options) = result_options {
-                state.result_variants.push(const_);
+                if const_.ty.to_token_stream().to_string() == result_options.underlying_type {
+                    state.result_variants.push(const_);
+                }
             }
             None
         }
@@ -1654,11 +1751,21 @@ fn fn_arg_name(fn_arg: &FnArg) -> &Box<syn::Pat> {
     name
 }
 
-fn curesult_display_trait(derive_state: &DeriveDisplayState) -> syn::Item {
+fn result_display_trait(
+    result_options: &ConvertIntoRustResultOptions,
+    derive_state: &DeriveDisplayState,
+) -> syn::Item {
+    let path = &derive_state.types_crate;
+
+    let type_ = Ident::new(result_options.type_, Span::call_site());
+
+    let success = result_options.success.0;
+    let success_bstr = syn::LitByteStr::new(success.as_bytes(), Span::call_site());
+
     let errors = derive_state.result_variants.iter().filter_map(|const_| {
-        let prefix = "cudaError_enum_";
+        let prefix = format!("{}_", result_options.underlying_type);
         let text = &const_.ident.to_string()[prefix.len()..];
-        if text == "CUDA_SUCCESS" {
+        if text == success {
             return None;
         }
         let expr = &const_.expr;
@@ -1667,10 +1774,10 @@ fn curesult_display_trait(derive_state: &DeriveDisplayState) -> syn::Item {
         })
     });
     parse_quote! {
-        impl crate::CudaDisplay for cuda_types::cuda::CUresult {
+        impl crate::CudaDisplay for #path::#type_ {
             fn write(&self, _fn_name: &'static str, _index: usize, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
                 match self {
-                    Ok(()) => writer.write_all(b"CUDA_SUCCESS"),
+                    Ok(()) => writer.write_all(#success_bstr),
                     Err(err) => {
                         match err.0.get() {
                             #(#errors)*

zluda_blas/src/impl.rs

@@ -1,4 +1,4 @@
-use cuda_types::cublas::cublasStatus_t;
+use cuda_types::cublas::*;
 
 #[cfg(debug_assertions)]
 pub(crate) fn unimplemented() -> cublasStatus_t {
@@ -7,7 +7,7 @@ pub(crate) fn unimplemented() -> cublasStatus_t {
 
 #[cfg(not(debug_assertions))]
 pub(crate) fn unimplemented() -> cublasStatus_t {
-    cublasStatus_t::CUBLAS_STATUS_NOT_SUPPORTED
+    cublasStatus_t::ERROR_NOT_SUPPORTED
 }
 
 #[allow(non_snake_case)]

zluda_blaslt/src/impl.rs

@@ -1,4 +1,4 @@
-use cuda_types::cublas::cublasStatus_t;
+use cuda_types::cublas::*;
 
 #[cfg(debug_assertions)]
 pub(crate) fn unimplemented() -> cublasStatus_t {
@@ -7,7 +7,7 @@ pub(crate) fn unimplemented() -> cublasStatus_t {
 
 #[cfg(not(debug_assertions))]
 pub(crate) fn unimplemented() -> cublasStatus_t {
-    cublasStatus_t::CUBLAS_STATUS_NOT_SUPPORTED
+    cublasStatus_t::ERROR_NOT_SUPPORTED
 }
 
 #[allow(non_snake_case)]

zluda_dump_common/src/lib.rs

@@ -1,4 +1,9 @@
-use cuda_types::cuda::{CUerror, CUresult, CUresultConsts, CUuuid};
+use cuda_types::{
+    cublas::cublasStatus_tConsts,
+    cuda::{CUerror, CUresult, CUresultConsts, CUuuid},
+    cufft::cufftResultConsts,
+    cusparse::cusparseStatus_tConsts,
+};
 use dark_api::ByteVecFfi;
 use std::{ffi::c_void, num::NonZero, ptr, sync::LazyLock};
 
@@ -124,15 +129,21 @@ impl<T> ReprUsize for *const T {
 
 impl ReprUsize for cuda_types::cublas::cublasStatus_t {
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cublas::cublasStatus_t::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cublas::cublasError_t(err)),
+        }
     }
 
     const INTERNAL_ERROR: usize =
-        cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR.0 as usize;
+        cuda_types::cublas::cublasError_t::INTERNAL_ERROR.0.get() as usize;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();
@@ -150,8 +161,9 @@ impl ReprUsize for cuda_types::cudnn9::cudnnStatus_t {
         Self(x as u32)
     }
 
-    const INTERNAL_ERROR: usize =
+    // TODO: handle this after cudnn fix
-        cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR.0 as usize;
+
+    const INTERNAL_ERROR: usize = 14;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();
@@ -240,13 +252,21 @@ impl ReprUsize for *mut std::ffi::c_void {
     }
 }
 
-impl ReprUsize for cuda_types::cufft::cufftResult_t {
+impl ReprUsize for cuda_types::cufft::cufftResult {
+    const INTERNAL_ERROR: usize = cuda_types::cufft::cufftError_t::INTERNAL_ERROR.0.get() as usize;
+
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cufft::cufftResult::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cufft::cufftError_t(err)),
+        }
     }
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
@@ -258,15 +278,22 @@ impl ReprUsize for cuda_types::cufft::cufftResult_t {
 
 impl ReprUsize for cuda_types::cusparse::cusparseStatus_t {
     fn to_usize(self) -> usize {
-        self.0 as usize
+        match self {
+            cuda_types::cusparse::cusparseStatus_t::SUCCESS => 0,
+            Err(err) => err.0.get() as usize,
+        }
     }
 
     fn from_usize(x: usize) -> Self {
-        Self(x as u32)
+        match NonZero::new(x as u32) {
+            None => Ok(()),
+            Some(err) => Err(cuda_types::cusparse::cusparseError_t(err)),
+        }
     }
 
-    const INTERNAL_ERROR: usize =
+    const INTERNAL_ERROR: usize = cuda_types::cusparse::cusparseError_t::INTERNAL_ERROR
-        cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INTERNAL_ERROR.0 as usize;
+        .0
+        .get() as usize;
 
     extern "C" fn format_status(x: usize) -> ByteVecFfi {
         let mut writer = Vec::new();

zluda_fft/src/impl.rs

@@ -1,11 +1,11 @@
-use cuda_types::cufft::cufftResult_t;
+use cuda_types::cufft::*;
 
 #[cfg(debug_assertions)]
-pub(crate) fn unimplemented() -> cufftResult_t {
+pub(crate) fn unimplemented() -> cufftResult {
     unimplemented!()
 }
 
 #[cfg(not(debug_assertions))]
-pub(crate) fn unimplemented() -> cufftResult_t {
+pub(crate) fn unimplemented() -> cufftResult {
-    cufftResult_t::CUFFT_NOT_SUPPORTED
+    cufftResult::ERROR_NOT_SUPPORTED
 }

zluda_sparse/src/impl.rs

@@ -1,4 +1,4 @@
-use cuda_types::cusparse::cusparseStatus_t;
+use cuda_types::cusparse::*;
 
 #[cfg(debug_assertions)]
 pub(crate) fn unimplemented() -> cusparseStatus_t {
@@ -7,7 +7,7 @@ pub(crate) fn unimplemented() -> cusparseStatus_t {
 
 #[cfg(not(debug_assertions))]
 pub(crate) fn unimplemented() -> cusparseStatus_t {
-    cusparseStatus_t::CUSPARSE_STATUS_NOT_SUPPORTED
+    cusparseStatus_t::ERROR_NOT_SUPPORTED
 }
 
 #[allow(non_snake_case)]