From 481c3550faa5b29872c3b50369bebb3f603c019d Mon Sep 17 00:00:00 2001 From: Violet Date: Tue, 29 Jul 2025 14:28:14 -0700 Subject: [PATCH] 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 | 2 +- Cargo.lock | 1 + cuda_types/Cargo.toml | 1 + cuda_types/src/cublas.rs | 107 ++++++--- cuda_types/src/cuda.rs | 3 - cuda_types/src/cufft.rs | 162 +++++++++----- cuda_types/src/cusparse.rs | 124 +++++++---- cuda_types/src/nvml.rs | 2 - ext/rocblas-sys/src/lib.rs | 2 - format/src/format_generated_blas.rs | 68 +++--- format/src/format_generated_fft.rs | 96 +++----- format/src/format_generated_sparse.rs | 92 ++++---- zluda_bindgen/src/main.rs | 301 +++++++++++++++++--------- zluda_blas/src/impl.rs | 4 +- zluda_blaslt/src/impl.rs | 4 +- zluda_dump_common/src/lib.rs | 53 +++-- zluda_fft/src/impl.rs | 8 +- zluda_sparse/src/impl.rs | 4 +- 18 files changed, 613 insertions(+), 421 deletions(-) diff --git a/.github/workflows/rocm_setup_build.sh b/.github/workflows/rocm_setup_build.sh index 3c0e6a7..f66c34e 100644 --- a/.github/workflows/rocm_setup_build.sh +++ b/.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 diff --git a/Cargo.lock b/Cargo.lock index b4d2322..e65e2ea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -317,6 +317,7 @@ dependencies = [ "bitflags 2.9.1", "cuda_macros", "hip_runtime-sys", + "rocblas-sys", ] [[package]] diff --git a/cuda_types/Cargo.toml b/cuda_types/Cargo.toml index ba61449..23f37a7 100644 --- a/cuda_types/Cargo.toml +++ b/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" } diff --git a/cuda_types/src/cublas.rs b/cuda_types/src/cublas.rs index 31adb7a..dc422a3 100644 --- a/cuda_types/src/cublas.rs +++ b/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::; +}; +impl From for cublasError_t { + fn from(error: rocblas_sys::rocblas_error) -> Self { + Self(error.0) + } +} diff --git a/cuda_types/src/cuda.rs b/cuda_types/src/cuda.rs index cfdef15..996fecf 100644 --- a/cuda_types/src/cuda.rs +++ b/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( diff --git a/cuda_types/src/cufft.rs b/cuda_types/src/cufft.rs index a6d1833..3be098b 100644 --- a/cuda_types/src/cufft.rs +++ b/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::; +}; diff --git a/cuda_types/src/cusparse.rs b/cuda_types/src/cusparse.rs index b814166..ee29399 100644 --- a/cuda_types/src/cusparse.rs +++ b/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::; +}; diff --git a/cuda_types/src/nvml.rs b/cuda_types/src/nvml.rs index 4c38f4e..a30d336 100644 --- a/cuda_types/src/nvml.rs +++ b/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( diff --git a/ext/rocblas-sys/src/lib.rs b/ext/rocblas-sys/src/lib.rs index 2f0bd4e..b567202 100644 --- a/ext/rocblas-sys/src/lib.rs +++ b/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_( diff --git a/format/src/format_generated_blas.rs b/format/src/format_generated_blas.rs index 1e74e36..3c01f23 100644 --- a/format/src/format_generated_blas.rs +++ b/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), + } + } + } + } +} diff --git a/format/src/format_generated_fft.rs b/format/src/format_generated_fft.rs index 5873de3..c9c3124 100644 --- a/format/src/format_generated_fft.rs +++ b/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), + } + } + } + } +} diff --git a/format/src/format_generated_sparse.rs b/format/src/format_generated_sparse.rs index 49db811..93213c6 100644 --- a/format/src/format_generated_sparse.rs +++ b/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), + } + } + } + } +} diff --git a/zluda_bindgen/src/main.rs b/zluda_bindgen/src/main.rs index a2d9e43..4439683 100644 --- a/zluda_bindgen/src/main.rs +++ b/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 { &["..", "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 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::>(); - converter.flush(&mut module.items); + let module: syn::File = syn::parse_str(&ml_header).unwrap(); 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, 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 = 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::>(); + converter.flush(&mut non_fn); + non_fn + } else { + let non_fn = module + .items + .clone() + .into_iter() + .filter_map(remove_functions) + .collect::>(); + 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(), - }; - 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::>(); + hip_type: None, + }); + module.items = converter.convert(module.items).collect::>(); 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 - .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), + let mut converter = ConvertIntoRustResult::new(result_options); + module.items = converter + .convert(module.items) + .map(|item| match item { 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::>(); + .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 { - type_: "CUresult", - underlying_type: "cudaError_enum", - new_error_type: "CUerror", - error_prefix: ("CUDA_ERROR_", "ERROR_"), - success: ("CUDA_SUCCESS", "SUCCESS"), - constants: Vec::new(), - }; - module.items = module - .items - .into_iter() + let mut converter = ConvertIntoRustResult::new(options.clone()); + module.items = converter + .convert(module.items) .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::>(); converter.flush(&mut module.items); - module.items.push(parse_quote! { - impl From 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, 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, +} + +struct ConvertIntoRustResult { + options: ConvertIntoRustResultOptions, constants: Vec, } impl ConvertIntoRustResult { + fn new(options: ConvertIntoRustResultOptions) -> Self { + Self { + options, + constants: vec![], + } + } + fn get_const(&mut self, const_: syn::ItemConst) -> Option { 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 { 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) { - let type_ = format_ident!("{}", self.type_); - let type_trait = format_ident!("{}Consts", self.type_); - let new_error_type = format_ident!("{}", self.new_error_type); - let success = format_ident!("{}", self.success.1); + let type_ = format_ident!("{}", self.options.type_); + let type_trait = format_ident!("{}Consts", self.options.type_); + let new_error_type = format_ident!("{}", self.options.new_error_type); + 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 variant_ident = - format_ident!("{}{}", self.error_prefix.1, &ident[old_prefix_len..]); + let old_prefix_len = + self.options.underlying_type.len() + 1 + self.options.error_prefix.0.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 { - 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) -> impl Iterator + 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::>(); - 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::>(); + 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" { - state.result_variants.push(const_); + if let Some(result_options) = result_options { + 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 { 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)* diff --git a/zluda_blas/src/impl.rs b/zluda_blas/src/impl.rs index 692b504..627ecc0 100644 --- a/zluda_blas/src/impl.rs +++ b/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)] diff --git a/zluda_blaslt/src/impl.rs b/zluda_blaslt/src/impl.rs index 25a7a48..d2ec310 100644 --- a/zluda_blaslt/src/impl.rs +++ b/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)] diff --git a/zluda_dump_common/src/lib.rs b/zluda_dump_common/src/lib.rs index 3f75dd1..25b6380 100644 --- a/zluda_dump_common/src/lib.rs +++ b/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 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 = - cuda_types::cublas::cublasStatus_t::CUBLAS_STATUS_INTERNAL_ERROR.0 as usize; + // TODO: handle this after cudnn fix + + 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 = - cuda_types::cusparse::cusparseStatus_t::CUSPARSE_STATUS_INTERNAL_ERROR.0 as usize; + const INTERNAL_ERROR: usize = cuda_types::cusparse::cusparseError_t::INTERNAL_ERROR + .0 + .get() as usize; extern "C" fn format_status(x: usize) -> ByteVecFfi { let mut writer = Vec::new(); diff --git a/zluda_fft/src/impl.rs b/zluda_fft/src/impl.rs index ece814e..94cc02b 100644 --- a/zluda_fft/src/impl.rs +++ b/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 { - cufftResult_t::CUFFT_NOT_SUPPORTED +pub(crate) fn unimplemented() -> cufftResult { + cufftResult::ERROR_NOT_SUPPORTED } diff --git a/zluda_sparse/src/impl.rs b/zluda_sparse/src/impl.rs index 726a061..691961c 100644 --- a/zluda_sparse/src/impl.rs +++ b/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)]