Applied-Software/ZLUDA
5
0
Fork 0
mirror of https://github.com/vosen/ZLUDA.git synced 2025-08-02 06:47:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add support for rocblas to zluda_bindgen (#440)

Browse Source 
One step of several for adding cublas support
This commit is contained in:
Violet
2025-07-28 15:07:22 -07:00
committed by GitHub
parent 8dbc7208de
commit d81404eb70
10 changed files with 32084 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/pr_master.yml vendored
View File

@ -91,7 +91,7 @@ jobs:
tool: cargo-export
- name: Build
run: |
cargo export target/tests -- test --features ci_build --workspace --exclude cuda_macros --exclude ptx_parser_macros
cargo export target/tests -- test --features ci_build --workspace --exclude cuda_macros --exclude ptx_parser_macros --exclude rocblas-sys
mkdir -p target/amdgpu
bash .github/workflows/move_tests.sh target/tests amdgpu
strip target/amdgpu/*

7
Cargo.lock generated
View File

@ -1204,6 +1204,13 @@ version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
[[package]]
name = "rocblas-sys"
version = "0.1.0"
dependencies = [
"hip_runtime-sys",
]
[[package]]
name = "rustc-hash"
version = "1.1.0"

1
Cargo.toml
View File

@ -10,6 +10,7 @@ members = [
"detours-sys",
"ext/amd_comgr-sys",
"ext/hip_runtime-sys",
"ext/rocblas-sys",
"format",
"ptx",
"ptx_parser",

406
cuda_types/src/cuda.rs
View File

@ -8454,301 +8454,301 @@ pub type cuFloatComplex = float2;
pub type cuDoubleComplex = double2;
pub type cuComplex = cuFloatComplex;
impl CUerror {
pub const INVALID_VALUE: CUerror = CUerror(unsafe {
pub const r#INVALID_VALUE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(1)
});
pub const OUT_OF_MEMORY: CUerror = CUerror(unsafe {
pub const r#OUT_OF_MEMORY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(2)
});
pub const NOT_INITIALIZED: CUerror = CUerror(unsafe {
pub const r#NOT_INITIALIZED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(3)
});
pub const DEINITIALIZED: CUerror = CUerror(unsafe {
pub const r#DEINITIALIZED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(4)
});
pub const PROFILER_DISABLED: CUerror = CUerror(unsafe {
pub const r#PROFILER_DISABLED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(5)
});
pub const PROFILER_NOT_INITIALIZED: CUerror = CUerror(unsafe {
pub const r#PROFILER_NOT_INITIALIZED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(6)
});
pub const PROFILER_ALREADY_STARTED: CUerror = CUerror(unsafe {
pub const r#PROFILER_ALREADY_STARTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(7)
});
pub const PROFILER_ALREADY_STOPPED: CUerror = CUerror(unsafe {
pub const r#PROFILER_ALREADY_STOPPED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(8)
});
pub const STUB_LIBRARY: CUerror = CUerror(unsafe {
pub const r#STUB_LIBRARY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(34)
});
pub const DEVICE_UNAVAILABLE: CUerror = CUerror(unsafe {
pub const r#DEVICE_UNAVAILABLE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(46)
});
pub const NO_DEVICE: CUerror = CUerror(unsafe {
pub const r#NO_DEVICE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(100)
});
pub const INVALID_DEVICE: CUerror = CUerror(unsafe {
pub const r#INVALID_DEVICE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(101)
});
pub const DEVICE_NOT_LICENSED: CUerror = CUerror(unsafe {
pub const r#DEVICE_NOT_LICENSED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(102)
});
pub const INVALID_IMAGE: CUerror = CUerror(unsafe {
pub const r#INVALID_IMAGE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(200)
});
pub const INVALID_CONTEXT: CUerror = CUerror(unsafe {
pub const r#INVALID_CONTEXT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(201)
});
pub const CONTEXT_ALREADY_CURRENT: CUerror = CUerror(unsafe {
pub const r#CONTEXT_ALREADY_CURRENT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(202)
});
pub const MAP_FAILED: CUerror = CUerror(unsafe {
pub const r#MAP_FAILED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(205)
});
pub const UNMAP_FAILED: CUerror = CUerror(unsafe {
pub const r#UNMAP_FAILED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(206)
});
pub const ARRAY_IS_MAPPED: CUerror = CUerror(unsafe {
pub const r#ARRAY_IS_MAPPED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(207)
});
pub const ALREADY_MAPPED: CUerror = CUerror(unsafe {
pub const r#ALREADY_MAPPED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(208)
});
pub const NO_BINARY_FOR_GPU: CUerror = CUerror(unsafe {
pub const r#NO_BINARY_FOR_GPU: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(209)
});
pub const ALREADY_ACQUIRED: CUerror = CUerror(unsafe {
pub const r#ALREADY_ACQUIRED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(210)
});
pub const NOT_MAPPED: CUerror = CUerror(unsafe {
pub const r#NOT_MAPPED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(211)
});
pub const NOT_MAPPED_AS_ARRAY: CUerror = CUerror(unsafe {
pub const r#NOT_MAPPED_AS_ARRAY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(212)
});
pub const NOT_MAPPED_AS_POINTER: CUerror = CUerror(unsafe {
pub const r#NOT_MAPPED_AS_POINTER: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(213)
});
pub const ECC_UNCORRECTABLE: CUerror = CUerror(unsafe {
pub const r#ECC_UNCORRECTABLE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(214)
});
pub const UNSUPPORTED_LIMIT: CUerror = CUerror(unsafe {
pub const r#UNSUPPORTED_LIMIT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(215)
});
pub const CONTEXT_ALREADY_IN_USE: CUerror = CUerror(unsafe {
pub const r#CONTEXT_ALREADY_IN_USE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(216)
});
pub const PEER_ACCESS_UNSUPPORTED: CUerror = CUerror(unsafe {
pub const r#PEER_ACCESS_UNSUPPORTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(217)
});
pub const INVALID_PTX: CUerror = CUerror(unsafe {
pub const r#INVALID_PTX: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(218)
});
pub const INVALID_GRAPHICS_CONTEXT: CUerror = CUerror(unsafe {
pub const r#INVALID_GRAPHICS_CONTEXT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(219)
});
pub const NVLINK_UNCORRECTABLE: CUerror = CUerror(unsafe {
pub const r#NVLINK_UNCORRECTABLE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(220)
});
pub const JIT_COMPILER_NOT_FOUND: CUerror = CUerror(unsafe {
pub const r#JIT_COMPILER_NOT_FOUND: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(221)
});
pub const UNSUPPORTED_PTX_VERSION: CUerror = CUerror(unsafe {
pub const r#UNSUPPORTED_PTX_VERSION: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(222)
});
pub const JIT_COMPILATION_DISABLED: CUerror = CUerror(unsafe {
pub const r#JIT_COMPILATION_DISABLED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(223)
});
pub const UNSUPPORTED_EXEC_AFFINITY: CUerror = CUerror(unsafe {
pub const r#UNSUPPORTED_EXEC_AFFINITY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(224)
});
pub const UNSUPPORTED_DEVSIDE_SYNC: CUerror = CUerror(unsafe {
pub const r#UNSUPPORTED_DEVSIDE_SYNC: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(225)
});
pub const CONTAINED: CUerror = CUerror(unsafe {
pub const r#CONTAINED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(226)
});
pub const INVALID_SOURCE: CUerror = CUerror(unsafe {
pub const r#INVALID_SOURCE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(300)
});
pub const FILE_NOT_FOUND: CUerror = CUerror(unsafe {
pub const r#FILE_NOT_FOUND: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(301)
});
pub const SHARED_OBJECT_SYMBOL_NOT_FOUND: CUerror = CUerror(unsafe {
pub const r#SHARED_OBJECT_SYMBOL_NOT_FOUND: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(302)
});
pub const SHARED_OBJECT_INIT_FAILED: CUerror = CUerror(unsafe {
pub const r#SHARED_OBJECT_INIT_FAILED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(303)
});
pub const OPERATING_SYSTEM: CUerror = CUerror(unsafe {
pub const r#OPERATING_SYSTEM: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(304)
});
pub const INVALID_HANDLE: CUerror = CUerror(unsafe {
pub const r#INVALID_HANDLE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(400)
});
pub const ILLEGAL_STATE: CUerror = CUerror(unsafe {
pub const r#ILLEGAL_STATE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(401)
});
pub const LOSSY_QUERY: CUerror = CUerror(unsafe {
pub const r#LOSSY_QUERY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(402)
});
pub const NOT_FOUND: CUerror = CUerror(unsafe {
pub const r#NOT_FOUND: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(500)
});
pub const NOT_READY: CUerror = CUerror(unsafe {
pub const r#NOT_READY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(600)
});
pub const ILLEGAL_ADDRESS: CUerror = CUerror(unsafe {
pub const r#ILLEGAL_ADDRESS: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(700)
});
pub const LAUNCH_OUT_OF_RESOURCES: CUerror = CUerror(unsafe {
pub const r#LAUNCH_OUT_OF_RESOURCES: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(701)
});
pub const LAUNCH_TIMEOUT: CUerror = CUerror(unsafe {
pub const r#LAUNCH_TIMEOUT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(702)
});
pub const LAUNCH_INCOMPATIBLE_TEXTURING: CUerror = CUerror(unsafe {
pub const r#LAUNCH_INCOMPATIBLE_TEXTURING: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(703)
});
pub const PEER_ACCESS_ALREADY_ENABLED: CUerror = CUerror(unsafe {
pub const r#PEER_ACCESS_ALREADY_ENABLED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(704)
});
pub const PEER_ACCESS_NOT_ENABLED: CUerror = CUerror(unsafe {
pub const r#PEER_ACCESS_NOT_ENABLED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(705)
});
pub const PRIMARY_CONTEXT_ACTIVE: CUerror = CUerror(unsafe {
pub const r#PRIMARY_CONTEXT_ACTIVE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(708)
});
pub const CONTEXT_IS_DESTROYED: CUerror = CUerror(unsafe {
pub const r#CONTEXT_IS_DESTROYED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(709)
});
pub const ASSERT: CUerror = CUerror(unsafe {
pub const r#ASSERT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(710)
});
pub const TOO_MANY_PEERS: CUerror = CUerror(unsafe {
pub const r#TOO_MANY_PEERS: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(711)
});
pub const HOST_MEMORY_ALREADY_REGISTERED: CUerror = CUerror(unsafe {
pub const r#HOST_MEMORY_ALREADY_REGISTERED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(712)
});
pub const HOST_MEMORY_NOT_REGISTERED: CUerror = CUerror(unsafe {
pub const r#HOST_MEMORY_NOT_REGISTERED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(713)
});
pub const HARDWARE_STACK_ERROR: CUerror = CUerror(unsafe {
pub const r#HARDWARE_STACK_ERROR: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(714)
});
pub const ILLEGAL_INSTRUCTION: CUerror = CUerror(unsafe {
pub const r#ILLEGAL_INSTRUCTION: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(715)
});
pub const MISALIGNED_ADDRESS: CUerror = CUerror(unsafe {
pub const r#MISALIGNED_ADDRESS: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(716)
});
pub const INVALID_ADDRESS_SPACE: CUerror = CUerror(unsafe {
pub const r#INVALID_ADDRESS_SPACE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(717)
});
pub const INVALID_PC: CUerror = CUerror(unsafe {
pub const r#INVALID_PC: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(718)
});
pub const LAUNCH_FAILED: CUerror = CUerror(unsafe {
pub const r#LAUNCH_FAILED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(719)
});
pub const COOPERATIVE_LAUNCH_TOO_LARGE: CUerror = CUerror(unsafe {
pub const r#COOPERATIVE_LAUNCH_TOO_LARGE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(720)
});
pub const TENSOR_MEMORY_LEAK: CUerror = CUerror(unsafe {
pub const r#TENSOR_MEMORY_LEAK: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(721)
});
pub const NOT_PERMITTED: CUerror = CUerror(unsafe {
pub const r#NOT_PERMITTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(800)
});
pub const NOT_SUPPORTED: CUerror = CUerror(unsafe {
pub const r#NOT_SUPPORTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(801)
});
pub const SYSTEM_NOT_READY: CUerror = CUerror(unsafe {
pub const r#SYSTEM_NOT_READY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(802)
});
pub const SYSTEM_DRIVER_MISMATCH: CUerror = CUerror(unsafe {
pub const r#SYSTEM_DRIVER_MISMATCH: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(803)
});
pub const COMPAT_NOT_SUPPORTED_ON_DEVICE: CUerror = CUerror(unsafe {
pub const r#COMPAT_NOT_SUPPORTED_ON_DEVICE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(804)
});
pub const MPS_CONNECTION_FAILED: CUerror = CUerror(unsafe {
pub const r#MPS_CONNECTION_FAILED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(805)
});
pub const MPS_RPC_FAILURE: CUerror = CUerror(unsafe {
pub const r#MPS_RPC_FAILURE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(806)
});
pub const MPS_SERVER_NOT_READY: CUerror = CUerror(unsafe {
pub const r#MPS_SERVER_NOT_READY: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(807)
});
pub const MPS_MAX_CLIENTS_REACHED: CUerror = CUerror(unsafe {
pub const r#MPS_MAX_CLIENTS_REACHED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(808)
});
pub const MPS_MAX_CONNECTIONS_REACHED: CUerror = CUerror(unsafe {
pub const r#MPS_MAX_CONNECTIONS_REACHED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(809)
});
pub const MPS_CLIENT_TERMINATED: CUerror = CUerror(unsafe {
pub const r#MPS_CLIENT_TERMINATED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(810)
});
pub const CDP_NOT_SUPPORTED: CUerror = CUerror(unsafe {
pub const r#CDP_NOT_SUPPORTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(811)
});
pub const CDP_VERSION_MISMATCH: CUerror = CUerror(unsafe {
pub const r#CDP_VERSION_MISMATCH: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(812)
});
pub const STREAM_CAPTURE_UNSUPPORTED: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_UNSUPPORTED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(900)
});
pub const STREAM_CAPTURE_INVALIDATED: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_INVALIDATED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(901)
});
pub const STREAM_CAPTURE_MERGE: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_MERGE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(902)
});
pub const STREAM_CAPTURE_UNMATCHED: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_UNMATCHED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(903)
});
pub const STREAM_CAPTURE_UNJOINED: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_UNJOINED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(904)
});
pub const STREAM_CAPTURE_ISOLATION: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_ISOLATION: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(905)
});
pub const STREAM_CAPTURE_IMPLICIT: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_IMPLICIT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(906)
});
pub const CAPTURED_EVENT: CUerror = CUerror(unsafe {
pub const r#CAPTURED_EVENT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(907)
});
pub const STREAM_CAPTURE_WRONG_THREAD: CUerror = CUerror(unsafe {
pub const r#STREAM_CAPTURE_WRONG_THREAD: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(908)
});
pub const TIMEOUT: CUerror = CUerror(unsafe {
pub const r#TIMEOUT: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(909)
});
pub const GRAPH_EXEC_UPDATE_FAILURE: CUerror = CUerror(unsafe {
pub const r#GRAPH_EXEC_UPDATE_FAILURE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(910)
});
pub const EXTERNAL_DEVICE: CUerror = CUerror(unsafe {
pub const r#EXTERNAL_DEVICE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(911)
});
pub const INVALID_CLUSTER_SIZE: CUerror = CUerror(unsafe {
pub const r#INVALID_CLUSTER_SIZE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(912)
});
pub const FUNCTION_NOT_LOADED: CUerror = CUerror(unsafe {
pub const r#FUNCTION_NOT_LOADED: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(913)
});
pub const INVALID_RESOURCE_TYPE: CUerror = CUerror(unsafe {
pub const r#INVALID_RESOURCE_TYPE: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(914)
});
pub const INVALID_RESOURCE_CONFIGURATION: CUerror = CUerror(unsafe {
pub const r#INVALID_RESOURCE_CONFIGURATION: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(915)
});
pub const KEY_ROTATION: CUerror = CUerror(unsafe {
pub const r#KEY_ROTATION: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(916)
});
pub const UNKNOWN: CUerror = CUerror(unsafe {
pub const r#UNKNOWN: CUerror = CUerror(unsafe {
::core::num::NonZeroU32::new_unchecked(999)
});
}
@ -8757,213 +8757,223 @@ impl CUerror {
pub struct CUerror(pub ::core::num::NonZeroU32);
pub trait CUresultConsts {
const SUCCESS: CUresult = CUresult::Ok(());
const ERROR_INVALID_VALUE: CUresult = CUresult::Err(CUerror::INVALID_VALUE);
const ERROR_OUT_OF_MEMORY: CUresult = CUresult::Err(CUerror::OUT_OF_MEMORY);
const ERROR_NOT_INITIALIZED: CUresult = CUresult::Err(CUerror::NOT_INITIALIZED);
const ERROR_DEINITIALIZED: CUresult = CUresult::Err(CUerror::DEINITIALIZED);
const ERROR_PROFILER_DISABLED: CUresult = CUresult::Err(CUerror::PROFILER_DISABLED);
const ERROR_INVALID_VALUE: CUresult = CUresult::Err(CUerror::r#INVALID_VALUE);
const ERROR_OUT_OF_MEMORY: CUresult = CUresult::Err(CUerror::r#OUT_OF_MEMORY);
const ERROR_NOT_INITIALIZED: CUresult = CUresult::Err(CUerror::r#NOT_INITIALIZED);
const ERROR_DEINITIALIZED: CUresult = CUresult::Err(CUerror::r#DEINITIALIZED);
const ERROR_PROFILER_DISABLED: CUresult = CUresult::Err(
CUerror::r#PROFILER_DISABLED,
);
const ERROR_PROFILER_NOT_INITIALIZED: CUresult = CUresult::Err(
CUerror::PROFILER_NOT_INITIALIZED,
CUerror::r#PROFILER_NOT_INITIALIZED,
);
const ERROR_PROFILER_ALREADY_STARTED: CUresult = CUresult::Err(
CUerror::PROFILER_ALREADY_STARTED,
CUerror::r#PROFILER_ALREADY_STARTED,
);
const ERROR_PROFILER_ALREADY_STOPPED: CUresult = CUresult::Err(
CUerror::PROFILER_ALREADY_STOPPED,
CUerror::r#PROFILER_ALREADY_STOPPED,
);
const ERROR_STUB_LIBRARY: CUresult = CUresult::Err(CUerror::STUB_LIBRARY);
const ERROR_STUB_LIBRARY: CUresult = CUresult::Err(CUerror::r#STUB_LIBRARY);
const ERROR_DEVICE_UNAVAILABLE: CUresult = CUresult::Err(
CUerror::DEVICE_UNAVAILABLE,
CUerror::r#DEVICE_UNAVAILABLE,
);
const ERROR_NO_DEVICE: CUresult = CUresult::Err(CUerror::NO_DEVICE);
const ERROR_INVALID_DEVICE: CUresult = CUresult::Err(CUerror::INVALID_DEVICE);
const ERROR_NO_DEVICE: CUresult = CUresult::Err(CUerror::r#NO_DEVICE);
const ERROR_INVALID_DEVICE: CUresult = CUresult::Err(CUerror::r#INVALID_DEVICE);
const ERROR_DEVICE_NOT_LICENSED: CUresult = CUresult::Err(
CUerror::DEVICE_NOT_LICENSED,
CUerror::r#DEVICE_NOT_LICENSED,
);
const ERROR_INVALID_IMAGE: CUresult = CUresult::Err(CUerror::INVALID_IMAGE);
const ERROR_INVALID_CONTEXT: CUresult = CUresult::Err(CUerror::INVALID_CONTEXT);
const ERROR_INVALID_IMAGE: CUresult = CUresult::Err(CUerror::r#INVALID_IMAGE);
const ERROR_INVALID_CONTEXT: CUresult = CUresult::Err(CUerror::r#INVALID_CONTEXT);
const ERROR_CONTEXT_ALREADY_CURRENT: CUresult = CUresult::Err(
CUerror::CONTEXT_ALREADY_CURRENT,
CUerror::r#CONTEXT_ALREADY_CURRENT,
);
const ERROR_MAP_FAILED: CUresult = CUresult::Err(CUerror::MAP_FAILED);
const ERROR_UNMAP_FAILED: CUresult = CUresult::Err(CUerror::UNMAP_FAILED);
const ERROR_ARRAY_IS_MAPPED: CUresult = CUresult::Err(CUerror::ARRAY_IS_MAPPED);
const ERROR_ALREADY_MAPPED: CUresult = CUresult::Err(CUerror::ALREADY_MAPPED);
const ERROR_NO_BINARY_FOR_GPU: CUresult = CUresult::Err(CUerror::NO_BINARY_FOR_GPU);
const ERROR_ALREADY_ACQUIRED: CUresult = CUresult::Err(CUerror::ALREADY_ACQUIRED);
const ERROR_NOT_MAPPED: CUresult = CUresult::Err(CUerror::NOT_MAPPED);
const ERROR_MAP_FAILED: CUresult = CUresult::Err(CUerror::r#MAP_FAILED);
const ERROR_UNMAP_FAILED: CUresult = CUresult::Err(CUerror::r#UNMAP_FAILED);
const ERROR_ARRAY_IS_MAPPED: CUresult = CUresult::Err(CUerror::r#ARRAY_IS_MAPPED);
const ERROR_ALREADY_MAPPED: CUresult = CUresult::Err(CUerror::r#ALREADY_MAPPED);
const ERROR_NO_BINARY_FOR_GPU: CUresult = CUresult::Err(
CUerror::r#NO_BINARY_FOR_GPU,
);
const ERROR_ALREADY_ACQUIRED: CUresult = CUresult::Err(CUerror::r#ALREADY_ACQUIRED);
const ERROR_NOT_MAPPED: CUresult = CUresult::Err(CUerror::r#NOT_MAPPED);
const ERROR_NOT_MAPPED_AS_ARRAY: CUresult = CUresult::Err(
CUerror::NOT_MAPPED_AS_ARRAY,
CUerror::r#NOT_MAPPED_AS_ARRAY,
);
const ERROR_NOT_MAPPED_AS_POINTER: CUresult = CUresult::Err(
CUerror::NOT_MAPPED_AS_POINTER,
CUerror::r#NOT_MAPPED_AS_POINTER,
);
const ERROR_ECC_UNCORRECTABLE: CUresult = CUresult::Err(
CUerror::r#ECC_UNCORRECTABLE,
);
const ERROR_UNSUPPORTED_LIMIT: CUresult = CUresult::Err(
CUerror::r#UNSUPPORTED_LIMIT,
);
const ERROR_ECC_UNCORRECTABLE: CUresult = CUresult::Err(CUerror::ECC_UNCORRECTABLE);
const ERROR_UNSUPPORTED_LIMIT: CUresult = CUresult::Err(CUerror::UNSUPPORTED_LIMIT);
const ERROR_CONTEXT_ALREADY_IN_USE: CUresult = CUresult::Err(
CUerror::CONTEXT_ALREADY_IN_USE,
CUerror::r#CONTEXT_ALREADY_IN_USE,
);
const ERROR_PEER_ACCESS_UNSUPPORTED: CUresult = CUresult::Err(
CUerror::PEER_ACCESS_UNSUPPORTED,
CUerror::r#PEER_ACCESS_UNSUPPORTED,
);
const ERROR_INVALID_PTX: CUresult = CUresult::Err(CUerror::INVALID_PTX);
const ERROR_INVALID_PTX: CUresult = CUresult::Err(CUerror::r#INVALID_PTX);
const ERROR_INVALID_GRAPHICS_CONTEXT: CUresult = CUresult::Err(
CUerror::INVALID_GRAPHICS_CONTEXT,
CUerror::r#INVALID_GRAPHICS_CONTEXT,
);
const ERROR_NVLINK_UNCORRECTABLE: CUresult = CUresult::Err(
CUerror::NVLINK_UNCORRECTABLE,
CUerror::r#NVLINK_UNCORRECTABLE,
);
const ERROR_JIT_COMPILER_NOT_FOUND: CUresult = CUresult::Err(
CUerror::JIT_COMPILER_NOT_FOUND,
CUerror::r#JIT_COMPILER_NOT_FOUND,
);
const ERROR_UNSUPPORTED_PTX_VERSION: CUresult = CUresult::Err(
CUerror::UNSUPPORTED_PTX_VERSION,
CUerror::r#UNSUPPORTED_PTX_VERSION,
);
const ERROR_JIT_COMPILATION_DISABLED: CUresult = CUresult::Err(
CUerror::JIT_COMPILATION_DISABLED,
CUerror::r#JIT_COMPILATION_DISABLED,
);
const ERROR_UNSUPPORTED_EXEC_AFFINITY: CUresult = CUresult::Err(
CUerror::UNSUPPORTED_EXEC_AFFINITY,
CUerror::r#UNSUPPORTED_EXEC_AFFINITY,
);
const ERROR_UNSUPPORTED_DEVSIDE_SYNC: CUresult = CUresult::Err(
CUerror::UNSUPPORTED_DEVSIDE_SYNC,
CUerror::r#UNSUPPORTED_DEVSIDE_SYNC,
);
const ERROR_CONTAINED: CUresult = CUresult::Err(CUerror::CONTAINED);
const ERROR_INVALID_SOURCE: CUresult = CUresult::Err(CUerror::INVALID_SOURCE);
const ERROR_FILE_NOT_FOUND: CUresult = CUresult::Err(CUerror::FILE_NOT_FOUND);
const ERROR_CONTAINED: CUresult = CUresult::Err(CUerror::r#CONTAINED);
const ERROR_INVALID_SOURCE: CUresult = CUresult::Err(CUerror::r#INVALID_SOURCE);
const ERROR_FILE_NOT_FOUND: CUresult = CUresult::Err(CUerror::r#FILE_NOT_FOUND);
const ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: CUresult = CUresult::Err(
CUerror::SHARED_OBJECT_SYMBOL_NOT_FOUND,
CUerror::r#SHARED_OBJECT_SYMBOL_NOT_FOUND,
);
const ERROR_SHARED_OBJECT_INIT_FAILED: CUresult = CUresult::Err(
CUerror::SHARED_OBJECT_INIT_FAILED,
CUerror::r#SHARED_OBJECT_INIT_FAILED,
);
const ERROR_OPERATING_SYSTEM: CUresult = CUresult::Err(CUerror::OPERATING_SYSTEM);
const ERROR_INVALID_HANDLE: CUresult = CUresult::Err(CUerror::INVALID_HANDLE);
const ERROR_ILLEGAL_STATE: CUresult = CUresult::Err(CUerror::ILLEGAL_STATE);
const ERROR_LOSSY_QUERY: CUresult = CUresult::Err(CUerror::LOSSY_QUERY);
const ERROR_NOT_FOUND: CUresult = CUresult::Err(CUerror::NOT_FOUND);
const ERROR_NOT_READY: CUresult = CUresult::Err(CUerror::NOT_READY);
const ERROR_ILLEGAL_ADDRESS: CUresult = CUresult::Err(CUerror::ILLEGAL_ADDRESS);
const ERROR_OPERATING_SYSTEM: CUresult = CUresult::Err(CUerror::r#OPERATING_SYSTEM);
const ERROR_INVALID_HANDLE: CUresult = CUresult::Err(CUerror::r#INVALID_HANDLE);
const ERROR_ILLEGAL_STATE: CUresult = CUresult::Err(CUerror::r#ILLEGAL_STATE);
const ERROR_LOSSY_QUERY: CUresult = CUresult::Err(CUerror::r#LOSSY_QUERY);
const ERROR_NOT_FOUND: CUresult = CUresult::Err(CUerror::r#NOT_FOUND);
const ERROR_NOT_READY: CUresult = CUresult::Err(CUerror::r#NOT_READY);
const ERROR_ILLEGAL_ADDRESS: CUresult = CUresult::Err(CUerror::r#ILLEGAL_ADDRESS);
const ERROR_LAUNCH_OUT_OF_RESOURCES: CUresult = CUresult::Err(
CUerror::LAUNCH_OUT_OF_RESOURCES,
CUerror::r#LAUNCH_OUT_OF_RESOURCES,
);
const ERROR_LAUNCH_TIMEOUT: CUresult = CUresult::Err(CUerror::LAUNCH_TIMEOUT);
const ERROR_LAUNCH_TIMEOUT: CUresult = CUresult::Err(CUerror::r#LAUNCH_TIMEOUT);
const ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: CUresult = CUresult::Err(
CUerror::LAUNCH_INCOMPATIBLE_TEXTURING,
CUerror::r#LAUNCH_INCOMPATIBLE_TEXTURING,
);
const ERROR_PEER_ACCESS_ALREADY_ENABLED: CUresult = CUresult::Err(
CUerror::PEER_ACCESS_ALREADY_ENABLED,
CUerror::r#PEER_ACCESS_ALREADY_ENABLED,
);
const ERROR_PEER_ACCESS_NOT_ENABLED: CUresult = CUresult::Err(
CUerror::PEER_ACCESS_NOT_ENABLED,
CUerror::r#PEER_ACCESS_NOT_ENABLED,
);
const ERROR_PRIMARY_CONTEXT_ACTIVE: CUresult = CUresult::Err(
CUerror::PRIMARY_CONTEXT_ACTIVE,
CUerror::r#PRIMARY_CONTEXT_ACTIVE,
);
const ERROR_CONTEXT_IS_DESTROYED: CUresult = CUresult::Err(
CUerror::CONTEXT_IS_DESTROYED,
CUerror::r#CONTEXT_IS_DESTROYED,
);
const ERROR_ASSERT: CUresult = CUresult::Err(CUerror::ASSERT);
const ERROR_TOO_MANY_PEERS: CUresult = CUresult::Err(CUerror::TOO_MANY_PEERS);
const ERROR_ASSERT: CUresult = CUresult::Err(CUerror::r#ASSERT);
const ERROR_TOO_MANY_PEERS: CUresult = CUresult::Err(CUerror::r#TOO_MANY_PEERS);
const ERROR_HOST_MEMORY_ALREADY_REGISTERED: CUresult = CUresult::Err(
CUerror::HOST_MEMORY_ALREADY_REGISTERED,
CUerror::r#HOST_MEMORY_ALREADY_REGISTERED,
);
const ERROR_HOST_MEMORY_NOT_REGISTERED: CUresult = CUresult::Err(
CUerror::HOST_MEMORY_NOT_REGISTERED,
CUerror::r#HOST_MEMORY_NOT_REGISTERED,
);
const ERROR_HARDWARE_STACK_ERROR: CUresult = CUresult::Err(
CUerror::HARDWARE_STACK_ERROR,
CUerror::r#HARDWARE_STACK_ERROR,
);
const ERROR_ILLEGAL_INSTRUCTION: CUresult = CUresult::Err(
CUerror::ILLEGAL_INSTRUCTION,
CUerror::r#ILLEGAL_INSTRUCTION,
);
const ERROR_MISALIGNED_ADDRESS: CUresult = CUresult::Err(
CUerror::MISALIGNED_ADDRESS,
CUerror::r#MISALIGNED_ADDRESS,
);
const ERROR_INVALID_ADDRESS_SPACE: CUresult = CUresult::Err(
CUerror::INVALID_ADDRESS_SPACE,
CUerror::r#INVALID_ADDRESS_SPACE,
);
const ERROR_INVALID_PC: CUresult = CUresult::Err(CUerror::INVALID_PC);
const ERROR_LAUNCH_FAILED: CUresult = CUresult::Err(CUerror::LAUNCH_FAILED);
const ERROR_INVALID_PC: CUresult = CUresult::Err(CUerror::r#INVALID_PC);
const ERROR_LAUNCH_FAILED: CUresult = CUresult::Err(CUerror::r#LAUNCH_FAILED);
const ERROR_COOPERATIVE_LAUNCH_TOO_LARGE: CUresult = CUresult::Err(
CUerror::COOPERATIVE_LAUNCH_TOO_LARGE,
CUerror::r#COOPERATIVE_LAUNCH_TOO_LARGE,
);
const ERROR_TENSOR_MEMORY_LEAK: CUresult = CUresult::Err(
CUerror::TENSOR_MEMORY_LEAK,
CUerror::r#TENSOR_MEMORY_LEAK,
);
const ERROR_NOT_PERMITTED: CUresult = CUresult::Err(CUerror::NOT_PERMITTED);
const ERROR_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::NOT_SUPPORTED);
const ERROR_SYSTEM_NOT_READY: CUresult = CUresult::Err(CUerror::SYSTEM_NOT_READY);
const ERROR_NOT_PERMITTED: CUresult = CUresult::Err(CUerror::r#NOT_PERMITTED);
const ERROR_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::r#NOT_SUPPORTED);
const ERROR_SYSTEM_NOT_READY: CUresult = CUresult::Err(CUerror::r#SYSTEM_NOT_READY);
const ERROR_SYSTEM_DRIVER_MISMATCH: CUresult = CUresult::Err(
CUerror::SYSTEM_DRIVER_MISMATCH,
CUerror::r#SYSTEM_DRIVER_MISMATCH,
);
const ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: CUresult = CUresult::Err(
CUerror::COMPAT_NOT_SUPPORTED_ON_DEVICE,
CUerror::r#COMPAT_NOT_SUPPORTED_ON_DEVICE,
);
const ERROR_MPS_CONNECTION_FAILED: CUresult = CUresult::Err(
CUerror::MPS_CONNECTION_FAILED,
CUerror::r#MPS_CONNECTION_FAILED,
);
const ERROR_MPS_RPC_FAILURE: CUresult = CUresult::Err(CUerror::MPS_RPC_FAILURE);
const ERROR_MPS_RPC_FAILURE: CUresult = CUresult::Err(CUerror::r#MPS_RPC_FAILURE);
const ERROR_MPS_SERVER_NOT_READY: CUresult = CUresult::Err(
CUerror::MPS_SERVER_NOT_READY,
CUerror::r#MPS_SERVER_NOT_READY,
);
const ERROR_MPS_MAX_CLIENTS_REACHED: CUresult = CUresult::Err(
CUerror::MPS_MAX_CLIENTS_REACHED,
CUerror::r#MPS_MAX_CLIENTS_REACHED,
);
const ERROR_MPS_MAX_CONNECTIONS_REACHED: CUresult = CUresult::Err(
CUerror::MPS_MAX_CONNECTIONS_REACHED,
CUerror::r#MPS_MAX_CONNECTIONS_REACHED,
);
const ERROR_MPS_CLIENT_TERMINATED: CUresult = CUresult::Err(
CUerror::MPS_CLIENT_TERMINATED,
CUerror::r#MPS_CLIENT_TERMINATED,
);
const ERROR_CDP_NOT_SUPPORTED: CUresult = CUresult::Err(
CUerror::r#CDP_NOT_SUPPORTED,
);
const ERROR_CDP_NOT_SUPPORTED: CUresult = CUresult::Err(CUerror::CDP_NOT_SUPPORTED);
const ERROR_CDP_VERSION_MISMATCH: CUresult = CUresult::Err(
CUerror::CDP_VERSION_MISMATCH,
CUerror::r#CDP_VERSION_MISMATCH,
);
const ERROR_STREAM_CAPTURE_UNSUPPORTED: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_UNSUPPORTED,
CUerror::r#STREAM_CAPTURE_UNSUPPORTED,
);
const ERROR_STREAM_CAPTURE_INVALIDATED: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_INVALIDATED,
CUerror::r#STREAM_CAPTURE_INVALIDATED,
);
const ERROR_STREAM_CAPTURE_MERGE: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_MERGE,
CUerror::r#STREAM_CAPTURE_MERGE,
);
const ERROR_STREAM_CAPTURE_UNMATCHED: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_UNMATCHED,
CUerror::r#STREAM_CAPTURE_UNMATCHED,
);
const ERROR_STREAM_CAPTURE_UNJOINED: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_UNJOINED,
CUerror::r#STREAM_CAPTURE_UNJOINED,
);
const ERROR_STREAM_CAPTURE_ISOLATION: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_ISOLATION,
CUerror::r#STREAM_CAPTURE_ISOLATION,
);
const ERROR_STREAM_CAPTURE_IMPLICIT: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_IMPLICIT,
CUerror::r#STREAM_CAPTURE_IMPLICIT,
);
const ERROR_CAPTURED_EVENT: CUresult = CUresult::Err(CUerror::CAPTURED_EVENT);
const ERROR_CAPTURED_EVENT: CUresult = CUresult::Err(CUerror::r#CAPTURED_EVENT);
const ERROR_STREAM_CAPTURE_WRONG_THREAD: CUresult = CUresult::Err(
CUerror::STREAM_CAPTURE_WRONG_THREAD,
CUerror::r#STREAM_CAPTURE_WRONG_THREAD,
);
const ERROR_TIMEOUT: CUresult = CUresult::Err(CUerror::TIMEOUT);
const ERROR_TIMEOUT: CUresult = CUresult::Err(CUerror::r#TIMEOUT);
const ERROR_GRAPH_EXEC_UPDATE_FAILURE: CUresult = CUresult::Err(
CUerror::GRAPH_EXEC_UPDATE_FAILURE,
CUerror::r#GRAPH_EXEC_UPDATE_FAILURE,
);
const ERROR_EXTERNAL_DEVICE: CUresult = CUresult::Err(CUerror::EXTERNAL_DEVICE);
const ERROR_EXTERNAL_DEVICE: CUresult = CUresult::Err(CUerror::r#EXTERNAL_DEVICE);
const ERROR_INVALID_CLUSTER_SIZE: CUresult = CUresult::Err(
CUerror::INVALID_CLUSTER_SIZE,
CUerror::r#INVALID_CLUSTER_SIZE,
);
const ERROR_FUNCTION_NOT_LOADED: CUresult = CUresult::Err(
CUerror::FUNCTION_NOT_LOADED,
CUerror::r#FUNCTION_NOT_LOADED,
);
const ERROR_INVALID_RESOURCE_TYPE: CUresult = CUresult::Err(
CUerror::INVALID_RESOURCE_TYPE,
CUerror::r#INVALID_RESOURCE_TYPE,
);
const ERROR_INVALID_RESOURCE_CONFIGURATION: CUresult = CUresult::Err(
CUerror::INVALID_RESOURCE_CONFIGURATION,
CUerror::r#INVALID_RESOURCE_CONFIGURATION,
);
const ERROR_KEY_ROTATION: CUresult = CUresult::Err(CUerror::KEY_ROTATION);
const ERROR_UNKNOWN: CUresult = CUresult::Err(CUerror::UNKNOWN);
const ERROR_KEY_ROTATION: CUresult = CUresult::Err(CUerror::r#KEY_ROTATION);
const ERROR_UNKNOWN: CUresult = CUresult::Err(CUerror::r#UNKNOWN);
}
impl CUresultConsts for CUresult {}
#[must_use]

122
cuda_types/src/nvml.rs
View File

@ -4706,94 +4706,94 @@ pub struct nvmlPowerSmoothingState_v1_t {
}
pub type nvmlPowerSmoothingState_t = nvmlPowerSmoothingState_v1_t;
impl nvmlError_t {
pub const UNINITIALIZED: nvmlError_t = nvmlError_t(unsafe {
pub const r#UNINITIALIZED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(1)
});
pub const INVALID_ARGUMENT: nvmlError_t = nvmlError_t(unsafe {
pub const r#INVALID_ARGUMENT: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(2)
});
pub const NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
pub const r#NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(3)
});
pub const NO_PERMISSION: nvmlError_t = nvmlError_t(unsafe {
pub const r#NO_PERMISSION: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(4)
});
pub const ALREADY_INITIALIZED: nvmlError_t = nvmlError_t(unsafe {
pub const r#ALREADY_INITIALIZED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(5)
});
pub const NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
pub const r#NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(6)
});
pub const INSUFFICIENT_SIZE: nvmlError_t = nvmlError_t(unsafe {
pub const r#INSUFFICIENT_SIZE: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(7)
});
pub const INSUFFICIENT_POWER: nvmlError_t = nvmlError_t(unsafe {
pub const r#INSUFFICIENT_POWER: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(8)
});
pub const DRIVER_NOT_LOADED: nvmlError_t = nvmlError_t(unsafe {
pub const r#DRIVER_NOT_LOADED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(9)
});
pub const TIMEOUT: nvmlError_t = nvmlError_t(unsafe {
pub const r#TIMEOUT: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(10)
});
pub const IRQ_ISSUE: nvmlError_t = nvmlError_t(unsafe {
pub const r#IRQ_ISSUE: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(11)
});
pub const LIBRARY_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
pub const r#LIBRARY_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(12)
});
pub const FUNCTION_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
pub const r#FUNCTION_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(13)
});
pub const CORRUPTED_INFOROM: nvmlError_t = nvmlError_t(unsafe {
pub const r#CORRUPTED_INFOROM: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(14)
});
pub const GPU_IS_LOST: nvmlError_t = nvmlError_t(unsafe {
pub const r#GPU_IS_LOST: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(15)
});
pub const RESET_REQUIRED: nvmlError_t = nvmlError_t(unsafe {
pub const r#RESET_REQUIRED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(16)
});
pub const OPERATING_SYSTEM: nvmlError_t = nvmlError_t(unsafe {
pub const r#OPERATING_SYSTEM: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(17)
});
pub const LIB_RM_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
pub const r#LIB_RM_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(18)
});
pub const IN_USE: nvmlError_t = nvmlError_t(unsafe {
pub const r#IN_USE: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(19)
});
pub const MEMORY: nvmlError_t = nvmlError_t(unsafe {
pub const r#MEMORY: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(20)
});
pub const NO_DATA: nvmlError_t = nvmlError_t(unsafe {
pub const r#NO_DATA: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(21)
});
pub const VGPU_ECC_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
pub const r#VGPU_ECC_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(22)
});
pub const INSUFFICIENT_RESOURCES: nvmlError_t = nvmlError_t(unsafe {
pub const r#INSUFFICIENT_RESOURCES: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(23)
});
pub const FREQ_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
pub const r#FREQ_NOT_SUPPORTED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(24)
});
pub const ARGUMENT_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
pub const r#ARGUMENT_VERSION_MISMATCH: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(25)
});
pub const DEPRECATED: nvmlError_t = nvmlError_t(unsafe {
pub const r#DEPRECATED: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(26)
});
pub const NOT_READY: nvmlError_t = nvmlError_t(unsafe {
pub const r#NOT_READY: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(27)
});
pub const GPU_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
pub const r#GPU_NOT_FOUND: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(28)
});
pub const INVALID_STATE: nvmlError_t = nvmlError_t(unsafe {
pub const r#INVALID_STATE: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(29)
});
pub const UNKNOWN: nvmlError_t = nvmlError_t(unsafe {
pub const r#UNKNOWN: nvmlError_t = nvmlError_t(unsafe {
::core::num::NonZeroU32::new_unchecked(999)
});
}
@ -4803,75 +4803,77 @@ pub struct nvmlError_t(pub ::core::num::NonZeroU32);
pub trait nvmlReturn_tConsts {
const SUCCESS: nvmlReturn_t = nvmlReturn_t::Ok(());
const ERROR_UNINITIALIZED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::UNINITIALIZED,
nvmlError_t::r#UNINITIALIZED,
);
const ERROR_INVALID_ARGUMENT: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::INVALID_ARGUMENT,
nvmlError_t::r#INVALID_ARGUMENT,
);
const ERROR_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::NOT_SUPPORTED,
nvmlError_t::r#NOT_SUPPORTED,
);
const ERROR_NO_PERMISSION: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::NO_PERMISSION,
nvmlError_t::r#NO_PERMISSION,
);
const ERROR_ALREADY_INITIALIZED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::ALREADY_INITIALIZED,
nvmlError_t::r#ALREADY_INITIALIZED,
);
const ERROR_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NOT_FOUND);
const ERROR_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NOT_FOUND);
const ERROR_INSUFFICIENT_SIZE: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::INSUFFICIENT_SIZE,
nvmlError_t::r#INSUFFICIENT_SIZE,
);
const ERROR_INSUFFICIENT_POWER: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::INSUFFICIENT_POWER,
nvmlError_t::r#INSUFFICIENT_POWER,
);
const ERROR_DRIVER_NOT_LOADED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::DRIVER_NOT_LOADED,
nvmlError_t::r#DRIVER_NOT_LOADED,
);
const ERROR_TIMEOUT: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::TIMEOUT);
const ERROR_IRQ_ISSUE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::IRQ_ISSUE);
const ERROR_TIMEOUT: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#TIMEOUT);
const ERROR_IRQ_ISSUE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#IRQ_ISSUE);
const ERROR_LIBRARY_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::LIBRARY_NOT_FOUND,
nvmlError_t::r#LIBRARY_NOT_FOUND,
);
const ERROR_FUNCTION_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::FUNCTION_NOT_FOUND,
nvmlError_t::r#FUNCTION_NOT_FOUND,
);
const ERROR_CORRUPTED_INFOROM: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::CORRUPTED_INFOROM,
nvmlError_t::r#CORRUPTED_INFOROM,
);
const ERROR_GPU_IS_LOST: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::r#GPU_IS_LOST,
);
const ERROR_GPU_IS_LOST: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::GPU_IS_LOST);
const ERROR_RESET_REQUIRED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::RESET_REQUIRED,
nvmlError_t::r#RESET_REQUIRED,
);
const ERROR_OPERATING_SYSTEM: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::OPERATING_SYSTEM,
nvmlError_t::r#OPERATING_SYSTEM,
);
const ERROR_LIB_RM_VERSION_MISMATCH: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::LIB_RM_VERSION_MISMATCH,
nvmlError_t::r#LIB_RM_VERSION_MISMATCH,
);
const ERROR_IN_USE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::IN_USE);
const ERROR_MEMORY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::MEMORY);
const ERROR_NO_DATA: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NO_DATA);
const ERROR_IN_USE: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#IN_USE);
const ERROR_MEMORY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#MEMORY);
const ERROR_NO_DATA: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NO_DATA);
const ERROR_VGPU_ECC_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::VGPU_ECC_NOT_SUPPORTED,
nvmlError_t::r#VGPU_ECC_NOT_SUPPORTED,
);
const ERROR_INSUFFICIENT_RESOURCES: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::INSUFFICIENT_RESOURCES,
nvmlError_t::r#INSUFFICIENT_RESOURCES,
);
const ERROR_FREQ_NOT_SUPPORTED: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::FREQ_NOT_SUPPORTED,
nvmlError_t::r#FREQ_NOT_SUPPORTED,
);
const ERROR_ARGUMENT_VERSION_MISMATCH: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::ARGUMENT_VERSION_MISMATCH,
nvmlError_t::r#ARGUMENT_VERSION_MISMATCH,
);
const ERROR_DEPRECATED: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::DEPRECATED);
const ERROR_NOT_READY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::NOT_READY);
const ERROR_DEPRECATED: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#DEPRECATED);
const ERROR_NOT_READY: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#NOT_READY);
const ERROR_GPU_NOT_FOUND: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::GPU_NOT_FOUND,
nvmlError_t::r#GPU_NOT_FOUND,
);
const ERROR_INVALID_STATE: nvmlReturn_t = nvmlReturn_t::Err(
nvmlError_t::INVALID_STATE,
nvmlError_t::r#INVALID_STATE,
);
const ERROR_UNKNOWN: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::UNKNOWN);
const ERROR_UNKNOWN: nvmlReturn_t = nvmlReturn_t::Err(nvmlError_t::r#UNKNOWN);
}
impl nvmlReturn_tConsts for nvmlReturn_t {}
#[must_use]

328
ext/hip_runtime-sys/src/lib.rs vendored
View File

@ -13215,241 +13215,241 @@ extern "C" {
) -> hipError_t;
}
impl hipErrorCode_t {
pub const InvalidValue: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidValue: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(1)
});
pub const OutOfMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#OutOfMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(2)
});
pub const MemoryAllocation: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#MemoryAllocation: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(2)
});
pub const NotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(3)
});
pub const InitializationError: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InitializationError: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(3)
});
pub const Deinitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#Deinitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(4)
});
pub const ProfilerDisabled: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ProfilerDisabled: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(5)
});
pub const ProfilerNotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ProfilerNotInitialized: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(6)
});
pub const ProfilerAlreadyStarted: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ProfilerAlreadyStarted: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(7)
});
pub const ProfilerAlreadyStopped: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ProfilerAlreadyStopped: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(8)
});
pub const InvalidConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(9)
});
pub const InvalidPitchValue: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidPitchValue: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(12)
});
pub const InvalidSymbol: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidSymbol: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(13)
});
pub const InvalidDevicePointer: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidDevicePointer: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(17)
});
pub const InvalidMemcpyDirection: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidMemcpyDirection: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(21)
});
pub const InsufficientDriver: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InsufficientDriver: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(35)
});
pub const MissingConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#MissingConfiguration: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(52)
});
pub const PriorLaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#PriorLaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(53)
});
pub const InvalidDeviceFunction: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidDeviceFunction: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(98)
});
pub const NoDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NoDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(100)
});
pub const InvalidDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidDevice: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(101)
});
pub const InvalidImage: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidImage: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(200)
});
pub const InvalidContext: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidContext: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(201)
});
pub const ContextAlreadyCurrent: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ContextAlreadyCurrent: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(202)
});
pub const MapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#MapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(205)
});
pub const MapBufferObjectFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#MapBufferObjectFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(205)
});
pub const UnmapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#UnmapFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(206)
});
pub const ArrayIsMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ArrayIsMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(207)
});
pub const AlreadyMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#AlreadyMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(208)
});
pub const NoBinaryForGpu: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NoBinaryForGpu: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(209)
});
pub const AlreadyAcquired: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#AlreadyAcquired: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(210)
});
pub const NotMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotMapped: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(211)
});
pub const NotMappedAsArray: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotMappedAsArray: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(212)
});
pub const NotMappedAsPointer: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotMappedAsPointer: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(213)
});
pub const ECCNotCorrectable: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ECCNotCorrectable: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(214)
});
pub const UnsupportedLimit: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#UnsupportedLimit: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(215)
});
pub const ContextAlreadyInUse: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ContextAlreadyInUse: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(216)
});
pub const PeerAccessUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#PeerAccessUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(217)
});
pub const InvalidKernelFile: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidKernelFile: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(218)
});
pub const InvalidGraphicsContext: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidGraphicsContext: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(219)
});
pub const InvalidSource: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidSource: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(300)
});
pub const FileNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#FileNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(301)
});
pub const SharedObjectSymbolNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#SharedObjectSymbolNotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(302)
});
pub const SharedObjectInitFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#SharedObjectInitFailed: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(303)
});
pub const OperatingSystem: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#OperatingSystem: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(304)
});
pub const InvalidHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(400)
});
pub const InvalidResourceHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidResourceHandle: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(400)
});
pub const IllegalState: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#IllegalState: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(401)
});
pub const NotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotFound: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(500)
});
pub const NotReady: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotReady: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(600)
});
pub const IllegalAddress: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#IllegalAddress: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(700)
});
pub const LaunchOutOfResources: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#LaunchOutOfResources: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(701)
});
pub const LaunchTimeOut: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#LaunchTimeOut: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(702)
});
pub const PeerAccessAlreadyEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#PeerAccessAlreadyEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(704)
});
pub const PeerAccessNotEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#PeerAccessNotEnabled: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(705)
});
pub const SetOnActiveProcess: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#SetOnActiveProcess: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(708)
});
pub const ContextIsDestroyed: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#ContextIsDestroyed: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(709)
});
pub const Assert: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#Assert: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(710)
});
pub const HostMemoryAlreadyRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#HostMemoryAlreadyRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(712)
});
pub const HostMemoryNotRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#HostMemoryNotRegistered: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(713)
});
pub const LaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#LaunchFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(719)
});
pub const CooperativeLaunchTooLarge: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#CooperativeLaunchTooLarge: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(720)
});
pub const NotSupported: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#NotSupported: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(801)
});
pub const StreamCaptureUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureUnsupported: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(900)
});
pub const StreamCaptureInvalidated: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureInvalidated: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(901)
});
pub const StreamCaptureMerge: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureMerge: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(902)
});
pub const StreamCaptureUnmatched: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureUnmatched: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(903)
});
pub const StreamCaptureUnjoined: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureUnjoined: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(904)
});
pub const StreamCaptureIsolation: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureIsolation: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(905)
});
pub const StreamCaptureImplicit: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureImplicit: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(906)
});
pub const CapturedEvent: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#CapturedEvent: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(907)
});
pub const StreamCaptureWrongThread: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#StreamCaptureWrongThread: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(908)
});
pub const GraphExecUpdateFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#GraphExecUpdateFailure: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(910)
});
pub const InvalidChannelDescriptor: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidChannelDescriptor: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(911)
});
pub const InvalidTexture: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#InvalidTexture: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(912)
});
pub const Unknown: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#Unknown: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(999)
});
pub const RuntimeMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#RuntimeMemory: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(1052)
});
pub const RuntimeOther: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#RuntimeOther: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(1053)
});
pub const Tbd: hipErrorCode_t = hipErrorCode_t(unsafe {
pub const r#Tbd: hipErrorCode_t = hipErrorCode_t(unsafe {
::core::num::NonZeroU32::new_unchecked(1054)
});
}
@ -13458,211 +13458,223 @@ impl hipErrorCode_t {
pub struct hipErrorCode_t(pub ::core::num::NonZeroU32);
pub trait hipError_tConsts {
const Success: hipError_t = hipError_t::Ok(());
const ErrorInvalidValue: hipError_t = hipError_t::Err(hipErrorCode_t::InvalidValue);
const ErrorOutOfMemory: hipError_t = hipError_t::Err(hipErrorCode_t::OutOfMemory);
const ErrorInvalidValue: hipError_t = hipError_t::Err(
hipErrorCode_t::r#InvalidValue,
);
const ErrorOutOfMemory: hipError_t = hipError_t::Err(hipErrorCode_t::r#OutOfMemory);
const ErrorMemoryAllocation: hipError_t = hipError_t::Err(
hipErrorCode_t::MemoryAllocation,
hipErrorCode_t::r#MemoryAllocation,
);
const ErrorNotInitialized: hipError_t = hipError_t::Err(
hipErrorCode_t::NotInitialized,
hipErrorCode_t::r#NotInitialized,
);
const ErrorInitializationError: hipError_t = hipError_t::Err(
hipErrorCode_t::InitializationError,
hipErrorCode_t::r#InitializationError,
);
const ErrorDeinitialized: hipError_t = hipError_t::Err(
hipErrorCode_t::Deinitialized,
hipErrorCode_t::r#Deinitialized,
);
const ErrorProfilerDisabled: hipError_t = hipError_t::Err(
hipErrorCode_t::ProfilerDisabled,
hipErrorCode_t::r#ProfilerDisabled,
);
const ErrorProfilerNotInitialized: hipError_t = hipError_t::Err(
hipErrorCode_t::ProfilerNotInitialized,
hipErrorCode_t::r#ProfilerNotInitialized,
);
const ErrorProfilerAlreadyStarted: hipError_t = hipError_t::Err(
hipErrorCode_t::ProfilerAlreadyStarted,
hipErrorCode_t::r#ProfilerAlreadyStarted,
);
const ErrorProfilerAlreadyStopped: hipError_t = hipError_t::Err(
hipErrorCode_t::ProfilerAlreadyStopped,
hipErrorCode_t::r#ProfilerAlreadyStopped,
);
const ErrorInvalidConfiguration: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidConfiguration,
hipErrorCode_t::r#InvalidConfiguration,
);
const ErrorInvalidPitchValue: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidPitchValue,
hipErrorCode_t::r#InvalidPitchValue,
);
const ErrorInvalidSymbol: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidSymbol,
hipErrorCode_t::r#InvalidSymbol,
);
const ErrorInvalidDevicePointer: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidDevicePointer,
hipErrorCode_t::r#InvalidDevicePointer,
);
const ErrorInvalidMemcpyDirection: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidMemcpyDirection,
hipErrorCode_t::r#InvalidMemcpyDirection,
);
const ErrorInsufficientDriver: hipError_t = hipError_t::Err(
hipErrorCode_t::InsufficientDriver,
hipErrorCode_t::r#InsufficientDriver,
);
const ErrorMissingConfiguration: hipError_t = hipError_t::Err(
hipErrorCode_t::MissingConfiguration,
hipErrorCode_t::r#MissingConfiguration,
);
const ErrorPriorLaunchFailure: hipError_t = hipError_t::Err(
hipErrorCode_t::PriorLaunchFailure,
hipErrorCode_t::r#PriorLaunchFailure,
);
const ErrorInvalidDeviceFunction: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidDeviceFunction,
hipErrorCode_t::r#InvalidDeviceFunction,
);
const ErrorNoDevice: hipError_t = hipError_t::Err(hipErrorCode_t::NoDevice);
const ErrorNoDevice: hipError_t = hipError_t::Err(hipErrorCode_t::r#NoDevice);
const ErrorInvalidDevice: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidDevice,
hipErrorCode_t::r#InvalidDevice,
);
const ErrorInvalidImage: hipError_t = hipError_t::Err(
hipErrorCode_t::r#InvalidImage,
);
const ErrorInvalidImage: hipError_t = hipError_t::Err(hipErrorCode_t::InvalidImage);
const ErrorInvalidContext: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidContext,
hipErrorCode_t::r#InvalidContext,
);
const ErrorContextAlreadyCurrent: hipError_t = hipError_t::Err(
hipErrorCode_t::ContextAlreadyCurrent,
hipErrorCode_t::r#ContextAlreadyCurrent,
);
const ErrorMapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::MapFailed);
const ErrorMapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::r#MapFailed);
const ErrorMapBufferObjectFailed: hipError_t = hipError_t::Err(
hipErrorCode_t::MapBufferObjectFailed,
hipErrorCode_t::r#MapBufferObjectFailed,
);
const ErrorUnmapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::UnmapFailed);
const ErrorUnmapFailed: hipError_t = hipError_t::Err(hipErrorCode_t::r#UnmapFailed);
const ErrorArrayIsMapped: hipError_t = hipError_t::Err(
hipErrorCode_t::ArrayIsMapped,
hipErrorCode_t::r#ArrayIsMapped,
);
const ErrorAlreadyMapped: hipError_t = hipError_t::Err(
hipErrorCode_t::AlreadyMapped,
hipErrorCode_t::r#AlreadyMapped,
);
const ErrorNoBinaryForGpu: hipError_t = hipError_t::Err(
hipErrorCode_t::NoBinaryForGpu,
hipErrorCode_t::r#NoBinaryForGpu,
);
const ErrorAlreadyAcquired: hipError_t = hipError_t::Err(
hipErrorCode_t::AlreadyAcquired,
hipErrorCode_t::r#AlreadyAcquired,
);
const ErrorNotMapped: hipError_t = hipError_t::Err(hipErrorCode_t::NotMapped);
const ErrorNotMapped: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotMapped);
const ErrorNotMappedAsArray: hipError_t = hipError_t::Err(
hipErrorCode_t::NotMappedAsArray,
hipErrorCode_t::r#NotMappedAsArray,
);
const ErrorNotMappedAsPointer: hipError_t = hipError_t::Err(
hipErrorCode_t::NotMappedAsPointer,
hipErrorCode_t::r#NotMappedAsPointer,
);
const ErrorECCNotCorrectable: hipError_t = hipError_t::Err(
hipErrorCode_t::ECCNotCorrectable,
hipErrorCode_t::r#ECCNotCorrectable,
);
const ErrorUnsupportedLimit: hipError_t = hipError_t::Err(
hipErrorCode_t::UnsupportedLimit,
hipErrorCode_t::r#UnsupportedLimit,
);
const ErrorContextAlreadyInUse: hipError_t = hipError_t::Err(
hipErrorCode_t::ContextAlreadyInUse,
hipErrorCode_t::r#ContextAlreadyInUse,
);
const ErrorPeerAccessUnsupported: hipError_t = hipError_t::Err(
hipErrorCode_t::PeerAccessUnsupported,
hipErrorCode_t::r#PeerAccessUnsupported,
);
const ErrorInvalidKernelFile: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidKernelFile,
hipErrorCode_t::r#InvalidKernelFile,
);
const ErrorInvalidGraphicsContext: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidGraphicsContext,
hipErrorCode_t::r#InvalidGraphicsContext,
);
const ErrorInvalidSource: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidSource,
hipErrorCode_t::r#InvalidSource,
);
const ErrorFileNotFound: hipError_t = hipError_t::Err(
hipErrorCode_t::r#FileNotFound,
);
const ErrorFileNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::FileNotFound);
const ErrorSharedObjectSymbolNotFound: hipError_t = hipError_t::Err(
hipErrorCode_t::SharedObjectSymbolNotFound,
hipErrorCode_t::r#SharedObjectSymbolNotFound,
);
const ErrorSharedObjectInitFailed: hipError_t = hipError_t::Err(
hipErrorCode_t::SharedObjectInitFailed,
hipErrorCode_t::r#SharedObjectInitFailed,
);
const ErrorOperatingSystem: hipError_t = hipError_t::Err(
hipErrorCode_t::OperatingSystem,
hipErrorCode_t::r#OperatingSystem,
);
const ErrorInvalidHandle: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidHandle,
hipErrorCode_t::r#InvalidHandle,
);
const ErrorInvalidResourceHandle: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidResourceHandle,
hipErrorCode_t::r#InvalidResourceHandle,
);
const ErrorIllegalState: hipError_t = hipError_t::Err(hipErrorCode_t::IllegalState);
const ErrorNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::NotFound);
const ErrorNotReady: hipError_t = hipError_t::Err(hipErrorCode_t::NotReady);
const ErrorIllegalState: hipError_t = hipError_t::Err(
hipErrorCode_t::r#IllegalState,
);
const ErrorNotFound: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotFound);
const ErrorNotReady: hipError_t = hipError_t::Err(hipErrorCode_t::r#NotReady);
const ErrorIllegalAddress: hipError_t = hipError_t::Err(
hipErrorCode_t::IllegalAddress,
hipErrorCode_t::r#IllegalAddress,
);
const ErrorLaunchOutOfResources: hipError_t = hipError_t::Err(
hipErrorCode_t::LaunchOutOfResources,
hipErrorCode_t::r#LaunchOutOfResources,
);
const ErrorLaunchTimeOut: hipError_t = hipError_t::Err(
hipErrorCode_t::LaunchTimeOut,
hipErrorCode_t::r#LaunchTimeOut,
);
const ErrorPeerAccessAlreadyEnabled: hipError_t = hipError_t::Err(
hipErrorCode_t::PeerAccessAlreadyEnabled,
hipErrorCode_t::r#PeerAccessAlreadyEnabled,
);
const ErrorPeerAccessNotEnabled: hipError_t = hipError_t::Err(
hipErrorCode_t::PeerAccessNotEnabled,
hipErrorCode_t::r#PeerAccessNotEnabled,
);
const ErrorSetOnActiveProcess: hipError_t = hipError_t::Err(
hipErrorCode_t::SetOnActiveProcess,
hipErrorCode_t::r#SetOnActiveProcess,
);
const ErrorContextIsDestroyed: hipError_t = hipError_t::Err(
hipErrorCode_t::ContextIsDestroyed,
hipErrorCode_t::r#ContextIsDestroyed,
);
const ErrorAssert: hipError_t = hipError_t::Err(hipErrorCode_t::Assert);
const ErrorAssert: hipError_t = hipError_t::Err(hipErrorCode_t::r#Assert);
const ErrorHostMemoryAlreadyRegistered: hipError_t = hipError_t::Err(
hipErrorCode_t::HostMemoryAlreadyRegistered,
hipErrorCode_t::r#HostMemoryAlreadyRegistered,
);
const ErrorHostMemoryNotRegistered: hipError_t = hipError_t::Err(
hipErrorCode_t::HostMemoryNotRegistered,
hipErrorCode_t::r#HostMemoryNotRegistered,
);
const ErrorLaunchFailure: hipError_t = hipError_t::Err(
hipErrorCode_t::LaunchFailure,
hipErrorCode_t::r#LaunchFailure,
);
const ErrorCooperativeLaunchTooLarge: hipError_t = hipError_t::Err(
hipErrorCode_t::CooperativeLaunchTooLarge,
hipErrorCode_t::r#CooperativeLaunchTooLarge,
);
const ErrorNotSupported: hipError_t = hipError_t::Err(
hipErrorCode_t::r#NotSupported,
);
const ErrorNotSupported: hipError_t = hipError_t::Err(hipErrorCode_t::NotSupported);
const ErrorStreamCaptureUnsupported: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureUnsupported,
hipErrorCode_t::r#StreamCaptureUnsupported,
);
const ErrorStreamCaptureInvalidated: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureInvalidated,
hipErrorCode_t::r#StreamCaptureInvalidated,
);
const ErrorStreamCaptureMerge: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureMerge,
hipErrorCode_t::r#StreamCaptureMerge,
);
const ErrorStreamCaptureUnmatched: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureUnmatched,
hipErrorCode_t::r#StreamCaptureUnmatched,
);
const ErrorStreamCaptureUnjoined: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureUnjoined,
hipErrorCode_t::r#StreamCaptureUnjoined,
);
const ErrorStreamCaptureIsolation: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureIsolation,
hipErrorCode_t::r#StreamCaptureIsolation,
);
const ErrorStreamCaptureImplicit: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureImplicit,
hipErrorCode_t::r#StreamCaptureImplicit,
);
const ErrorCapturedEvent: hipError_t = hipError_t::Err(
hipErrorCode_t::CapturedEvent,
hipErrorCode_t::r#CapturedEvent,
);
const ErrorStreamCaptureWrongThread: hipError_t = hipError_t::Err(
hipErrorCode_t::StreamCaptureWrongThread,
hipErrorCode_t::r#StreamCaptureWrongThread,
);
const ErrorGraphExecUpdateFailure: hipError_t = hipError_t::Err(
hipErrorCode_t::GraphExecUpdateFailure,
hipErrorCode_t::r#GraphExecUpdateFailure,
);
const ErrorInvalidChannelDescriptor: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidChannelDescriptor,
hipErrorCode_t::r#InvalidChannelDescriptor,
);
const ErrorInvalidTexture: hipError_t = hipError_t::Err(
hipErrorCode_t::InvalidTexture,
hipErrorCode_t::r#InvalidTexture,
);
const ErrorUnknown: hipError_t = hipError_t::Err(hipErrorCode_t::Unknown);
const ErrorUnknown: hipError_t = hipError_t::Err(hipErrorCode_t::r#Unknown);
const ErrorRuntimeMemory: hipError_t = hipError_t::Err(
hipErrorCode_t::RuntimeMemory,
hipErrorCode_t::r#RuntimeMemory,
);
const ErrorRuntimeOther: hipError_t = hipError_t::Err(hipErrorCode_t::RuntimeOther);
const ErrorTbd: hipError_t = hipError_t::Err(hipErrorCode_t::Tbd);
const ErrorRuntimeOther: hipError_t = hipError_t::Err(
hipErrorCode_t::r#RuntimeOther,
);
const ErrorTbd: hipError_t = hipError_t::Err(hipErrorCode_t::r#Tbd);
}
impl hipError_tConsts for hipError_t {}
#[must_use]

10
ext/rocblas-sys/Cargo.toml vendored Normal file
View File

@ -0,0 +1,10 @@
[package]
name = "rocblas-sys"
version = "0.1.0"
authors = ["Violet <c01368481@gmail.com>"]
edition = "2021"
[lib]
[dependencies]
hip_runtime-sys = { version = "0.0.0", path = "../hip_runtime-sys" }

9
ext/rocblas-sys/build.rs vendored Normal file
View File

@ -0,0 +1,9 @@
use std::env::VarError;
fn main() -> Result<(), VarError> {
if !cfg!(windows) {
println!("cargo:rustc-link-lib=dylib=rocblas");
println!("cargo:rustc-link-search=native=/opt/rocm/lib/");
}
Ok(())
}

31561
ext/rocblas-sys/src/lib.rs vendored Normal file
View File

File diff suppressed because it is too large Load Diff

56
zluda_bindgen/src/main.rs
View File

@ -28,6 +28,7 @@ fn main() {
&crate_root,
&["..", "ext", "hip_runtime-sys", "src", "lib.rs"],
);
generate_rocblas(&crate_root, &["..", "ext", "rocblas-sys", "src", "lib.rs"]);
let cuda_functions = generate_cuda(&crate_root);
generate_process_address_table(&crate_root, cuda_functions);
generate_ml(&crate_root);
@ -655,6 +656,7 @@ fn remove_type(module: &mut syn::File, type_name: &str) {
let items = items
.into_iter()
.filter_map(|item| match item {
Item::Type(type_) if type_.ident == type_name => None,
Item::Enum(enum_) if enum_.ident == type_name => None,
Item::Struct(struct_) if struct_.ident == type_name => None,
Item::Impl(impl_) if impl_.self_ty.to_token_stream().to_string() == type_name => None,
@ -921,6 +923,58 @@ fn generate_hip_runtime(output: &PathBuf, path: &[&str]) {
write_rust_to_file(output, &prettyplease::unparse(&module))
}
fn generate_rocblas(output: &PathBuf, path: &[&str]) {
let rocblas_header = new_builder()
.header("/opt/rocm/include/rocblas/rocblas.h")
.allowlist_type("^rocblas.*")
.allowlist_function("^rocblas.*")
.allowlist_var("^rocblas.*")
.must_use_type("rocblas_status")
.constified_enum("rocblas_status_")
.new_type_alias("^rocblas_handle$")
.clang_args(["-I/opt/rocm/include", "-D__HIP_PLATFORM_AMD__"])
.generate()
.unwrap()
.to_string();
let mut module: syn::File = syn::parse_str(&rocblas_header).unwrap();
remove_type(&mut module, "hipStream_t");
remove_type(&mut module, "ihipStream_t");
remove_type(&mut module, "hipEvent_t");
remove_type(&mut module, "ihipEvent_t");
let mut converter = ConvertIntoRustResult {
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(),
};
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::ForeignMod(mut extern_) => {
extern_.attrs.push(
parse_quote!(#[cfg_attr(windows, link = "rocblas", kind = "raw-dylib")]),
);
Some(Item::ForeignMod(extern_))
}
item => Some(item),
})
.collect::<Vec<_>>();
converter.flush(&mut module.items);
add_send_sync(&mut module.items, &["rocblas_handle"]);
let mut output = output.clone();
output.extend(path);
let text = &prettyplease::unparse(&module)
.replace("hipStream_t", "hip_runtime_sys::hipStream_t")
.replace("hipEvent_t", "hip_runtime_sys::hipEvent_t");
write_rust_to_file(output, text)
}
fn add_send_sync(items: &mut Vec<Item>, arg: &[&str]) {
for type_ in arg {
let type_ = Ident::new(type_, Span::call_site());
@ -1115,7 +1169,7 @@ impl ConvertIntoRustResult {
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 error_ident = format_ident!("{}", &ident[old_prefix_len..]);
let error_ident = format_ident!("r#{}", &ident[old_prefix_len..]);
let expr = &const_.expr;
result_variants.push(quote! {
const #variant_ident: #type_ = #type_::Err(#new_error_type::#error_ident);