From 9ebfe9d9965abca1a530390b8d01de3d79fe2b6f Mon Sep 17 00:00:00 2001 From: Violet Date: Mon, 28 Jul 2025 04:22:41 +0000 Subject: [PATCH] Run zluda_bindgen and fix usages --- cuda_types/src/cublas.rs | 102 ++++++++++++------ cuda_types/src/cufft.rs | 150 ++++++++++++++++---------- cuda_types/src/cusparse.rs | 124 +++++++++++++-------- 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 | 2 +- zluda_dump_common/src/lib.rs | 53 ++++++--- 8 files changed, 381 insertions(+), 306 deletions(-) diff --git a/cuda_types/src/cublas.rs b/cuda_types/src/cublas.rs index 31adb7a..cb90b3e 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,71 @@ 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 NOT_INITIALIZED: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(1) + }); + pub const ALLOC_FAILED: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(3) + }); + pub const INVALID_VALUE: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(7) + }); + pub const ARCH_MISMATCH: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(8) + }); + pub const MAPPING_ERROR: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(11) + }); + pub const EXECUTION_FAILED: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(13) + }); + pub const INTERNAL_ERROR: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(14) + }); + pub const NOT_SUPPORTED: cublasError_t = cublasError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(15) + }); + pub const 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::NOT_INITIALIZED, + ); + const ERROR_ALLOC_FAILED: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::ALLOC_FAILED, + ); + const ERROR_INVALID_VALUE: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::INVALID_VALUE, + ); + const ERROR_ARCH_MISMATCH: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::ARCH_MISMATCH, + ); + const ERROR_MAPPING_ERROR: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::MAPPING_ERROR, + ); + const ERROR_EXECUTION_FAILED: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::EXECUTION_FAILED, + ); + const ERROR_INTERNAL_ERROR: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::INTERNAL_ERROR, + ); + const ERROR_NOT_SUPPORTED: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::NOT_SUPPORTED, + ); + const ERROR_LICENSE_ERROR: cublasStatus_t = cublasStatus_t::Err( + cublasError_t::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::; +}; diff --git a/cuda_types/src/cufft.rs b/cuda_types/src/cufft.rs index a6d1833..cfea1c3 100644 --- a/cuda_types/src/cufft.rs +++ b/cuda_types/src/cufft.rs @@ -50,62 +50,8 @@ 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 cufftResult_t = ::core::ffi::c_uint; pub type cufftReal = f32; pub type cufftDoubleReal = f64; pub type cufftComplex = super::cuda::cuComplex; @@ -425,3 +371,97 @@ pub type cufftJITCallbackStoreD = ::core::option::Option< sharedPointer: *mut ::core::ffi::c_void, ), >; +impl cufftError_t { + pub const INVALID_PLAN: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(1) + }); + pub const ALLOC_FAILED: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(2) + }); + pub const INVALID_TYPE: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(3) + }); + pub const INVALID_VALUE: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(4) + }); + pub const INTERNAL_ERROR: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(5) + }); + pub const EXEC_FAILED: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(6) + }); + pub const SETUP_FAILED: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(7) + }); + pub const INVALID_SIZE: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(8) + }); + pub const UNALIGNED_DATA: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(9) + }); + pub const INCOMPLETE_PARAMETER_LIST: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(10) + }); + pub const INVALID_DEVICE: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(11) + }); + pub const PARSE_ERROR: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(12) + }); + pub const NO_WORKSPACE: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(13) + }); + pub const NOT_IMPLEMENTED: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(14) + }); + pub const LICENSE_ERROR: cufftError_t = cufftError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(15) + }); + pub const 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::INVALID_PLAN); + const ERROR_ALLOC_FAILED: cufftResult = cufftResult::Err(cufftError_t::ALLOC_FAILED); + const ERROR_INVALID_TYPE: cufftResult = cufftResult::Err(cufftError_t::INVALID_TYPE); + const ERROR_INVALID_VALUE: cufftResult = cufftResult::Err( + cufftError_t::INVALID_VALUE, + ); + const ERROR_INTERNAL_ERROR: cufftResult = cufftResult::Err( + cufftError_t::INTERNAL_ERROR, + ); + const ERROR_EXEC_FAILED: cufftResult = cufftResult::Err(cufftError_t::EXEC_FAILED); + const ERROR_SETUP_FAILED: cufftResult = cufftResult::Err(cufftError_t::SETUP_FAILED); + const ERROR_INVALID_SIZE: cufftResult = cufftResult::Err(cufftError_t::INVALID_SIZE); + const ERROR_UNALIGNED_DATA: cufftResult = cufftResult::Err( + cufftError_t::UNALIGNED_DATA, + ); + const ERROR_INCOMPLETE_PARAMETER_LIST: cufftResult = cufftResult::Err( + cufftError_t::INCOMPLETE_PARAMETER_LIST, + ); + const ERROR_INVALID_DEVICE: cufftResult = cufftResult::Err( + cufftError_t::INVALID_DEVICE, + ); + const ERROR_PARSE_ERROR: cufftResult = cufftResult::Err(cufftError_t::PARSE_ERROR); + const ERROR_NO_WORKSPACE: cufftResult = cufftResult::Err(cufftError_t::NO_WORKSPACE); + const ERROR_NOT_IMPLEMENTED: cufftResult = cufftResult::Err( + cufftError_t::NOT_IMPLEMENTED, + ); + const ERROR_LICENSE_ERROR: cufftResult = cufftResult::Err( + cufftError_t::LICENSE_ERROR, + ); + const ERROR_NOT_SUPPORTED: cufftResult = cufftResult::Err( + cufftError_t::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..589178f 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 NOT_INITIALIZED: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(1) + }); + pub const ALLOC_FAILED: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(2) + }); + pub const INVALID_VALUE: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(3) + }); + pub const ARCH_MISMATCH: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(4) + }); + pub const MAPPING_ERROR: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(5) + }); + pub const EXECUTION_FAILED: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(6) + }); + pub const INTERNAL_ERROR: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(7) + }); + pub const MATRIX_TYPE_NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(8) + }); + pub const ZERO_PIVOT: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(9) + }); + pub const NOT_SUPPORTED: cusparseError_t = cusparseError_t(unsafe { + ::core::num::NonZeroU32::new_unchecked(10) + }); + pub const 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::NOT_INITIALIZED, + ); + const ERROR_ALLOC_FAILED: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::ALLOC_FAILED, + ); + const ERROR_INVALID_VALUE: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::INVALID_VALUE, + ); + const ERROR_ARCH_MISMATCH: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::ARCH_MISMATCH, + ); + const ERROR_MAPPING_ERROR: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::MAPPING_ERROR, + ); + const ERROR_EXECUTION_FAILED: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::EXECUTION_FAILED, + ); + const ERROR_INTERNAL_ERROR: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::INTERNAL_ERROR, + ); + const ERROR_MATRIX_TYPE_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::MATRIX_TYPE_NOT_SUPPORTED, + ); + const ERROR_ZERO_PIVOT: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::ZERO_PIVOT, + ); + const ERROR_NOT_SUPPORTED: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::NOT_SUPPORTED, + ); + const ERROR_INSUFFICIENT_RESOURCES: cusparseStatus_t = cusparseStatus_t::Err( + cusparseError_t::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/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 72a952d..30ed0f7 100644 --- a/zluda_bindgen/src/main.rs +++ b/zluda_bindgen/src/main.rs @@ -35,7 +35,7 @@ fn main() { generate_cublaslt(&crate_root); generate_cufft(&crate_root); generate_cusparse(&crate_root); - // generate_cudnn(&crate_root); + generate_cudnn(&crate_root); } fn generate_process_address_table(crate_root: &PathBuf, mut cuda_fns: Vec) { 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();