From 869efbe0e2597d130a973d38d0d9bbdb70a67874 Mon Sep 17 00:00:00 2001 From: Andrzej Janik Date: Fri, 7 Jan 2022 04:20:33 +0100 Subject: Move zluda_dump to the new CUDA infrastructure --- Cargo.toml | 2 + cuda_base/Cargo.toml | 14 + cuda_base/README | 1 + cuda_base/src/cuda.rs | 5705 ++++++++++++++++++++++++++++++++++++++++++++ cuda_base/src/lib.rs | 485 ++++ cuda_types/Cargo.toml | 8 + cuda_types/src/lib.rs | 3 + zluda_dump/Cargo.toml | 2 + zluda_dump/src/cuda.rs | 4417 ---------------------------------- zluda_dump/src/dark_api.rs | 92 +- zluda_dump/src/format.rs | 1306 ++++------ zluda_dump/src/lib.rs | 1260 +--------- zluda_dump/src/log.rs | 99 +- zluda_dump/src/os_win.rs | 8 +- zluda_dump/src/trace.rs | 9 +- 15 files changed, 6876 insertions(+), 6535 deletions(-) create mode 100644 cuda_base/Cargo.toml create mode 100644 cuda_base/README create mode 100644 cuda_base/src/cuda.rs create mode 100644 cuda_base/src/lib.rs create mode 100644 cuda_types/Cargo.toml create mode 100644 cuda_types/src/lib.rs delete mode 100644 zluda_dump/src/cuda.rs diff --git a/Cargo.toml b/Cargo.toml index 76f3277..6371981 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,8 @@ [workspace] members = [ + "cuda_base", + "cuda_types", "detours-sys", "hip_runtime-sys", "level_zero-sys", diff --git a/cuda_base/Cargo.toml b/cuda_base/Cargo.toml new file mode 100644 index 0000000..997a426 --- /dev/null +++ b/cuda_base/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "cuda_base" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2018" + +[dependencies] +quote = "1.0" +syn = { version = "1.0", features = ["full", "visit-mut"] } +proc-macro2 = "1.0" +rustc-hash = "1.1.0" + +[lib] +proc-macro = true diff --git a/cuda_base/README b/cuda_base/README new file mode 100644 index 0000000..a284995 --- /dev/null +++ b/cuda_base/README @@ -0,0 +1 @@ +bindgen /usr/local/cuda/include/cuda.h -o src/cuda.rs --with-derive-eq --whitelist-function="^cu.*" --whitelist-var="^CU.*" --size_t-is-usize --default-enum-style=newtype --no-layout-tests --no-doc-comments --no-derive-debug --new-type-alias "^CUdevice_v\d+$|^CUdeviceptr_v\d+$" --must-use-type "cudaError_enum" -- -D__CUDA_API_VERSION_INTERNAL diff --git a/cuda_base/src/cuda.rs b/cuda_base/src/cuda.rs new file mode 100644 index 0000000..a3a67c6 --- /dev/null +++ b/cuda_base/src/cuda.rs @@ -0,0 +1,5705 @@ +/* automatically generated by rust-bindgen 0.59.2 */ + +pub const CUDA_VERSION: u32 = 11050; +pub const CU_IPC_HANDLE_SIZE: u32 = 64; +pub const CU_MEMHOSTALLOC_PORTABLE: u32 = 1; +pub const CU_MEMHOSTALLOC_DEVICEMAP: u32 = 2; +pub const CU_MEMHOSTALLOC_WRITECOMBINED: u32 = 4; +pub const CU_MEMHOSTREGISTER_PORTABLE: u32 = 1; +pub const CU_MEMHOSTREGISTER_DEVICEMAP: u32 = 2; +pub const CU_MEMHOSTREGISTER_IOMEMORY: u32 = 4; +pub const CU_MEMHOSTREGISTER_READ_ONLY: u32 = 8; +pub const CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL: u32 = 1; +pub const CUDA_EXTERNAL_MEMORY_DEDICATED: u32 = 1; +pub const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC: u32 = 1; +pub const CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC: u32 = 2; +pub const CUDA_NVSCISYNC_ATTR_SIGNAL: u32 = 1; +pub const CUDA_NVSCISYNC_ATTR_WAIT: u32 = 2; +pub const CU_MEM_CREATE_USAGE_TILE_POOL: u32 = 1; +pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC: u32 = 1; +pub const CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC: u32 = 2; +pub const CUDA_ARRAY3D_LAYERED: u32 = 1; +pub const CUDA_ARRAY3D_2DARRAY: u32 = 1; +pub const CUDA_ARRAY3D_SURFACE_LDST: u32 = 2; +pub const CUDA_ARRAY3D_CUBEMAP: u32 = 4; +pub const CUDA_ARRAY3D_TEXTURE_GATHER: u32 = 8; +pub const CUDA_ARRAY3D_DEPTH_TEXTURE: u32 = 16; +pub const CUDA_ARRAY3D_COLOR_ATTACHMENT: u32 = 32; +pub const CUDA_ARRAY3D_SPARSE: u32 = 64; +pub const CU_TRSA_OVERRIDE_FORMAT: u32 = 1; +pub const CU_TRSF_READ_AS_INTEGER: u32 = 1; +pub const CU_TRSF_NORMALIZED_COORDINATES: u32 = 2; +pub const CU_TRSF_SRGB: u32 = 16; +pub const CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION: u32 = 32; +pub const CU_PARAM_TR_DEFAULT: i32 = -1; +pub type cuuint32_t = u32; +pub type cuuint64_t = u64; +#[repr(transparent)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUdeviceptr_v2(pub ::std::os::raw::c_ulonglong); +pub type CUdeviceptr = CUdeviceptr_v2; +#[repr(transparent)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUdevice_v1(pub ::std::os::raw::c_int); +pub type CUdevice = CUdevice_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUctx_st { + _unused: [u8; 0], +} +pub type CUcontext = *mut CUctx_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUmod_st { + _unused: [u8; 0], +} +pub type CUmodule = *mut CUmod_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUfunc_st { + _unused: [u8; 0], +} +pub type CUfunction = *mut CUfunc_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUarray_st { + _unused: [u8; 0], +} +pub type CUarray = *mut CUarray_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUmipmappedArray_st { + _unused: [u8; 0], +} +pub type CUmipmappedArray = *mut CUmipmappedArray_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUtexref_st { + _unused: [u8; 0], +} +pub type CUtexref = *mut CUtexref_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUsurfref_st { + _unused: [u8; 0], +} +pub type CUsurfref = *mut CUsurfref_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUevent_st { + _unused: [u8; 0], +} +pub type CUevent = *mut CUevent_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUstream_st { + _unused: [u8; 0], +} +pub type CUstream = *mut CUstream_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUgraphicsResource_st { + _unused: [u8; 0], +} +pub type CUgraphicsResource = *mut CUgraphicsResource_st; +pub type CUtexObject_v1 = ::std::os::raw::c_ulonglong; +pub type CUtexObject = CUtexObject_v1; +pub type CUsurfObject_v1 = ::std::os::raw::c_ulonglong; +pub type CUsurfObject = CUsurfObject_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUextMemory_st { + _unused: [u8; 0], +} +pub type CUexternalMemory = *mut CUextMemory_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUextSemaphore_st { + _unused: [u8; 0], +} +pub type CUexternalSemaphore = *mut CUextSemaphore_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUgraph_st { + _unused: [u8; 0], +} +pub type CUgraph = *mut CUgraph_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUgraphNode_st { + _unused: [u8; 0], +} +pub type CUgraphNode = *mut CUgraphNode_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUgraphExec_st { + _unused: [u8; 0], +} +pub type CUgraphExec = *mut CUgraphExec_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUmemPoolHandle_st { + _unused: [u8; 0], +} +pub type CUmemoryPool = *mut CUmemPoolHandle_st; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUuserObject_st { + _unused: [u8; 0], +} +pub type CUuserObject = *mut CUuserObject_st; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUuuid_st { + pub bytes: [::std::os::raw::c_char; 16usize], +} +pub type CUuuid = CUuuid_st; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUipcEventHandle_st { + pub reserved: [::std::os::raw::c_char; 64usize], +} +pub type CUipcEventHandle_v1 = CUipcEventHandle_st; +pub type CUipcEventHandle = CUipcEventHandle_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUipcMemHandle_st { + pub reserved: [::std::os::raw::c_char; 64usize], +} +pub type CUipcMemHandle_v1 = CUipcMemHandle_st; +pub type CUipcMemHandle = CUipcMemHandle_v1; +impl CUstreamBatchMemOpType_enum { + pub const CU_STREAM_MEM_OP_WAIT_VALUE_32: CUstreamBatchMemOpType_enum = + CUstreamBatchMemOpType_enum(1); +} +impl CUstreamBatchMemOpType_enum { + pub const CU_STREAM_MEM_OP_WRITE_VALUE_32: CUstreamBatchMemOpType_enum = + CUstreamBatchMemOpType_enum(2); +} +impl CUstreamBatchMemOpType_enum { + pub const CU_STREAM_MEM_OP_WAIT_VALUE_64: CUstreamBatchMemOpType_enum = + CUstreamBatchMemOpType_enum(4); +} +impl CUstreamBatchMemOpType_enum { + pub const CU_STREAM_MEM_OP_WRITE_VALUE_64: CUstreamBatchMemOpType_enum = + CUstreamBatchMemOpType_enum(5); +} +impl CUstreamBatchMemOpType_enum { + pub const CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES: CUstreamBatchMemOpType_enum = + CUstreamBatchMemOpType_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUstreamBatchMemOpType_enum(pub ::std::os::raw::c_uint); +pub use self::CUstreamBatchMemOpType_enum as CUstreamBatchMemOpType; +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUstreamBatchMemOpParams_union { + pub operation: CUstreamBatchMemOpType, + pub waitValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st, + pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st, + pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st, + pub pad: [cuuint64_t; 6usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st { + pub operation: CUstreamBatchMemOpType, + pub address: CUdeviceptr, + pub __bindgen_anon_1: + CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, + pub alias: CUdeviceptr, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 { + pub value: cuuint32_t, + pub value64: cuuint64_t, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st { + pub operation: CUstreamBatchMemOpType, + pub address: CUdeviceptr, + pub __bindgen_anon_1: + CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, + pub alias: CUdeviceptr, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 { + pub value: cuuint32_t, + pub value64: cuuint64_t, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st { + pub operation: CUstreamBatchMemOpType, + pub flags: ::std::os::raw::c_uint, +} +pub type CUstreamBatchMemOpParams_v1 = CUstreamBatchMemOpParams_union; +pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_v1; +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNSIGNED_INT8: CUarray_format_enum = CUarray_format_enum(1); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNSIGNED_INT16: CUarray_format_enum = CUarray_format_enum(2); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNSIGNED_INT32: CUarray_format_enum = CUarray_format_enum(3); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SIGNED_INT8: CUarray_format_enum = CUarray_format_enum(8); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SIGNED_INT16: CUarray_format_enum = CUarray_format_enum(9); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SIGNED_INT32: CUarray_format_enum = CUarray_format_enum(10); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_HALF: CUarray_format_enum = CUarray_format_enum(16); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_FLOAT: CUarray_format_enum = CUarray_format_enum(32); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_NV12: CUarray_format_enum = CUarray_format_enum(176); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT8X1: CUarray_format_enum = CUarray_format_enum(192); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT8X2: CUarray_format_enum = CUarray_format_enum(193); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT8X4: CUarray_format_enum = CUarray_format_enum(194); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT16X1: CUarray_format_enum = CUarray_format_enum(195); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT16X2: CUarray_format_enum = CUarray_format_enum(196); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_UNORM_INT16X4: CUarray_format_enum = CUarray_format_enum(197); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT8X1: CUarray_format_enum = CUarray_format_enum(198); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT8X2: CUarray_format_enum = CUarray_format_enum(199); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT8X4: CUarray_format_enum = CUarray_format_enum(200); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT16X1: CUarray_format_enum = CUarray_format_enum(201); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT16X2: CUarray_format_enum = CUarray_format_enum(202); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_SNORM_INT16X4: CUarray_format_enum = CUarray_format_enum(203); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC1_UNORM: CUarray_format_enum = CUarray_format_enum(145); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC1_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(146); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC2_UNORM: CUarray_format_enum = CUarray_format_enum(147); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC2_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(148); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC3_UNORM: CUarray_format_enum = CUarray_format_enum(149); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC3_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(150); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC4_UNORM: CUarray_format_enum = CUarray_format_enum(151); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC4_SNORM: CUarray_format_enum = CUarray_format_enum(152); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC5_UNORM: CUarray_format_enum = CUarray_format_enum(153); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC5_SNORM: CUarray_format_enum = CUarray_format_enum(154); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC6H_UF16: CUarray_format_enum = CUarray_format_enum(155); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC6H_SF16: CUarray_format_enum = CUarray_format_enum(156); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC7_UNORM: CUarray_format_enum = CUarray_format_enum(157); +} +impl CUarray_format_enum { + pub const CU_AD_FORMAT_BC7_UNORM_SRGB: CUarray_format_enum = CUarray_format_enum(158); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUarray_format_enum(pub ::std::os::raw::c_uint); +pub use self::CUarray_format_enum as CUarray_format; +impl CUaddress_mode_enum { + pub const CU_TR_ADDRESS_MODE_WRAP: CUaddress_mode_enum = CUaddress_mode_enum(0); +} +impl CUaddress_mode_enum { + pub const CU_TR_ADDRESS_MODE_CLAMP: CUaddress_mode_enum = CUaddress_mode_enum(1); +} +impl CUaddress_mode_enum { + pub const CU_TR_ADDRESS_MODE_MIRROR: CUaddress_mode_enum = CUaddress_mode_enum(2); +} +impl CUaddress_mode_enum { + pub const CU_TR_ADDRESS_MODE_BORDER: CUaddress_mode_enum = CUaddress_mode_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUaddress_mode_enum(pub ::std::os::raw::c_uint); +pub use self::CUaddress_mode_enum as CUaddress_mode; +impl CUfilter_mode_enum { + pub const CU_TR_FILTER_MODE_POINT: CUfilter_mode_enum = CUfilter_mode_enum(0); +} +impl CUfilter_mode_enum { + pub const CU_TR_FILTER_MODE_LINEAR: CUfilter_mode_enum = CUfilter_mode_enum(1); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUfilter_mode_enum(pub ::std::os::raw::c_uint); +pub use self::CUfilter_mode_enum as CUfilter_mode; +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(1); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X: CUdevice_attribute_enum = + CUdevice_attribute_enum(2); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y: CUdevice_attribute_enum = + CUdevice_attribute_enum(3); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z: CUdevice_attribute_enum = + CUdevice_attribute_enum(4); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X: CUdevice_attribute_enum = + CUdevice_attribute_enum(5); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y: CUdevice_attribute_enum = + CUdevice_attribute_enum(6); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z: CUdevice_attribute_enum = + CUdevice_attribute_enum(7); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(8); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(8); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY: CUdevice_attribute_enum = + CUdevice_attribute_enum(9); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_WARP_SIZE: CUdevice_attribute_enum = CUdevice_attribute_enum(10); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_PITCH: CUdevice_attribute_enum = CUdevice_attribute_enum(11); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(12); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(12); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CLOCK_RATE: CUdevice_attribute_enum = CUdevice_attribute_enum(13); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT: CUdevice_attribute_enum = + CUdevice_attribute_enum(14); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GPU_OVERLAP: CUdevice_attribute_enum = + CUdevice_attribute_enum(15); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT: CUdevice_attribute_enum = + CUdevice_attribute_enum(16); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT: CUdevice_attribute_enum = + CUdevice_attribute_enum(17); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_INTEGRATED: CUdevice_attribute_enum = CUdevice_attribute_enum(18); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY: CUdevice_attribute_enum = + CUdevice_attribute_enum(19); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COMPUTE_MODE: CUdevice_attribute_enum = + CUdevice_attribute_enum(20); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(21); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(22); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(23); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(24); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(25); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(26); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(27); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(28); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(29); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(27); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(28); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES: CUdevice_attribute_enum = + CUdevice_attribute_enum(29); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT: CUdevice_attribute_enum = + CUdevice_attribute_enum(30); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS: CUdevice_attribute_enum = + CUdevice_attribute_enum(31); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_ECC_ENABLED: CUdevice_attribute_enum = + CUdevice_attribute_enum(32); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_PCI_BUS_ID: CUdevice_attribute_enum = CUdevice_attribute_enum(33); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: CUdevice_attribute_enum = + CUdevice_attribute_enum(34); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_TCC_DRIVER: CUdevice_attribute_enum = CUdevice_attribute_enum(35); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: CUdevice_attribute_enum = + CUdevice_attribute_enum(36); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(37); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: CUdevice_attribute_enum = + CUdevice_attribute_enum(38); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(39); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT: CUdevice_attribute_enum = + CUdevice_attribute_enum(40); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: CUdevice_attribute_enum = + CUdevice_attribute_enum(41); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(42); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(43); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER: CUdevice_attribute_enum = + CUdevice_attribute_enum(44); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(45); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(46); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: CUdevice_attribute_enum = + CUdevice_attribute_enum(47); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: CUdevice_attribute_enum = + CUdevice_attribute_enum(48); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: CUdevice_attribute_enum = + CUdevice_attribute_enum(49); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID: CUdevice_attribute_enum = + CUdevice_attribute_enum(50); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT: CUdevice_attribute_enum = + CUdevice_attribute_enum(51); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(52); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(53); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(54); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(55); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(56); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(57); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(58); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(59); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(60); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(61); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(62); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(63); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(64); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(65); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(66); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(67); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS: CUdevice_attribute_enum = + CUdevice_attribute_enum(68); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(69); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(70); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(71); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH: CUdevice_attribute_enum = + CUdevice_attribute_enum(72); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(73); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT: CUdevice_attribute_enum = + CUdevice_attribute_enum(74); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(75); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(76); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: CUdevice_attribute_enum = + CUdevice_attribute_enum(77); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(78); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(79); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(80); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(81); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(82); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: CUdevice_attribute_enum = + CUdevice_attribute_enum(83); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: CUdevice_attribute_enum = + CUdevice_attribute_enum(84); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: CUdevice_attribute_enum = + CUdevice_attribute_enum(85); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(86); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: CUdevice_attribute_enum = + CUdevice_attribute_enum(87); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: CUdevice_attribute_enum = + CUdevice_attribute_enum(88); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: CUdevice_attribute_enum = + CUdevice_attribute_enum(89); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(90); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: CUdevice_attribute_enum = + CUdevice_attribute_enum(91); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS: CUdevice_attribute_enum = + CUdevice_attribute_enum(92); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS: CUdevice_attribute_enum = + CUdevice_attribute_enum(93); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(94); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH: CUdevice_attribute_enum = + CUdevice_attribute_enum(95); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH: CUdevice_attribute_enum = + CUdevice_attribute_enum(96); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: CUdevice_attribute_enum = + CUdevice_attribute_enum(97); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES: CUdevice_attribute_enum = + CUdevice_attribute_enum(98); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(99); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES: + CUdevice_attribute_enum = CUdevice_attribute_enum(100); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST: CUdevice_attribute_enum = + CUdevice_attribute_enum(101); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(102); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(102); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED: + CUdevice_attribute_enum = CUdevice_attribute_enum(103); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(104); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(105); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = + CUdevice_attribute_enum(106); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(107); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE: CUdevice_attribute_enum = + CUdevice_attribute_enum(108); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE: CUdevice_attribute_enum = + CUdevice_attribute_enum(109); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(110); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = + CUdevice_attribute_enum(111); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(112); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(113); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(114); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(115); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED: CUdevice_attribute_enum = + CUdevice_attribute_enum(116); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS: CUdevice_attribute_enum = + CUdevice_attribute_enum(117); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING: CUdevice_attribute_enum = + CUdevice_attribute_enum(118); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES: CUdevice_attribute_enum = + CUdevice_attribute_enum(119); +} +impl CUdevice_attribute_enum { + pub const CU_DEVICE_ATTRIBUTE_MAX: CUdevice_attribute_enum = CUdevice_attribute_enum(120); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUdevice_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUdevice_attribute_enum as CUdevice_attribute; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUdevprop_st { + pub maxThreadsPerBlock: ::std::os::raw::c_int, + pub maxThreadsDim: [::std::os::raw::c_int; 3usize], + pub maxGridSize: [::std::os::raw::c_int; 3usize], + pub sharedMemPerBlock: ::std::os::raw::c_int, + pub totalConstantMemory: ::std::os::raw::c_int, + pub SIMDWidth: ::std::os::raw::c_int, + pub memPitch: ::std::os::raw::c_int, + pub regsPerBlock: ::std::os::raw::c_int, + pub clockRate: ::std::os::raw::c_int, + pub textureAlign: ::std::os::raw::c_int, +} +pub type CUdevprop_v1 = CUdevprop_st; +pub type CUdevprop = CUdevprop_v1; +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_CONTEXT: CUpointer_attribute_enum = CUpointer_attribute_enum(1); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_MEMORY_TYPE: CUpointer_attribute_enum = + CUpointer_attribute_enum(2); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_DEVICE_POINTER: CUpointer_attribute_enum = + CUpointer_attribute_enum(3); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_HOST_POINTER: CUpointer_attribute_enum = + CUpointer_attribute_enum(4); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_P2P_TOKENS: CUpointer_attribute_enum = + CUpointer_attribute_enum(5); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: CUpointer_attribute_enum = + CUpointer_attribute_enum(6); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_BUFFER_ID: CUpointer_attribute_enum = + CUpointer_attribute_enum(7); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_IS_MANAGED: CUpointer_attribute_enum = + CUpointer_attribute_enum(8); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL: CUpointer_attribute_enum = + CUpointer_attribute_enum(9); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE: CUpointer_attribute_enum = + CUpointer_attribute_enum(10); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_RANGE_START_ADDR: CUpointer_attribute_enum = + CUpointer_attribute_enum(11); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_RANGE_SIZE: CUpointer_attribute_enum = + CUpointer_attribute_enum(12); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_MAPPED: CUpointer_attribute_enum = CUpointer_attribute_enum(13); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES: CUpointer_attribute_enum = + CUpointer_attribute_enum(14); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE: CUpointer_attribute_enum = + CUpointer_attribute_enum(15); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_ACCESS_FLAGS: CUpointer_attribute_enum = + CUpointer_attribute_enum(16); +} +impl CUpointer_attribute_enum { + pub const CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE: CUpointer_attribute_enum = + CUpointer_attribute_enum(17); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUpointer_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUpointer_attribute_enum as CUpointer_attribute; +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: CUfunction_attribute_enum = + CUfunction_attribute_enum(0); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: CUfunction_attribute_enum = + CUfunction_attribute_enum(1); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: CUfunction_attribute_enum = + CUfunction_attribute_enum(2); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: CUfunction_attribute_enum = + CUfunction_attribute_enum(3); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_NUM_REGS: CUfunction_attribute_enum = CUfunction_attribute_enum(4); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_PTX_VERSION: CUfunction_attribute_enum = + CUfunction_attribute_enum(5); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_BINARY_VERSION: CUfunction_attribute_enum = + CUfunction_attribute_enum(6); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_CACHE_MODE_CA: CUfunction_attribute_enum = + CUfunction_attribute_enum(7); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: CUfunction_attribute_enum = + CUfunction_attribute_enum(8); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: CUfunction_attribute_enum = + CUfunction_attribute_enum(9); +} +impl CUfunction_attribute_enum { + pub const CU_FUNC_ATTRIBUTE_MAX: CUfunction_attribute_enum = CUfunction_attribute_enum(10); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUfunction_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUfunction_attribute_enum as CUfunction_attribute; +impl CUfunc_cache_enum { + pub const CU_FUNC_CACHE_PREFER_NONE: CUfunc_cache_enum = CUfunc_cache_enum(0); +} +impl CUfunc_cache_enum { + pub const CU_FUNC_CACHE_PREFER_SHARED: CUfunc_cache_enum = CUfunc_cache_enum(1); +} +impl CUfunc_cache_enum { + pub const CU_FUNC_CACHE_PREFER_L1: CUfunc_cache_enum = CUfunc_cache_enum(2); +} +impl CUfunc_cache_enum { + pub const CU_FUNC_CACHE_PREFER_EQUAL: CUfunc_cache_enum = CUfunc_cache_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUfunc_cache_enum(pub ::std::os::raw::c_uint); +pub use self::CUfunc_cache_enum as CUfunc_cache; +impl CUsharedconfig_enum { + pub const CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: CUsharedconfig_enum = CUsharedconfig_enum(0); +} +impl CUsharedconfig_enum { + pub const CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: CUsharedconfig_enum = + CUsharedconfig_enum(1); +} +impl CUsharedconfig_enum { + pub const CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: CUsharedconfig_enum = + CUsharedconfig_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUsharedconfig_enum(pub ::std::os::raw::c_uint); +pub use self::CUsharedconfig_enum as CUsharedconfig; +impl CUmemorytype_enum { + pub const CU_MEMORYTYPE_HOST: CUmemorytype_enum = CUmemorytype_enum(1); +} +impl CUmemorytype_enum { + pub const CU_MEMORYTYPE_DEVICE: CUmemorytype_enum = CUmemorytype_enum(2); +} +impl CUmemorytype_enum { + pub const CU_MEMORYTYPE_ARRAY: CUmemorytype_enum = CUmemorytype_enum(3); +} +impl CUmemorytype_enum { + pub const CU_MEMORYTYPE_UNIFIED: CUmemorytype_enum = CUmemorytype_enum(4); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemorytype_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemorytype_enum as CUmemorytype; +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_SET_READ_MOSTLY: CUmem_advise_enum = CUmem_advise_enum(1); +} +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_UNSET_READ_MOSTLY: CUmem_advise_enum = CUmem_advise_enum(2); +} +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_SET_PREFERRED_LOCATION: CUmem_advise_enum = CUmem_advise_enum(3); +} +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: CUmem_advise_enum = CUmem_advise_enum(4); +} +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_SET_ACCESSED_BY: CUmem_advise_enum = CUmem_advise_enum(5); +} +impl CUmem_advise_enum { + pub const CU_MEM_ADVISE_UNSET_ACCESSED_BY: CUmem_advise_enum = CUmem_advise_enum(6); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmem_advise_enum(pub ::std::os::raw::c_uint); +pub use self::CUmem_advise_enum as CUmem_advise; +impl CUmem_range_attribute_enum { + pub const CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: CUmem_range_attribute_enum = + CUmem_range_attribute_enum(1); +} +impl CUmem_range_attribute_enum { + pub const CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: CUmem_range_attribute_enum = + CUmem_range_attribute_enum(2); +} +impl CUmem_range_attribute_enum { + pub const CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: CUmem_range_attribute_enum = + CUmem_range_attribute_enum(3); +} +impl CUmem_range_attribute_enum { + pub const CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: CUmem_range_attribute_enum = + CUmem_range_attribute_enum(4); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmem_range_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUmem_range_attribute_enum as CUmem_range_attribute; +impl CUjit_option_enum { + pub const CU_JIT_MAX_REGISTERS: CUjit_option_enum = CUjit_option_enum(0); +} +impl CUjit_option_enum { + pub const CU_JIT_THREADS_PER_BLOCK: CUjit_option_enum = CUjit_option_enum(1); +} +impl CUjit_option_enum { + pub const CU_JIT_WALL_TIME: CUjit_option_enum = CUjit_option_enum(2); +} +impl CUjit_option_enum { + pub const CU_JIT_INFO_LOG_BUFFER: CUjit_option_enum = CUjit_option_enum(3); +} +impl CUjit_option_enum { + pub const CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES: CUjit_option_enum = CUjit_option_enum(4); +} +impl CUjit_option_enum { + pub const CU_JIT_ERROR_LOG_BUFFER: CUjit_option_enum = CUjit_option_enum(5); +} +impl CUjit_option_enum { + pub const CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES: CUjit_option_enum = CUjit_option_enum(6); +} +impl CUjit_option_enum { + pub const CU_JIT_OPTIMIZATION_LEVEL: CUjit_option_enum = CUjit_option_enum(7); +} +impl CUjit_option_enum { + pub const CU_JIT_TARGET_FROM_CUCONTEXT: CUjit_option_enum = CUjit_option_enum(8); +} +impl CUjit_option_enum { + pub const CU_JIT_TARGET: CUjit_option_enum = CUjit_option_enum(9); +} +impl CUjit_option_enum { + pub const CU_JIT_FALLBACK_STRATEGY: CUjit_option_enum = CUjit_option_enum(10); +} +impl CUjit_option_enum { + pub const CU_JIT_GENERATE_DEBUG_INFO: CUjit_option_enum = CUjit_option_enum(11); +} +impl CUjit_option_enum { + pub const CU_JIT_LOG_VERBOSE: CUjit_option_enum = CUjit_option_enum(12); +} +impl CUjit_option_enum { + pub const CU_JIT_GENERATE_LINE_INFO: CUjit_option_enum = CUjit_option_enum(13); +} +impl CUjit_option_enum { + pub const CU_JIT_CACHE_MODE: CUjit_option_enum = CUjit_option_enum(14); +} +impl CUjit_option_enum { + pub const CU_JIT_NEW_SM3X_OPT: CUjit_option_enum = CUjit_option_enum(15); +} +impl CUjit_option_enum { + pub const CU_JIT_FAST_COMPILE: CUjit_option_enum = CUjit_option_enum(16); +} +impl CUjit_option_enum { + pub const CU_JIT_GLOBAL_SYMBOL_NAMES: CUjit_option_enum = CUjit_option_enum(17); +} +impl CUjit_option_enum { + pub const CU_JIT_GLOBAL_SYMBOL_ADDRESSES: CUjit_option_enum = CUjit_option_enum(18); +} +impl CUjit_option_enum { + pub const CU_JIT_GLOBAL_SYMBOL_COUNT: CUjit_option_enum = CUjit_option_enum(19); +} +impl CUjit_option_enum { + pub const CU_JIT_LTO: CUjit_option_enum = CUjit_option_enum(20); +} +impl CUjit_option_enum { + pub const CU_JIT_FTZ: CUjit_option_enum = CUjit_option_enum(21); +} +impl CUjit_option_enum { + pub const CU_JIT_PREC_DIV: CUjit_option_enum = CUjit_option_enum(22); +} +impl CUjit_option_enum { + pub const CU_JIT_PREC_SQRT: CUjit_option_enum = CUjit_option_enum(23); +} +impl CUjit_option_enum { + pub const CU_JIT_FMA: CUjit_option_enum = CUjit_option_enum(24); +} +impl CUjit_option_enum { + pub const CU_JIT_NUM_OPTIONS: CUjit_option_enum = CUjit_option_enum(25); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUjit_option_enum(pub ::std::os::raw::c_uint); +pub use self::CUjit_option_enum as CUjit_option; +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_CUBIN: CUjitInputType_enum = CUjitInputType_enum(0); +} +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_PTX: CUjitInputType_enum = CUjitInputType_enum(1); +} +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_FATBINARY: CUjitInputType_enum = CUjitInputType_enum(2); +} +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_OBJECT: CUjitInputType_enum = CUjitInputType_enum(3); +} +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_LIBRARY: CUjitInputType_enum = CUjitInputType_enum(4); +} +impl CUjitInputType_enum { + pub const CU_JIT_INPUT_NVVM: CUjitInputType_enum = CUjitInputType_enum(5); +} +impl CUjitInputType_enum { + pub const CU_JIT_NUM_INPUT_TYPES: CUjitInputType_enum = CUjitInputType_enum(6); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUjitInputType_enum(pub ::std::os::raw::c_uint); +pub use self::CUjitInputType_enum as CUjitInputType; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUlinkState_st { + _unused: [u8; 0], +} +pub type CUlinkState = *mut CUlinkState_st; +impl CUlimit_enum { + pub const CU_LIMIT_STACK_SIZE: CUlimit_enum = CUlimit_enum(0); +} +impl CUlimit_enum { + pub const CU_LIMIT_PRINTF_FIFO_SIZE: CUlimit_enum = CUlimit_enum(1); +} +impl CUlimit_enum { + pub const CU_LIMIT_MALLOC_HEAP_SIZE: CUlimit_enum = CUlimit_enum(2); +} +impl CUlimit_enum { + pub const CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH: CUlimit_enum = CUlimit_enum(3); +} +impl CUlimit_enum { + pub const CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT: CUlimit_enum = CUlimit_enum(4); +} +impl CUlimit_enum { + pub const CU_LIMIT_MAX_L2_FETCH_GRANULARITY: CUlimit_enum = CUlimit_enum(5); +} +impl CUlimit_enum { + pub const CU_LIMIT_PERSISTING_L2_CACHE_SIZE: CUlimit_enum = CUlimit_enum(6); +} +impl CUlimit_enum { + pub const CU_LIMIT_MAX: CUlimit_enum = CUlimit_enum(7); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUlimit_enum(pub ::std::os::raw::c_uint); +pub use self::CUlimit_enum as CUlimit; +impl CUresourcetype_enum { + pub const CU_RESOURCE_TYPE_ARRAY: CUresourcetype_enum = CUresourcetype_enum(0); +} +impl CUresourcetype_enum { + pub const CU_RESOURCE_TYPE_MIPMAPPED_ARRAY: CUresourcetype_enum = CUresourcetype_enum(1); +} +impl CUresourcetype_enum { + pub const CU_RESOURCE_TYPE_LINEAR: CUresourcetype_enum = CUresourcetype_enum(2); +} +impl CUresourcetype_enum { + pub const CU_RESOURCE_TYPE_PITCH2D: CUresourcetype_enum = CUresourcetype_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUresourcetype_enum(pub ::std::os::raw::c_uint); +pub use self::CUresourcetype_enum as CUresourcetype; +pub type CUhostFn = + ::std::option::Option; +impl CUaccessProperty_enum { + pub const CU_ACCESS_PROPERTY_NORMAL: CUaccessProperty_enum = CUaccessProperty_enum(0); +} +impl CUaccessProperty_enum { + pub const CU_ACCESS_PROPERTY_STREAMING: CUaccessProperty_enum = CUaccessProperty_enum(1); +} +impl CUaccessProperty_enum { + pub const CU_ACCESS_PROPERTY_PERSISTING: CUaccessProperty_enum = CUaccessProperty_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUaccessProperty_enum(pub ::std::os::raw::c_uint); +pub use self::CUaccessProperty_enum as CUaccessProperty; +#[repr(C)] +#[derive(Copy, Clone, PartialEq)] +pub struct CUaccessPolicyWindow_st { + pub base_ptr: *mut ::std::os::raw::c_void, + pub num_bytes: usize, + pub hitRatio: f32, + pub hitProp: CUaccessProperty, + pub missProp: CUaccessProperty, +} +pub type CUaccessPolicyWindow_v1 = CUaccessPolicyWindow_st; +pub type CUaccessPolicyWindow = CUaccessPolicyWindow_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_KERNEL_NODE_PARAMS_st { + pub func: CUfunction, + pub gridDimX: ::std::os::raw::c_uint, + pub gridDimY: ::std::os::raw::c_uint, + pub gridDimZ: ::std::os::raw::c_uint, + pub blockDimX: ::std::os::raw::c_uint, + pub blockDimY: ::std::os::raw::c_uint, + pub blockDimZ: ::std::os::raw::c_uint, + pub sharedMemBytes: ::std::os::raw::c_uint, + pub kernelParams: *mut *mut ::std::os::raw::c_void, + pub extra: *mut *mut ::std::os::raw::c_void, +} +pub type CUDA_KERNEL_NODE_PARAMS_v1 = CUDA_KERNEL_NODE_PARAMS_st; +pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMSET_NODE_PARAMS_st { + pub dst: CUdeviceptr, + pub pitch: usize, + pub value: ::std::os::raw::c_uint, + pub elementSize: ::std::os::raw::c_uint, + pub width: usize, + pub height: usize, +} +pub type CUDA_MEMSET_NODE_PARAMS_v1 = CUDA_MEMSET_NODE_PARAMS_st; +pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_HOST_NODE_PARAMS_st { + pub fn_: CUhostFn, + pub userData: *mut ::std::os::raw::c_void, +} +pub type CUDA_HOST_NODE_PARAMS_v1 = CUDA_HOST_NODE_PARAMS_st; +pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_v1; +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_KERNEL: CUgraphNodeType_enum = CUgraphNodeType_enum(0); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_MEMCPY: CUgraphNodeType_enum = CUgraphNodeType_enum(1); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_MEMSET: CUgraphNodeType_enum = CUgraphNodeType_enum(2); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_HOST: CUgraphNodeType_enum = CUgraphNodeType_enum(3); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_GRAPH: CUgraphNodeType_enum = CUgraphNodeType_enum(4); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_EMPTY: CUgraphNodeType_enum = CUgraphNodeType_enum(5); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_WAIT_EVENT: CUgraphNodeType_enum = CUgraphNodeType_enum(6); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_EVENT_RECORD: CUgraphNodeType_enum = CUgraphNodeType_enum(7); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL: CUgraphNodeType_enum = CUgraphNodeType_enum(8); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT: CUgraphNodeType_enum = CUgraphNodeType_enum(9); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_MEM_ALLOC: CUgraphNodeType_enum = CUgraphNodeType_enum(10); +} +impl CUgraphNodeType_enum { + pub const CU_GRAPH_NODE_TYPE_MEM_FREE: CUgraphNodeType_enum = CUgraphNodeType_enum(11); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUgraphNodeType_enum(pub ::std::os::raw::c_uint); +pub use self::CUgraphNodeType_enum as CUgraphNodeType; +impl CUsynchronizationPolicy_enum { + pub const CU_SYNC_POLICY_AUTO: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(1); +} +impl CUsynchronizationPolicy_enum { + pub const CU_SYNC_POLICY_SPIN: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(2); +} +impl CUsynchronizationPolicy_enum { + pub const CU_SYNC_POLICY_YIELD: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(3); +} +impl CUsynchronizationPolicy_enum { + pub const CU_SYNC_POLICY_BLOCKING_SYNC: CUsynchronizationPolicy_enum = + CUsynchronizationPolicy_enum(4); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUsynchronizationPolicy_enum(pub ::std::os::raw::c_uint); +pub use self::CUsynchronizationPolicy_enum as CUsynchronizationPolicy; +impl CUkernelNodeAttrID_enum { + pub const CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW: CUkernelNodeAttrID_enum = + CUkernelNodeAttrID_enum(1); +} +impl CUkernelNodeAttrID_enum { + pub const CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE: CUkernelNodeAttrID_enum = + CUkernelNodeAttrID_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUkernelNodeAttrID_enum(pub ::std::os::raw::c_uint); +pub use self::CUkernelNodeAttrID_enum as CUkernelNodeAttrID; +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUkernelNodeAttrValue_union { + pub accessPolicyWindow: CUaccessPolicyWindow, + pub cooperative: ::std::os::raw::c_int, +} +pub type CUkernelNodeAttrValue_v1 = CUkernelNodeAttrValue_union; +pub type CUkernelNodeAttrValue = CUkernelNodeAttrValue_v1; +impl CUstreamCaptureStatus_enum { + pub const CU_STREAM_CAPTURE_STATUS_NONE: CUstreamCaptureStatus_enum = + CUstreamCaptureStatus_enum(0); +} +impl CUstreamCaptureStatus_enum { + pub const CU_STREAM_CAPTURE_STATUS_ACTIVE: CUstreamCaptureStatus_enum = + CUstreamCaptureStatus_enum(1); +} +impl CUstreamCaptureStatus_enum { + pub const CU_STREAM_CAPTURE_STATUS_INVALIDATED: CUstreamCaptureStatus_enum = + CUstreamCaptureStatus_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUstreamCaptureStatus_enum(pub ::std::os::raw::c_uint); +pub use self::CUstreamCaptureStatus_enum as CUstreamCaptureStatus; +impl CUstreamCaptureMode_enum { + pub const CU_STREAM_CAPTURE_MODE_GLOBAL: CUstreamCaptureMode_enum = CUstreamCaptureMode_enum(0); +} +impl CUstreamCaptureMode_enum { + pub const CU_STREAM_CAPTURE_MODE_THREAD_LOCAL: CUstreamCaptureMode_enum = + CUstreamCaptureMode_enum(1); +} +impl CUstreamCaptureMode_enum { + pub const CU_STREAM_CAPTURE_MODE_RELAXED: CUstreamCaptureMode_enum = + CUstreamCaptureMode_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUstreamCaptureMode_enum(pub ::std::os::raw::c_uint); +pub use self::CUstreamCaptureMode_enum as CUstreamCaptureMode; +impl CUstreamAttrID_enum { + pub const CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW: CUstreamAttrID_enum = + CUstreamAttrID_enum(1); +} +impl CUstreamAttrID_enum { + pub const CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY: CUstreamAttrID_enum = + CUstreamAttrID_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUstreamAttrID_enum(pub ::std::os::raw::c_uint); +pub use self::CUstreamAttrID_enum as CUstreamAttrID; +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUstreamAttrValue_union { + pub accessPolicyWindow: CUaccessPolicyWindow, + pub syncPolicy: CUsynchronizationPolicy, +} +pub type CUstreamAttrValue_v1 = CUstreamAttrValue_union; +pub type CUstreamAttrValue = CUstreamAttrValue_v1; +impl CUexecAffinityType_enum { + pub const CU_EXEC_AFFINITY_TYPE_SM_COUNT: CUexecAffinityType_enum = CUexecAffinityType_enum(0); +} +impl CUexecAffinityType_enum { + pub const CU_EXEC_AFFINITY_TYPE_MAX: CUexecAffinityType_enum = CUexecAffinityType_enum(1); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUexecAffinityType_enum(pub ::std::os::raw::c_uint); +pub use self::CUexecAffinityType_enum as CUexecAffinityType; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUexecAffinitySmCount_st { + pub val: ::std::os::raw::c_uint, +} +pub type CUexecAffinitySmCount_v1 = CUexecAffinitySmCount_st; +pub type CUexecAffinitySmCount = CUexecAffinitySmCount_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUexecAffinityParam_st { + pub type_: CUexecAffinityType, + pub param: CUexecAffinityParam_st__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUexecAffinityParam_st__bindgen_ty_1 { + pub smCount: CUexecAffinitySmCount, +} +pub type CUexecAffinityParam_v1 = CUexecAffinityParam_st; +pub type CUexecAffinityParam = CUexecAffinityParam_v1; +impl cudaError_enum { + pub const CUDA_SUCCESS: cudaError_enum = cudaError_enum(0); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_VALUE: cudaError_enum = cudaError_enum(1); +} +impl cudaError_enum { + pub const CUDA_ERROR_OUT_OF_MEMORY: cudaError_enum = cudaError_enum(2); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_INITIALIZED: cudaError_enum = cudaError_enum(3); +} +impl cudaError_enum { + pub const CUDA_ERROR_DEINITIALIZED: cudaError_enum = cudaError_enum(4); +} +impl cudaError_enum { + pub const CUDA_ERROR_PROFILER_DISABLED: cudaError_enum = cudaError_enum(5); +} +impl cudaError_enum { + pub const CUDA_ERROR_PROFILER_NOT_INITIALIZED: cudaError_enum = cudaError_enum(6); +} +impl cudaError_enum { + pub const CUDA_ERROR_PROFILER_ALREADY_STARTED: cudaError_enum = cudaError_enum(7); +} +impl cudaError_enum { + pub const CUDA_ERROR_PROFILER_ALREADY_STOPPED: cudaError_enum = cudaError_enum(8); +} +impl cudaError_enum { + pub const CUDA_ERROR_STUB_LIBRARY: cudaError_enum = cudaError_enum(34); +} +impl cudaError_enum { + pub const CUDA_ERROR_NO_DEVICE: cudaError_enum = cudaError_enum(100); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_DEVICE: cudaError_enum = cudaError_enum(101); +} +impl cudaError_enum { + pub const CUDA_ERROR_DEVICE_NOT_LICENSED: cudaError_enum = cudaError_enum(102); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_IMAGE: cudaError_enum = cudaError_enum(200); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_CONTEXT: cudaError_enum = cudaError_enum(201); +} +impl cudaError_enum { + pub const CUDA_ERROR_CONTEXT_ALREADY_CURRENT: cudaError_enum = cudaError_enum(202); +} +impl cudaError_enum { + pub const CUDA_ERROR_MAP_FAILED: cudaError_enum = cudaError_enum(205); +} +impl cudaError_enum { + pub const CUDA_ERROR_UNMAP_FAILED: cudaError_enum = cudaError_enum(206); +} +impl cudaError_enum { + pub const CUDA_ERROR_ARRAY_IS_MAPPED: cudaError_enum = cudaError_enum(207); +} +impl cudaError_enum { + pub const CUDA_ERROR_ALREADY_MAPPED: cudaError_enum = cudaError_enum(208); +} +impl cudaError_enum { + pub const CUDA_ERROR_NO_BINARY_FOR_GPU: cudaError_enum = cudaError_enum(209); +} +impl cudaError_enum { + pub const CUDA_ERROR_ALREADY_ACQUIRED: cudaError_enum = cudaError_enum(210); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_MAPPED: cudaError_enum = cudaError_enum(211); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_MAPPED_AS_ARRAY: cudaError_enum = cudaError_enum(212); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_MAPPED_AS_POINTER: cudaError_enum = cudaError_enum(213); +} +impl cudaError_enum { + pub const CUDA_ERROR_ECC_UNCORRECTABLE: cudaError_enum = cudaError_enum(214); +} +impl cudaError_enum { + pub const CUDA_ERROR_UNSUPPORTED_LIMIT: cudaError_enum = cudaError_enum(215); +} +impl cudaError_enum { + pub const CUDA_ERROR_CONTEXT_ALREADY_IN_USE: cudaError_enum = cudaError_enum(216); +} +impl cudaError_enum { + pub const CUDA_ERROR_PEER_ACCESS_UNSUPPORTED: cudaError_enum = cudaError_enum(217); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_PTX: cudaError_enum = cudaError_enum(218); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_GRAPHICS_CONTEXT: cudaError_enum = cudaError_enum(219); +} +impl cudaError_enum { + pub const CUDA_ERROR_NVLINK_UNCORRECTABLE: cudaError_enum = cudaError_enum(220); +} +impl cudaError_enum { + pub const CUDA_ERROR_JIT_COMPILER_NOT_FOUND: cudaError_enum = cudaError_enum(221); +} +impl cudaError_enum { + pub const CUDA_ERROR_UNSUPPORTED_PTX_VERSION: cudaError_enum = cudaError_enum(222); +} +impl cudaError_enum { + pub const CUDA_ERROR_JIT_COMPILATION_DISABLED: cudaError_enum = cudaError_enum(223); +} +impl cudaError_enum { + pub const CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY: cudaError_enum = cudaError_enum(224); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_SOURCE: cudaError_enum = cudaError_enum(300); +} +impl cudaError_enum { + pub const CUDA_ERROR_FILE_NOT_FOUND: cudaError_enum = cudaError_enum(301); +} +impl cudaError_enum { + pub const CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: cudaError_enum = cudaError_enum(302); +} +impl cudaError_enum { + pub const CUDA_ERROR_SHARED_OBJECT_INIT_FAILED: cudaError_enum = cudaError_enum(303); +} +impl cudaError_enum { + pub const CUDA_ERROR_OPERATING_SYSTEM: cudaError_enum = cudaError_enum(304); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_HANDLE: cudaError_enum = cudaError_enum(400); +} +impl cudaError_enum { + pub const CUDA_ERROR_ILLEGAL_STATE: cudaError_enum = cudaError_enum(401); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_FOUND: cudaError_enum = cudaError_enum(500); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_READY: cudaError_enum = cudaError_enum(600); +} +impl cudaError_enum { + pub const CUDA_ERROR_ILLEGAL_ADDRESS: cudaError_enum = cudaError_enum(700); +} +impl cudaError_enum { + pub const CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES: cudaError_enum = cudaError_enum(701); +} +impl cudaError_enum { + pub const CUDA_ERROR_LAUNCH_TIMEOUT: cudaError_enum = cudaError_enum(702); +} +impl cudaError_enum { + pub const CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: cudaError_enum = cudaError_enum(703); +} +impl cudaError_enum { + pub const CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED: cudaError_enum = cudaError_enum(704); +} +impl cudaError_enum { + pub const CUDA_ERROR_PEER_ACCESS_NOT_ENABLED: cudaError_enum = cudaError_enum(705); +} +impl cudaError_enum { + pub const CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE: cudaError_enum = cudaError_enum(708); +} +impl cudaError_enum { + pub const CUDA_ERROR_CONTEXT_IS_DESTROYED: cudaError_enum = cudaError_enum(709); +} +impl cudaError_enum { + pub const CUDA_ERROR_ASSERT: cudaError_enum = cudaError_enum(710); +} +impl cudaError_enum { + pub const CUDA_ERROR_TOO_MANY_PEERS: cudaError_enum = cudaError_enum(711); +} +impl cudaError_enum { + pub const CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED: cudaError_enum = cudaError_enum(712); +} +impl cudaError_enum { + pub const CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED: cudaError_enum = cudaError_enum(713); +} +impl cudaError_enum { + pub const CUDA_ERROR_HARDWARE_STACK_ERROR: cudaError_enum = cudaError_enum(714); +} +impl cudaError_enum { + pub const CUDA_ERROR_ILLEGAL_INSTRUCTION: cudaError_enum = cudaError_enum(715); +} +impl cudaError_enum { + pub const CUDA_ERROR_MISALIGNED_ADDRESS: cudaError_enum = cudaError_enum(716); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_ADDRESS_SPACE: cudaError_enum = cudaError_enum(717); +} +impl cudaError_enum { + pub const CUDA_ERROR_INVALID_PC: cudaError_enum = cudaError_enum(718); +} +impl cudaError_enum { + pub const CUDA_ERROR_LAUNCH_FAILED: cudaError_enum = cudaError_enum(719); +} +impl cudaError_enum { + pub const CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE: cudaError_enum = cudaError_enum(720); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_PERMITTED: cudaError_enum = cudaError_enum(800); +} +impl cudaError_enum { + pub const CUDA_ERROR_NOT_SUPPORTED: cudaError_enum = cudaError_enum(801); +} +impl cudaError_enum { + pub const CUDA_ERROR_SYSTEM_NOT_READY: cudaError_enum = cudaError_enum(802); +} +impl cudaError_enum { + pub const CUDA_ERROR_SYSTEM_DRIVER_MISMATCH: cudaError_enum = cudaError_enum(803); +} +impl cudaError_enum { + pub const CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: cudaError_enum = cudaError_enum(804); +} +impl cudaError_enum { + pub const CUDA_ERROR_MPS_CONNECTION_FAILED: cudaError_enum = cudaError_enum(805); +} +impl cudaError_enum { + pub const CUDA_ERROR_MPS_RPC_FAILURE: cudaError_enum = cudaError_enum(806); +} +impl cudaError_enum { + pub const CUDA_ERROR_MPS_SERVER_NOT_READY: cudaError_enum = cudaError_enum(807); +} +impl cudaError_enum { + pub const CUDA_ERROR_MPS_MAX_CLIENTS_REACHED: cudaError_enum = cudaError_enum(808); +} +impl cudaError_enum { + pub const CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED: cudaError_enum = cudaError_enum(809); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED: cudaError_enum = cudaError_enum(900); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_INVALIDATED: cudaError_enum = cudaError_enum(901); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_MERGE: cudaError_enum = cudaError_enum(902); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_UNMATCHED: cudaError_enum = cudaError_enum(903); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_UNJOINED: cudaError_enum = cudaError_enum(904); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_ISOLATION: cudaError_enum = cudaError_enum(905); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_IMPLICIT: cudaError_enum = cudaError_enum(906); +} +impl cudaError_enum { + pub const CUDA_ERROR_CAPTURED_EVENT: cudaError_enum = cudaError_enum(907); +} +impl cudaError_enum { + pub const CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD: cudaError_enum = cudaError_enum(908); +} +impl cudaError_enum { + pub const CUDA_ERROR_TIMEOUT: cudaError_enum = cudaError_enum(909); +} +impl cudaError_enum { + pub const CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE: cudaError_enum = cudaError_enum(910); +} +impl cudaError_enum { + pub const CUDA_ERROR_EXTERNAL_DEVICE: cudaError_enum = cudaError_enum(911); +} +impl cudaError_enum { + pub const CUDA_ERROR_UNKNOWN: cudaError_enum = cudaError_enum(999); +} +#[repr(transparent)] +#[must_use] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct cudaError_enum(pub ::std::os::raw::c_uint); +pub use self::cudaError_enum as CUresult; +impl CUdevice_P2PAttribute_enum { + pub const CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: CUdevice_P2PAttribute_enum = + CUdevice_P2PAttribute_enum(1); +} +impl CUdevice_P2PAttribute_enum { + pub const CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = + CUdevice_P2PAttribute_enum(2); +} +impl CUdevice_P2PAttribute_enum { + pub const CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: CUdevice_P2PAttribute_enum = + CUdevice_P2PAttribute_enum(3); +} +impl CUdevice_P2PAttribute_enum { + pub const CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = + CUdevice_P2PAttribute_enum(4); +} +impl CUdevice_P2PAttribute_enum { + pub const CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = + CUdevice_P2PAttribute_enum(4); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUdevice_P2PAttribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUdevice_P2PAttribute_enum as CUdevice_P2PAttribute; +pub type CUstreamCallback = ::std::option::Option< + unsafe extern "C" fn( + hStream: CUstream, + status: CUresult, + userData: *mut ::std::os::raw::c_void, + ), +>; +pub type CUoccupancyB2DSize = + ::std::option::Option usize>; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMCPY2D_st { + pub srcXInBytes: usize, + pub srcY: usize, + pub srcMemoryType: CUmemorytype, + pub srcHost: *const ::std::os::raw::c_void, + pub srcDevice: CUdeviceptr, + pub srcArray: CUarray, + pub srcPitch: usize, + pub dstXInBytes: usize, + pub dstY: usize, + pub dstMemoryType: CUmemorytype, + pub dstHost: *mut ::std::os::raw::c_void, + pub dstDevice: CUdeviceptr, + pub dstArray: CUarray, + pub dstPitch: usize, + pub WidthInBytes: usize, + pub Height: usize, +} +pub type CUDA_MEMCPY2D_v2 = CUDA_MEMCPY2D_st; +pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_v2; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMCPY3D_st { + pub srcXInBytes: usize, + pub srcY: usize, + pub srcZ: usize, + pub srcLOD: usize, + pub srcMemoryType: CUmemorytype, + pub srcHost: *const ::std::os::raw::c_void, + pub srcDevice: CUdeviceptr, + pub srcArray: CUarray, + pub reserved0: *mut ::std::os::raw::c_void, + pub srcPitch: usize, + pub srcHeight: usize, + pub dstXInBytes: usize, + pub dstY: usize, + pub dstZ: usize, + pub dstLOD: usize, + pub dstMemoryType: CUmemorytype, + pub dstHost: *mut ::std::os::raw::c_void, + pub dstDevice: CUdeviceptr, + pub dstArray: CUarray, + pub reserved1: *mut ::std::os::raw::c_void, + pub dstPitch: usize, + pub dstHeight: usize, + pub WidthInBytes: usize, + pub Height: usize, + pub Depth: usize, +} +pub type CUDA_MEMCPY3D_v2 = CUDA_MEMCPY3D_st; +pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_v2; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMCPY3D_PEER_st { + pub srcXInBytes: usize, + pub srcY: usize, + pub srcZ: usize, + pub srcLOD: usize, + pub srcMemoryType: CUmemorytype, + pub srcHost: *const ::std::os::raw::c_void, + pub srcDevice: CUdeviceptr, + pub srcArray: CUarray, + pub srcContext: CUcontext, + pub srcPitch: usize, + pub srcHeight: usize, + pub dstXInBytes: usize, + pub dstY: usize, + pub dstZ: usize, + pub dstLOD: usize, + pub dstMemoryType: CUmemorytype, + pub dstHost: *mut ::std::os::raw::c_void, + pub dstDevice: CUdeviceptr, + pub dstArray: CUarray, + pub dstContext: CUcontext, + pub dstPitch: usize, + pub dstHeight: usize, + pub WidthInBytes: usize, + pub Height: usize, + pub Depth: usize, +} +pub type CUDA_MEMCPY3D_PEER_v1 = CUDA_MEMCPY3D_PEER_st; +pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY_DESCRIPTOR_st { + pub Width: usize, + pub Height: usize, + pub Format: CUarray_format, + pub NumChannels: ::std::os::raw::c_uint, +} +pub type CUDA_ARRAY_DESCRIPTOR_v2 = CUDA_ARRAY_DESCRIPTOR_st; +pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_v2; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY3D_DESCRIPTOR_st { + pub Width: usize, + pub Height: usize, + pub Depth: usize, + pub Format: CUarray_format, + pub NumChannels: ::std::os::raw::c_uint, + pub Flags: ::std::os::raw::c_uint, +} +pub type CUDA_ARRAY3D_DESCRIPTOR_v2 = CUDA_ARRAY3D_DESCRIPTOR_st; +pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_v2; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st { + pub tileExtent: CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1, + pub miptailFirstLevel: ::std::os::raw::c_uint, + pub miptailSize: ::std::os::raw::c_ulonglong, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 4usize], +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1 { + pub width: ::std::os::raw::c_uint, + pub height: ::std::os::raw::c_uint, + pub depth: ::std::os::raw::c_uint, +} +pub type CUDA_ARRAY_SPARSE_PROPERTIES_v1 = CUDA_ARRAY_SPARSE_PROPERTIES_st; +pub type CUDA_ARRAY_SPARSE_PROPERTIES = CUDA_ARRAY_SPARSE_PROPERTIES_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_RESOURCE_DESC_st { + pub resType: CUresourcetype, + pub res: CUDA_RESOURCE_DESC_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 { + pub array: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1, + pub mipmap: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2, + pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3, + pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4, + pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 { + pub hArray: CUarray, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 { + pub hMipmappedArray: CUmipmappedArray, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 { + pub devPtr: CUdeviceptr, + pub format: CUarray_format, + pub numChannels: ::std::os::raw::c_uint, + pub sizeInBytes: usize, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 { + pub devPtr: CUdeviceptr, + pub format: CUarray_format, + pub numChannels: ::std::os::raw::c_uint, + pub width: usize, + pub height: usize, + pub pitchInBytes: usize, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 { + pub reserved: [::std::os::raw::c_int; 32usize], +} +pub type CUDA_RESOURCE_DESC_v1 = CUDA_RESOURCE_DESC_st; +pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq)] +pub struct CUDA_TEXTURE_DESC_st { + pub addressMode: [CUaddress_mode; 3usize], + pub filterMode: CUfilter_mode, + pub flags: ::std::os::raw::c_uint, + pub maxAnisotropy: ::std::os::raw::c_uint, + pub mipmapFilterMode: CUfilter_mode, + pub mipmapLevelBias: f32, + pub minMipmapLevelClamp: f32, + pub maxMipmapLevelClamp: f32, + pub borderColor: [f32; 4usize], + pub reserved: [::std::os::raw::c_int; 12usize], +} +pub type CUDA_TEXTURE_DESC_v1 = CUDA_TEXTURE_DESC_st; +pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_v1; +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_NONE: CUresourceViewFormat_enum = CUresourceViewFormat_enum(0); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_1X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(1); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_2X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(2); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_4X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(3); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_1X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(4); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_2X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(5); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_4X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(6); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_1X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(7); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_2X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(8); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_4X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(9); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_1X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(10); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_2X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(11); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_4X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(12); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_1X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(13); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_2X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(14); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UINT_4X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(15); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_1X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(16); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_2X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(17); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SINT_4X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(18); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_1X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(19); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_2X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(20); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_4X16: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(21); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_1X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(22); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_2X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(23); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_FLOAT_4X32: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(24); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC1: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(25); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC2: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(26); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC3: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(27); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC4: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(28); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SIGNED_BC4: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(29); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC5: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(30); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SIGNED_BC5: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(31); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC6H: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(32); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_SIGNED_BC6H: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(33); +} +impl CUresourceViewFormat_enum { + pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC7: CUresourceViewFormat_enum = + CUresourceViewFormat_enum(34); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUresourceViewFormat_enum(pub ::std::os::raw::c_uint); +pub use self::CUresourceViewFormat_enum as CUresourceViewFormat; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_RESOURCE_VIEW_DESC_st { + pub format: CUresourceViewFormat, + pub width: usize, + pub height: usize, + pub depth: usize, + pub firstMipmapLevel: ::std::os::raw::c_uint, + pub lastMipmapLevel: ::std::os::raw::c_uint, + pub firstLayer: ::std::os::raw::c_uint, + pub lastLayer: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +pub type CUDA_RESOURCE_VIEW_DESC_v1 = CUDA_RESOURCE_VIEW_DESC_st; +pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_LAUNCH_PARAMS_st { + pub function: CUfunction, + pub gridDimX: ::std::os::raw::c_uint, + pub gridDimY: ::std::os::raw::c_uint, + pub gridDimZ: ::std::os::raw::c_uint, + pub blockDimX: ::std::os::raw::c_uint, + pub blockDimY: ::std::os::raw::c_uint, + pub blockDimZ: ::std::os::raw::c_uint, + pub sharedMemBytes: ::std::os::raw::c_uint, + pub hStream: CUstream, + pub kernelParams: *mut *mut ::std::os::raw::c_void, +} +pub type CUDA_LAUNCH_PARAMS_v1 = CUDA_LAUNCH_PARAMS_st; +pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_v1; +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(1); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(2); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(3); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(4); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(5); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(6); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(7); +} +impl CUexternalMemoryHandleType_enum { + pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF: CUexternalMemoryHandleType_enum = + CUexternalMemoryHandleType_enum(8); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUexternalMemoryHandleType_enum(pub ::std::os::raw::c_uint); +pub use self::CUexternalMemoryHandleType_enum as CUexternalMemoryHandleType; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st { + pub type_: CUexternalMemoryHandleType, + pub handle: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1, + pub size: ::std::os::raw::c_ulonglong, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 { + pub fd: ::std::os::raw::c_int, + pub win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1, + pub nvSciBufObject: *const ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 { + pub handle: *mut ::std::os::raw::c_void, + pub name: *const ::std::os::raw::c_void, +} +pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1 = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st; +pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st { + pub offset: ::std::os::raw::c_ulonglong, + pub size: ::std::os::raw::c_ulonglong, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1 = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st; +pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st { + pub offset: ::std::os::raw::c_ulonglong, + pub arrayDesc: CUDA_ARRAY3D_DESCRIPTOR, + pub numLevels: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1 = + CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st; +pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1; +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: CUexternalSemaphoreHandleType_enum = + CUexternalSemaphoreHandleType_enum(1); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: CUexternalSemaphoreHandleType_enum = + CUexternalSemaphoreHandleType_enum(2); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: + CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(3); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: CUexternalSemaphoreHandleType_enum = + CUexternalSemaphoreHandleType_enum(4); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE: CUexternalSemaphoreHandleType_enum = + CUexternalSemaphoreHandleType_enum(5); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC: CUexternalSemaphoreHandleType_enum = + CUexternalSemaphoreHandleType_enum(6); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX: + CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(7); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT: + CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(8); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD: + CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(9); +} +impl CUexternalSemaphoreHandleType_enum { + pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32: + CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(10); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUexternalSemaphoreHandleType_enum(pub ::std::os::raw::c_uint); +pub use self::CUexternalSemaphoreHandleType_enum as CUexternalSemaphoreHandleType; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st { + pub type_: CUexternalSemaphoreHandleType, + pub handle: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 { + pub fd: ::std::os::raw::c_int, + pub win32: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1, + pub nvSciSyncObj: *const ::std::os::raw::c_void, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 { + pub handle: *mut ::std::os::raw::c_void, + pub name: *const ::std::os::raw::c_void, +} +pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1 = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st; +pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st { + pub params: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 { + pub fence: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1, + pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2, + pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3, + pub reserved: [::std::os::raw::c_uint; 12usize], +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1 { + pub value: ::std::os::raw::c_ulonglong, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 { + pub fence: *mut ::std::os::raw::c_void, + pub reserved: ::std::os::raw::c_ulonglong, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3 { + pub key: ::std::os::raw::c_ulonglong, +} +pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st; +pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st { + pub params: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 16usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 { + pub fence: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1, + pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2, + pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3, + pub reserved: [::std::os::raw::c_uint; 10usize], +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 { + pub value: ::std::os::raw::c_ulonglong, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 { + pub fence: *mut ::std::os::raw::c_void, + pub reserved: ::std::os::raw::c_ulonglong, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3 { + pub key: ::std::os::raw::c_ulonglong, + pub timeoutMs: ::std::os::raw::c_uint, +} +pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1 = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st; +pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st { + pub extSemArray: *mut CUexternalSemaphore, + pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS, + pub numExtSems: ::std::os::raw::c_uint, +} +pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1 = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st; +pub type CUDA_EXT_SEM_SIGNAL_NODE_PARAMS = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st { + pub extSemArray: *mut CUexternalSemaphore, + pub paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS, + pub numExtSems: ::std::os::raw::c_uint, +} +pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1 = CUDA_EXT_SEM_WAIT_NODE_PARAMS_st; +pub type CUDA_EXT_SEM_WAIT_NODE_PARAMS = CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1; +pub type CUmemGenericAllocationHandle_v1 = ::std::os::raw::c_ulonglong; +pub type CUmemGenericAllocationHandle = CUmemGenericAllocationHandle_v1; +impl CUmemAllocationHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_NONE: CUmemAllocationHandleType_enum = + CUmemAllocationHandleType_enum(0); +} +impl CUmemAllocationHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR: CUmemAllocationHandleType_enum = + CUmemAllocationHandleType_enum(1); +} +impl CUmemAllocationHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_WIN32: CUmemAllocationHandleType_enum = + CUmemAllocationHandleType_enum(2); +} +impl CUmemAllocationHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_WIN32_KMT: CUmemAllocationHandleType_enum = + CUmemAllocationHandleType_enum(4); +} +impl CUmemAllocationHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_MAX: CUmemAllocationHandleType_enum = + CUmemAllocationHandleType_enum(2147483647); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemAllocationHandleType_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemAllocationHandleType_enum as CUmemAllocationHandleType; +impl CUmemAccess_flags_enum { + pub const CU_MEM_ACCESS_FLAGS_PROT_NONE: CUmemAccess_flags_enum = CUmemAccess_flags_enum(0); +} +impl CUmemAccess_flags_enum { + pub const CU_MEM_ACCESS_FLAGS_PROT_READ: CUmemAccess_flags_enum = CUmemAccess_flags_enum(1); +} +impl CUmemAccess_flags_enum { + pub const CU_MEM_ACCESS_FLAGS_PROT_READWRITE: CUmemAccess_flags_enum = + CUmemAccess_flags_enum(3); +} +impl CUmemAccess_flags_enum { + pub const CU_MEM_ACCESS_FLAGS_PROT_MAX: CUmemAccess_flags_enum = + CUmemAccess_flags_enum(2147483647); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemAccess_flags_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemAccess_flags_enum as CUmemAccess_flags; +impl CUmemLocationType_enum { + pub const CU_MEM_LOCATION_TYPE_INVALID: CUmemLocationType_enum = CUmemLocationType_enum(0); +} +impl CUmemLocationType_enum { + pub const CU_MEM_LOCATION_TYPE_DEVICE: CUmemLocationType_enum = CUmemLocationType_enum(1); +} +impl CUmemLocationType_enum { + pub const CU_MEM_LOCATION_TYPE_MAX: CUmemLocationType_enum = CUmemLocationType_enum(2147483647); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemLocationType_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemLocationType_enum as CUmemLocationType; +impl CUmemAllocationType_enum { + pub const CU_MEM_ALLOCATION_TYPE_INVALID: CUmemAllocationType_enum = + CUmemAllocationType_enum(0); +} +impl CUmemAllocationType_enum { + pub const CU_MEM_ALLOCATION_TYPE_PINNED: CUmemAllocationType_enum = CUmemAllocationType_enum(1); +} +impl CUmemAllocationType_enum { + pub const CU_MEM_ALLOCATION_TYPE_MAX: CUmemAllocationType_enum = + CUmemAllocationType_enum(2147483647); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemAllocationType_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemAllocationType_enum as CUmemAllocationType; +impl CUmemAllocationGranularity_flags_enum { + pub const CU_MEM_ALLOC_GRANULARITY_MINIMUM: CUmemAllocationGranularity_flags_enum = + CUmemAllocationGranularity_flags_enum(0); +} +impl CUmemAllocationGranularity_flags_enum { + pub const CU_MEM_ALLOC_GRANULARITY_RECOMMENDED: CUmemAllocationGranularity_flags_enum = + CUmemAllocationGranularity_flags_enum(1); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemAllocationGranularity_flags_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemAllocationGranularity_flags_enum as CUmemAllocationGranularity_flags; +impl CUarraySparseSubresourceType_enum { + pub const CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL: CUarraySparseSubresourceType_enum = + CUarraySparseSubresourceType_enum(0); +} +impl CUarraySparseSubresourceType_enum { + pub const CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL: CUarraySparseSubresourceType_enum = + CUarraySparseSubresourceType_enum(1); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUarraySparseSubresourceType_enum(pub ::std::os::raw::c_uint); +pub use self::CUarraySparseSubresourceType_enum as CUarraySparseSubresourceType; +impl CUmemOperationType_enum { + pub const CU_MEM_OPERATION_TYPE_MAP: CUmemOperationType_enum = CUmemOperationType_enum(1); +} +impl CUmemOperationType_enum { + pub const CU_MEM_OPERATION_TYPE_UNMAP: CUmemOperationType_enum = CUmemOperationType_enum(2); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemOperationType_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemOperationType_enum as CUmemOperationType; +impl CUmemHandleType_enum { + pub const CU_MEM_HANDLE_TYPE_GENERIC: CUmemHandleType_enum = CUmemHandleType_enum(0); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemHandleType_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemHandleType_enum as CUmemHandleType; +#[repr(C)] +#[derive(Copy, Clone)] +pub struct CUarrayMapInfo_st { + pub resourceType: CUresourcetype, + pub resource: CUarrayMapInfo_st__bindgen_ty_1, + pub subresourceType: CUarraySparseSubresourceType, + pub subresource: CUarrayMapInfo_st__bindgen_ty_2, + pub memOperationType: CUmemOperationType, + pub memHandleType: CUmemHandleType, + pub memHandle: CUarrayMapInfo_st__bindgen_ty_3, + pub offset: ::std::os::raw::c_ulonglong, + pub deviceBitMask: ::std::os::raw::c_uint, + pub flags: ::std::os::raw::c_uint, + pub reserved: [::std::os::raw::c_uint; 2usize], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUarrayMapInfo_st__bindgen_ty_1 { + pub mipmap: CUmipmappedArray, + pub array: CUarray, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUarrayMapInfo_st__bindgen_ty_2 { + pub sparseLevel: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1, + pub miptail: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1 { + pub level: ::std::os::raw::c_uint, + pub layer: ::std::os::raw::c_uint, + pub offsetX: ::std::os::raw::c_uint, + pub offsetY: ::std::os::raw::c_uint, + pub offsetZ: ::std::os::raw::c_uint, + pub extentWidth: ::std::os::raw::c_uint, + pub extentHeight: ::std::os::raw::c_uint, + pub extentDepth: ::std::os::raw::c_uint, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2 { + pub layer: ::std::os::raw::c_uint, + pub offset: ::std::os::raw::c_ulonglong, + pub size: ::std::os::raw::c_ulonglong, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union CUarrayMapInfo_st__bindgen_ty_3 { + pub memHandle: CUmemGenericAllocationHandle, +} +pub type CUarrayMapInfo_v1 = CUarrayMapInfo_st; +pub type CUarrayMapInfo = CUarrayMapInfo_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemLocation_st { + pub type_: CUmemLocationType, + pub id: ::std::os::raw::c_int, +} +pub type CUmemLocation_v1 = CUmemLocation_st; +pub type CUmemLocation = CUmemLocation_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemAllocationProp_st { + pub type_: CUmemAllocationType, + pub requestedHandleTypes: CUmemAllocationHandleType, + pub location: CUmemLocation, + pub win32HandleMetaData: *mut ::std::os::raw::c_void, + pub allocFlags: CUmemAllocationProp_st__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemAllocationProp_st__bindgen_ty_1 { + pub compressionType: ::std::os::raw::c_uchar, + pub gpuDirectRDMACapable: ::std::os::raw::c_uchar, + pub usage: ::std::os::raw::c_ushort, + pub reserved: [::std::os::raw::c_uchar; 4usize], +} +pub type CUmemAllocationProp_v1 = CUmemAllocationProp_st; +pub type CUmemAllocationProp = CUmemAllocationProp_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemAccessDesc_st { + pub location: CUmemLocation, + pub flags: CUmemAccess_flags, +} +pub type CUmemAccessDesc_v1 = CUmemAccessDesc_st; +pub type CUmemAccessDesc = CUmemAccessDesc_v1; +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_SUCCESS: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(0); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(1); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(2); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(3); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(4); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(5); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(6); +} +impl CUgraphExecUpdateResult_enum { + pub const CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE: CUgraphExecUpdateResult_enum = + CUgraphExecUpdateResult_enum(7); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUgraphExecUpdateResult_enum(pub ::std::os::raw::c_uint); +pub use self::CUgraphExecUpdateResult_enum as CUgraphExecUpdateResult; +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(1); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(2); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(3); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_RELEASE_THRESHOLD: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(4); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(5); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(6); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_USED_MEM_CURRENT: CUmemPool_attribute_enum = + CUmemPool_attribute_enum(7); +} +impl CUmemPool_attribute_enum { + pub const CU_MEMPOOL_ATTR_USED_MEM_HIGH: CUmemPool_attribute_enum = CUmemPool_attribute_enum(8); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUmemPool_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUmemPool_attribute_enum as CUmemPool_attribute; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemPoolProps_st { + pub allocType: CUmemAllocationType, + pub handleTypes: CUmemAllocationHandleType, + pub location: CUmemLocation, + pub win32SecurityAttributes: *mut ::std::os::raw::c_void, + pub reserved: [::std::os::raw::c_uchar; 64usize], +} +pub type CUmemPoolProps_v1 = CUmemPoolProps_st; +pub type CUmemPoolProps = CUmemPoolProps_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUmemPoolPtrExportData_st { + pub reserved: [::std::os::raw::c_uchar; 64usize], +} +pub type CUmemPoolPtrExportData_v1 = CUmemPoolPtrExportData_st; +pub type CUmemPoolPtrExportData = CUmemPoolPtrExportData_v1; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEM_ALLOC_NODE_PARAMS_st { + pub poolProps: CUmemPoolProps, + pub accessDescs: *const CUmemAccessDesc, + pub accessDescCount: usize, + pub bytesize: usize, + pub dptr: CUdeviceptr, +} +pub type CUDA_MEM_ALLOC_NODE_PARAMS = CUDA_MEM_ALLOC_NODE_PARAMS_st; +impl CUgraphMem_attribute_enum { + pub const CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT: CUgraphMem_attribute_enum = + CUgraphMem_attribute_enum(0); +} +impl CUgraphMem_attribute_enum { + pub const CU_GRAPH_MEM_ATTR_USED_MEM_HIGH: CUgraphMem_attribute_enum = + CUgraphMem_attribute_enum(1); +} +impl CUgraphMem_attribute_enum { + pub const CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT: CUgraphMem_attribute_enum = + CUgraphMem_attribute_enum(2); +} +impl CUgraphMem_attribute_enum { + pub const CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH: CUgraphMem_attribute_enum = + CUgraphMem_attribute_enum(3); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUgraphMem_attribute_enum(pub ::std::os::raw::c_uint); +pub use self::CUgraphMem_attribute_enum as CUgraphMem_attribute; +impl CUflushGPUDirectRDMAWritesScope_enum { + pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER: CUflushGPUDirectRDMAWritesScope_enum = + CUflushGPUDirectRDMAWritesScope_enum(100); +} +impl CUflushGPUDirectRDMAWritesScope_enum { + pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES: CUflushGPUDirectRDMAWritesScope_enum = + CUflushGPUDirectRDMAWritesScope_enum(200); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUflushGPUDirectRDMAWritesScope_enum(pub ::std::os::raw::c_uint); +pub use self::CUflushGPUDirectRDMAWritesScope_enum as CUflushGPUDirectRDMAWritesScope; +impl CUflushGPUDirectRDMAWritesTarget_enum { + pub const CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX: + CUflushGPUDirectRDMAWritesTarget_enum = CUflushGPUDirectRDMAWritesTarget_enum(0); +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct CUflushGPUDirectRDMAWritesTarget_enum(pub ::std::os::raw::c_uint); +pub use self::CUflushGPUDirectRDMAWritesTarget_enum as CUflushGPUDirectRDMAWritesTarget; +extern "C" { + pub fn cuGetErrorString(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult; +} +extern "C" { + pub fn cuGetErrorName(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult; +} +extern "C" { + pub fn cuInit(Flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> CUresult; +} +extern "C" { + pub fn cuDeviceGet(device: *mut CUdevice, ordinal: ::std::os::raw::c_int) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetCount(count: *mut ::std::os::raw::c_int) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetName( + name: *mut ::std::os::raw::c_char, + len: ::std::os::raw::c_int, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetUuid_v2(uuid: *mut CUuuid, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetLuid( + luid: *mut ::std::os::raw::c_char, + deviceNodeMask: *mut ::std::os::raw::c_uint, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetTexture1DLinearMaxWidth( + maxWidthInElements: *mut usize, + format: CUarray_format, + numChannels: ::std::os::raw::c_uint, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetAttribute( + pi: *mut ::std::os::raw::c_int, + attrib: CUdevice_attribute, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetNvSciSyncAttributes( + nvSciSyncAttrList: *mut ::std::os::raw::c_void, + dev: CUdevice, + flags: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceSetMemPool(dev: CUdevice, pool: CUmemoryPool) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetMemPool(pool: *mut CUmemoryPool, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetDefaultMemPool(pool_out: *mut CUmemoryPool, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuFlushGPUDirectRDMAWrites( + target: CUflushGPUDirectRDMAWritesTarget, + scope: CUflushGPUDirectRDMAWritesScope, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceComputeCapability( + major: *mut ::std::os::raw::c_int, + minor: *mut ::std::os::raw::c_int, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxRelease_v2(dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxSetFlags_v2(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxGetState( + dev: CUdevice, + flags: *mut ::std::os::raw::c_uint, + active: *mut ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxReset_v2(dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetExecAffinitySupport( + pi: *mut ::std::os::raw::c_int, + type_: CUexecAffinityType, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxCreate_v2( + pctx: *mut CUcontext, + flags: ::std::os::raw::c_uint, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxCreate_v3( + pctx: *mut CUcontext, + paramsArray: *mut CUexecAffinityParam, + numParams: ::std::os::raw::c_int, + flags: ::std::os::raw::c_uint, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult; +} +extern "C" { + pub fn cuCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuCtxSynchronize() -> CUresult; +} +extern "C" { + pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult; +} +extern "C" { + pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult; +} +extern "C" { + pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult; +} +extern "C" { + pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult; +} +extern "C" { + pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult; +} +extern "C" { + pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult; +} +extern "C" { + pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuCtxGetStreamPriorityRange( + leastPriority: *mut ::std::os::raw::c_int, + greatestPriority: *mut ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxResetPersistingL2Cache() -> CUresult; +} +extern "C" { + pub fn cuCtxGetExecAffinity( + pExecAffinity: *mut CUexecAffinityParam, + type_: CUexecAffinityType, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxAttach(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuCtxDetach(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuModuleLoad(module: *mut CUmodule, fname: *const ::std::os::raw::c_char) -> CUresult; +} +extern "C" { + pub fn cuModuleLoadData( + module: *mut CUmodule, + image: *const ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleLoadDataEx( + module: *mut CUmodule, + image: *const ::std::os::raw::c_void, + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleLoadFatBinary( + module: *mut CUmodule, + fatCubin: *const ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleUnload(hmod: CUmodule) -> CUresult; +} +extern "C" { + pub fn cuModuleGetFunction( + hfunc: *mut CUfunction, + hmod: CUmodule, + name: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleGetGlobal_v2( + dptr: *mut CUdeviceptr, + bytes: *mut usize, + hmod: CUmodule, + name: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleGetTexRef( + pTexRef: *mut CUtexref, + hmod: CUmodule, + name: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleGetSurfRef( + pSurfRef: *mut CUsurfref, + hmod: CUmodule, + name: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkCreate_v2( + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + stateOut: *mut CUlinkState, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkAddData_v2( + state: CUlinkState, + type_: CUjitInputType, + data: *mut ::std::os::raw::c_void, + size: usize, + name: *const ::std::os::raw::c_char, + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkAddFile_v2( + state: CUlinkState, + type_: CUjitInputType, + path: *const ::std::os::raw::c_char, + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkComplete( + state: CUlinkState, + cubinOut: *mut *mut ::std::os::raw::c_void, + sizeOut: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkDestroy(state: CUlinkState) -> CUresult; +} +extern "C" { + pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult; +} +extern "C" { + pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult; +} +extern "C" { + pub fn cuMemAllocPitch_v2( + dptr: *mut CUdeviceptr, + pPitch: *mut usize, + WidthInBytes: usize, + Height: usize, + ElementSizeBytes: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult; +} +extern "C" { + pub fn cuMemGetAddressRange_v2( + pbase: *mut CUdeviceptr, + psize: *mut usize, + dptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAllocHost_v2(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult; +} +extern "C" { + pub fn cuMemFreeHost(p: *mut ::std::os::raw::c_void) -> CUresult; +} +extern "C" { + pub fn cuMemHostAlloc( + pp: *mut *mut ::std::os::raw::c_void, + bytesize: usize, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemHostGetDevicePointer_v2( + pdptr: *mut CUdeviceptr, + p: *mut ::std::os::raw::c_void, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemHostGetFlags( + pFlags: *mut ::std::os::raw::c_uint, + p: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAllocManaged( + dptr: *mut CUdeviceptr, + bytesize: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetByPCIBusId( + dev: *mut CUdevice, + pciBusId: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetPCIBusId( + pciBusId: *mut ::std::os::raw::c_char, + len: ::std::os::raw::c_int, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult; +} +extern "C" { + pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult; +} +extern "C" { + pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult; +} +extern "C" { + pub fn cuIpcOpenMemHandle_v2( + pdptr: *mut CUdeviceptr, + handle: CUipcMemHandle, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult; +} +extern "C" { + pub fn cuMemHostRegister_v2( + p: *mut ::std::os::raw::c_void, + bytesize: usize, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemHostUnregister(p: *mut ::std::os::raw::c_void) -> CUresult; +} +extern "C" { + pub fn cuMemcpy_ptds(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult; +} +extern "C" { + pub fn cuMemcpyPeer_ptds( + dstDevice: CUdeviceptr, + dstContext: CUcontext, + srcDevice: CUdeviceptr, + srcContext: CUcontext, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoD_v2_ptds( + dstDevice: CUdeviceptr, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoH_v2_ptds( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoD_v2_ptds( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoA_v2_ptds( + dstArray: CUarray, + dstOffset: usize, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoD_v2_ptds( + dstDevice: CUdeviceptr, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoA_v2_ptds( + dstArray: CUarray, + dstOffset: usize, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoH_v2_ptds( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoA_v2_ptds( + dstArray: CUarray, + dstOffset: usize, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2D_v2_ptds(pCopy: *const CUDA_MEMCPY2D) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DUnaligned_v2_ptds(pCopy: *const CUDA_MEMCPY2D) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3D_v2_ptds(pCopy: *const CUDA_MEMCPY3D) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DPeer_ptds(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAsync_ptsz( + dst: CUdeviceptr, + src: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyPeerAsync_ptsz( + dstDevice: CUdeviceptr, + dstContext: CUcontext, + srcDevice: CUdeviceptr, + srcContext: CUcontext, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoDAsync_v2_ptsz( + dstDevice: CUdeviceptr, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoHAsync_v2_ptsz( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoDAsync_v2_ptsz( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoAAsync_v2_ptsz( + dstArray: CUarray, + dstOffset: usize, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoHAsync_v2_ptsz( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DAsync_v2_ptsz(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DAsync_v2_ptsz(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DPeerAsync_ptsz( + pCopy: *const CUDA_MEMCPY3D_PEER, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD8_v2_ptds( + dstDevice: CUdeviceptr, + uc: ::std::os::raw::c_uchar, + N: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD16_v2_ptds( + dstDevice: CUdeviceptr, + us: ::std::os::raw::c_ushort, + N: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD32_v2_ptds( + dstDevice: CUdeviceptr, + ui: ::std::os::raw::c_uint, + N: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D8_v2_ptds( + dstDevice: CUdeviceptr, + dstPitch: usize, + uc: ::std::os::raw::c_uchar, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D16_v2_ptds( + dstDevice: CUdeviceptr, + dstPitch: usize, + us: ::std::os::raw::c_ushort, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D32_v2_ptds( + dstDevice: CUdeviceptr, + dstPitch: usize, + ui: ::std::os::raw::c_uint, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD8Async_ptsz( + dstDevice: CUdeviceptr, + uc: ::std::os::raw::c_uchar, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD16Async_ptsz( + dstDevice: CUdeviceptr, + us: ::std::os::raw::c_ushort, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD32Async_ptsz( + dstDevice: CUdeviceptr, + ui: ::std::os::raw::c_uint, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D8Async_ptsz( + dstDevice: CUdeviceptr, + dstPitch: usize, + uc: ::std::os::raw::c_uchar, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D16Async_ptsz( + dstDevice: CUdeviceptr, + dstPitch: usize, + us: ::std::os::raw::c_ushort, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D32Async_ptsz( + dstDevice: CUdeviceptr, + dstPitch: usize, + ui: ::std::os::raw::c_uint, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayCreate_v2( + pHandle: *mut CUarray, + pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayGetDescriptor_v2( + pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR, + hArray: CUarray, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayGetSparseProperties( + sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES, + array: CUarray, + ) -> CUresult; +} +extern "C" { + pub fn cuMipmappedArrayGetSparseProperties( + sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES, + mipmap: CUmipmappedArray, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayGetPlane( + pPlaneArray: *mut CUarray, + hArray: CUarray, + planeIdx: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayDestroy(hArray: CUarray) -> CUresult; +} +extern "C" { + pub fn cuArray3DCreate_v2( + pHandle: *mut CUarray, + pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR, + ) -> CUresult; +} +extern "C" { + pub fn cuArray3DGetDescriptor_v2( + pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR, + hArray: CUarray, + ) -> CUresult; +} +extern "C" { + pub fn cuMipmappedArrayCreate( + pHandle: *mut CUmipmappedArray, + pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR, + numMipmapLevels: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMipmappedArrayGetLevel( + pLevelArray: *mut CUarray, + hMipmappedArray: CUmipmappedArray, + level: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult; +} +extern "C" { + pub fn cuMemAddressReserve( + ptr: *mut CUdeviceptr, + size: usize, + alignment: usize, + addr: CUdeviceptr, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAddressFree(ptr: CUdeviceptr, size: usize) -> CUresult; +} +extern "C" { + pub fn cuMemCreate( + handle: *mut CUmemGenericAllocationHandle, + size: usize, + prop: *const CUmemAllocationProp, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemRelease(handle: CUmemGenericAllocationHandle) -> CUresult; +} +extern "C" { + pub fn cuMemMap( + ptr: CUdeviceptr, + size: usize, + offset: usize, + handle: CUmemGenericAllocationHandle, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemMapArrayAsync_ptsz( + mapInfoList: *mut CUarrayMapInfo, + count: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemUnmap(ptr: CUdeviceptr, size: usize) -> CUresult; +} +extern "C" { + pub fn cuMemSetAccess( + ptr: CUdeviceptr, + size: usize, + desc: *const CUmemAccessDesc, + count: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemGetAccess( + flags: *mut ::std::os::raw::c_ulonglong, + location: *const CUmemLocation, + ptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuMemExportToShareableHandle( + shareableHandle: *mut ::std::os::raw::c_void, + handle: CUmemGenericAllocationHandle, + handleType: CUmemAllocationHandleType, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemImportFromShareableHandle( + handle: *mut CUmemGenericAllocationHandle, + osHandle: *mut ::std::os::raw::c_void, + shHandleType: CUmemAllocationHandleType, + ) -> CUresult; +} +extern "C" { + pub fn cuMemGetAllocationGranularity( + granularity: *mut usize, + prop: *const CUmemAllocationProp, + option: CUmemAllocationGranularity_flags, + ) -> CUresult; +} +extern "C" { + pub fn cuMemGetAllocationPropertiesFromHandle( + prop: *mut CUmemAllocationProp, + handle: CUmemGenericAllocationHandle, + ) -> CUresult; +} +extern "C" { + pub fn cuMemRetainAllocationHandle( + handle: *mut CUmemGenericAllocationHandle, + addr: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuMemFreeAsync_ptsz(dptr: CUdeviceptr, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemAllocAsync_ptsz( + dptr: *mut CUdeviceptr, + bytesize: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolTrimTo(pool: CUmemoryPool, minBytesToKeep: usize) -> CUresult; +} +extern "C" { + pub fn cuMemPoolSetAttribute( + pool: CUmemoryPool, + attr: CUmemPool_attribute, + value: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolGetAttribute( + pool: CUmemoryPool, + attr: CUmemPool_attribute, + value: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolSetAccess( + pool: CUmemoryPool, + map: *const CUmemAccessDesc, + count: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolGetAccess( + flags: *mut CUmemAccess_flags, + memPool: CUmemoryPool, + location: *mut CUmemLocation, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolCreate(pool: *mut CUmemoryPool, poolProps: *const CUmemPoolProps) -> CUresult; +} +extern "C" { + pub fn cuMemPoolDestroy(pool: CUmemoryPool) -> CUresult; +} +extern "C" { + pub fn cuMemAllocFromPoolAsync_ptsz( + dptr: *mut CUdeviceptr, + bytesize: usize, + pool: CUmemoryPool, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolExportToShareableHandle( + handle_out: *mut ::std::os::raw::c_void, + pool: CUmemoryPool, + handleType: CUmemAllocationHandleType, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolImportFromShareableHandle( + pool_out: *mut CUmemoryPool, + handle: *mut ::std::os::raw::c_void, + handleType: CUmemAllocationHandleType, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolExportPointer( + shareData_out: *mut CUmemPoolPtrExportData, + ptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPoolImportPointer( + ptr_out: *mut CUdeviceptr, + pool: CUmemoryPool, + shareData: *mut CUmemPoolPtrExportData, + ) -> CUresult; +} +extern "C" { + pub fn cuPointerGetAttribute( + data: *mut ::std::os::raw::c_void, + attribute: CUpointer_attribute, + ptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPrefetchAsync_ptsz( + devPtr: CUdeviceptr, + count: usize, + dstDevice: CUdevice, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAdvise( + devPtr: CUdeviceptr, + count: usize, + advice: CUmem_advise, + device: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuMemRangeGetAttribute( + data: *mut ::std::os::raw::c_void, + dataSize: usize, + attribute: CUmem_range_attribute, + devPtr: CUdeviceptr, + count: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemRangeGetAttributes( + data: *mut *mut ::std::os::raw::c_void, + dataSizes: *mut usize, + attributes: *mut CUmem_range_attribute, + numAttributes: usize, + devPtr: CUdeviceptr, + count: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuPointerSetAttribute( + value: *const ::std::os::raw::c_void, + attribute: CUpointer_attribute, + ptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuPointerGetAttributes( + numAttributes: ::std::os::raw::c_uint, + attributes: *mut CUpointer_attribute, + data: *mut *mut ::std::os::raw::c_void, + ptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamCreate(phStream: *mut CUstream, Flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuStreamCreateWithPriority( + phStream: *mut CUstream, + flags: ::std::os::raw::c_uint, + priority: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetPriority_ptsz( + hStream: CUstream, + priority: *mut ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetFlags_ptsz(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) + -> CUresult; +} +extern "C" { + pub fn cuStreamGetCtx_ptsz(hStream: CUstream, pctx: *mut CUcontext) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitEvent_ptsz( + hStream: CUstream, + hEvent: CUevent, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamAddCallback_ptsz( + hStream: CUstream, + callback: CUstreamCallback, + userData: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamBeginCapture_v2_ptsz(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult; +} +extern "C" { + pub fn cuThreadExchangeStreamCaptureMode(mode: *mut CUstreamCaptureMode) -> CUresult; +} +extern "C" { + pub fn cuStreamEndCapture_ptsz(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult; +} +extern "C" { + pub fn cuStreamIsCapturing_ptsz( + hStream: CUstream, + captureStatus: *mut CUstreamCaptureStatus, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetCaptureInfo_ptsz( + hStream: CUstream, + captureStatus_out: *mut CUstreamCaptureStatus, + id_out: *mut cuuint64_t, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetCaptureInfo_v2_ptsz( + hStream: CUstream, + captureStatus_out: *mut CUstreamCaptureStatus, + id_out: *mut cuuint64_t, + graph_out: *mut CUgraph, + dependencies_out: *mut *const CUgraphNode, + numDependencies_out: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamUpdateCaptureDependencies_ptsz( + hStream: CUstream, + dependencies: *mut CUgraphNode, + numDependencies: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamAttachMemAsync_ptsz( + hStream: CUstream, + dptr: CUdeviceptr, + length: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamQuery_ptsz(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamSynchronize_ptsz(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamCopyAttributes_ptsz(dst: CUstream, src: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamGetAttribute_ptsz( + hStream: CUstream, + attr: CUstreamAttrID, + value_out: *mut CUstreamAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamSetAttribute_ptsz( + hStream: CUstream, + attr: CUstreamAttrID, + value: *const CUstreamAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuEventCreate(phEvent: *mut CUevent, Flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuEventRecord_ptsz(hEvent: CUevent, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuEventRecordWithFlags_ptsz( + hEvent: CUevent, + hStream: CUstream, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuEventQuery(hEvent: CUevent) -> CUresult; +} +extern "C" { + pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult; +} +extern "C" { + pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult; +} +extern "C" { + pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult; +} +extern "C" { + pub fn cuImportExternalMemory( + extMem_out: *mut CUexternalMemory, + memHandleDesc: *const CUDA_EXTERNAL_MEMORY_HANDLE_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuExternalMemoryGetMappedBuffer( + devPtr: *mut CUdeviceptr, + extMem: CUexternalMemory, + bufferDesc: *const CUDA_EXTERNAL_MEMORY_BUFFER_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuExternalMemoryGetMappedMipmappedArray( + mipmap: *mut CUmipmappedArray, + extMem: CUexternalMemory, + mipmapDesc: *const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuDestroyExternalMemory(extMem: CUexternalMemory) -> CUresult; +} +extern "C" { + pub fn cuImportExternalSemaphore( + extSem_out: *mut CUexternalSemaphore, + semHandleDesc: *const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuSignalExternalSemaphoresAsync_ptsz( + extSemArray: *const CUexternalSemaphore, + paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS, + numExtSems: ::std::os::raw::c_uint, + stream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuWaitExternalSemaphoresAsync_ptsz( + extSemArray: *const CUexternalSemaphore, + paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS, + numExtSems: ::std::os::raw::c_uint, + stream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuDestroyExternalSemaphore(extSem: CUexternalSemaphore) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitValue32_ptsz( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint32_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitValue64_ptsz( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint64_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWriteValue32_ptsz( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint32_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWriteValue64_ptsz( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint64_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamBatchMemOp_ptsz( + stream: CUstream, + count: ::std::os::raw::c_uint, + paramArray: *mut CUstreamBatchMemOpParams, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuFuncGetAttribute( + pi: *mut ::std::os::raw::c_int, + attrib: CUfunction_attribute, + hfunc: CUfunction, + ) -> CUresult; +} +extern "C" { + pub fn cuFuncSetAttribute( + hfunc: CUfunction, + attrib: CUfunction_attribute, + value: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult; +} +extern "C" { + pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult; +} +extern "C" { + pub fn cuFuncGetModule(hmod: *mut CUmodule, hfunc: CUfunction) -> CUresult; +} +extern "C" { + pub fn cuLaunchKernel_ptsz( + f: CUfunction, + gridDimX: ::std::os::raw::c_uint, + gridDimY: ::std::os::raw::c_uint, + gridDimZ: ::std::os::raw::c_uint, + blockDimX: ::std::os::raw::c_uint, + blockDimY: ::std::os::raw::c_uint, + blockDimZ: ::std::os::raw::c_uint, + sharedMemBytes: ::std::os::raw::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::std::os::raw::c_void, + extra: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchCooperativeKernel_ptsz( + f: CUfunction, + gridDimX: ::std::os::raw::c_uint, + gridDimY: ::std::os::raw::c_uint, + gridDimZ: ::std::os::raw::c_uint, + blockDimX: ::std::os::raw::c_uint, + blockDimY: ::std::os::raw::c_uint, + blockDimZ: ::std::os::raw::c_uint, + sharedMemBytes: ::std::os::raw::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchCooperativeKernelMultiDevice( + launchParamsList: *mut CUDA_LAUNCH_PARAMS, + numDevices: ::std::os::raw::c_uint, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchHostFunc_ptsz( + hStream: CUstream, + fn_: CUhostFn, + userData: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuFuncSetBlockShape( + hfunc: CUfunction, + x: ::std::os::raw::c_int, + y: ::std::os::raw::c_int, + z: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuParamSetSize(hfunc: CUfunction, numbytes: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuParamSeti( + hfunc: CUfunction, + offset: ::std::os::raw::c_int, + value: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuParamSetf(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: f32) -> CUresult; +} +extern "C" { + pub fn cuParamSetv( + hfunc: CUfunction, + offset: ::std::os::raw::c_int, + ptr: *mut ::std::os::raw::c_void, + numbytes: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunch(f: CUfunction) -> CUresult; +} +extern "C" { + pub fn cuLaunchGrid( + f: CUfunction, + grid_width: ::std::os::raw::c_int, + grid_height: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchGridAsync( + f: CUfunction, + grid_width: ::std::os::raw::c_int, + grid_height: ::std::os::raw::c_int, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuParamSetTexRef( + hfunc: CUfunction, + texunit: ::std::os::raw::c_int, + hTexRef: CUtexref, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphCreate(phGraph: *mut CUgraph, flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuGraphAddKernelNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + nodeParams: *const CUDA_KERNEL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphKernelNodeGetParams( + hNode: CUgraphNode, + nodeParams: *mut CUDA_KERNEL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphKernelNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_KERNEL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddMemcpyNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + copyParams: *const CUDA_MEMCPY3D, + ctx: CUcontext, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemcpyNodeGetParams( + hNode: CUgraphNode, + nodeParams: *mut CUDA_MEMCPY3D, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemcpyNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_MEMCPY3D, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddMemsetNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + memsetParams: *const CUDA_MEMSET_NODE_PARAMS, + ctx: CUcontext, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemsetNodeGetParams( + hNode: CUgraphNode, + nodeParams: *mut CUDA_MEMSET_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemsetNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_MEMSET_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddHostNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + nodeParams: *const CUDA_HOST_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphHostNodeGetParams( + hNode: CUgraphNode, + nodeParams: *mut CUDA_HOST_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphHostNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_HOST_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddChildGraphNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + childGraph: CUgraph, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphChildGraphNodeGetGraph(hNode: CUgraphNode, phGraph: *mut CUgraph) -> CUresult; +} +extern "C" { + pub fn cuGraphAddEmptyNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddEventRecordNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + event: CUevent, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphEventRecordNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult; +} +extern "C" { + pub fn cuGraphEventRecordNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult; +} +extern "C" { + pub fn cuGraphAddEventWaitNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + event: CUevent, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphEventWaitNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult; +} +extern "C" { + pub fn cuGraphEventWaitNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult; +} +extern "C" { + pub fn cuGraphAddExternalSemaphoresSignalNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExternalSemaphoresSignalNodeGetParams( + hNode: CUgraphNode, + params_out: *mut CUDA_EXT_SEM_SIGNAL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExternalSemaphoresSignalNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddExternalSemaphoresWaitNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExternalSemaphoresWaitNodeGetParams( + hNode: CUgraphNode, + params_out: *mut CUDA_EXT_SEM_WAIT_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExternalSemaphoresWaitNodeSetParams( + hNode: CUgraphNode, + nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddMemAllocNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + nodeParams: *mut CUDA_MEM_ALLOC_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemAllocNodeGetParams( + hNode: CUgraphNode, + params_out: *mut CUDA_MEM_ALLOC_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddMemFreeNode( + phGraphNode: *mut CUgraphNode, + hGraph: CUgraph, + dependencies: *const CUgraphNode, + numDependencies: usize, + dptr: CUdeviceptr, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphMemFreeNodeGetParams(hNode: CUgraphNode, dptr_out: *mut CUdeviceptr) -> CUresult; +} +extern "C" { + pub fn cuDeviceGraphMemTrim(device: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetGraphMemAttribute( + device: CUdevice, + attr: CUgraphMem_attribute, + value: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceSetGraphMemAttribute( + device: CUdevice, + attr: CUgraphMem_attribute, + value: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphClone(phGraphClone: *mut CUgraph, originalGraph: CUgraph) -> CUresult; +} +extern "C" { + pub fn cuGraphNodeFindInClone( + phNode: *mut CUgraphNode, + hOriginalNode: CUgraphNode, + hClonedGraph: CUgraph, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphNodeGetType(hNode: CUgraphNode, type_: *mut CUgraphNodeType) -> CUresult; +} +extern "C" { + pub fn cuGraphGetNodes( + hGraph: CUgraph, + nodes: *mut CUgraphNode, + numNodes: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphGetRootNodes( + hGraph: CUgraph, + rootNodes: *mut CUgraphNode, + numRootNodes: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphGetEdges( + hGraph: CUgraph, + from: *mut CUgraphNode, + to: *mut CUgraphNode, + numEdges: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphNodeGetDependencies( + hNode: CUgraphNode, + dependencies: *mut CUgraphNode, + numDependencies: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphNodeGetDependentNodes( + hNode: CUgraphNode, + dependentNodes: *mut CUgraphNode, + numDependentNodes: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphAddDependencies( + hGraph: CUgraph, + from: *const CUgraphNode, + to: *const CUgraphNode, + numDependencies: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphRemoveDependencies( + hGraph: CUgraph, + from: *const CUgraphNode, + to: *const CUgraphNode, + numDependencies: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphDestroyNode(hNode: CUgraphNode) -> CUresult; +} +extern "C" { + pub fn cuGraphInstantiate_v2( + phGraphExec: *mut CUgraphExec, + hGraph: CUgraph, + phErrorNode: *mut CUgraphNode, + logBuffer: *mut ::std::os::raw::c_char, + bufferSize: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphInstantiateWithFlags( + phGraphExec: *mut CUgraphExec, + hGraph: CUgraph, + flags: ::std::os::raw::c_ulonglong, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecKernelNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + nodeParams: *const CUDA_KERNEL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecMemcpyNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + copyParams: *const CUDA_MEMCPY3D, + ctx: CUcontext, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecMemsetNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + memsetParams: *const CUDA_MEMSET_NODE_PARAMS, + ctx: CUcontext, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecHostNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + nodeParams: *const CUDA_HOST_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecChildGraphNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + childGraph: CUgraph, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecEventRecordNodeSetEvent( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + event: CUevent, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecEventWaitNodeSetEvent( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + event: CUevent, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecExternalSemaphoresSignalNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + nodeParams: *const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphExecExternalSemaphoresWaitNodeSetParams( + hGraphExec: CUgraphExec, + hNode: CUgraphNode, + nodeParams: *const CUDA_EXT_SEM_WAIT_NODE_PARAMS, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphUpload_ptsz(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuGraphLaunch_ptsz(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuGraphExecDestroy(hGraphExec: CUgraphExec) -> CUresult; +} +extern "C" { + pub fn cuGraphDestroy(hGraph: CUgraph) -> CUresult; +} +extern "C" { + pub fn cuGraphExecUpdate( + hGraphExec: CUgraphExec, + hGraph: CUgraph, + hErrorNode_out: *mut CUgraphNode, + updateResult_out: *mut CUgraphExecUpdateResult, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphKernelNodeCopyAttributes(dst: CUgraphNode, src: CUgraphNode) -> CUresult; +} +extern "C" { + pub fn cuGraphKernelNodeGetAttribute( + hNode: CUgraphNode, + attr: CUkernelNodeAttrID, + value_out: *mut CUkernelNodeAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphKernelNodeSetAttribute( + hNode: CUgraphNode, + attr: CUkernelNodeAttrID, + value: *const CUkernelNodeAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphDebugDotPrint( + hGraph: CUgraph, + path: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuUserObjectCreate( + object_out: *mut CUuserObject, + ptr: *mut ::std::os::raw::c_void, + destroy: CUhostFn, + initialRefcount: ::std::os::raw::c_uint, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuUserObjectRetain(object: CUuserObject, count: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuUserObjectRelease(object: CUuserObject, count: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuGraphRetainUserObject( + graph: CUgraph, + object: CUuserObject, + count: ::std::os::raw::c_uint, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphReleaseUserObject( + graph: CUgraph, + object: CUuserObject, + count: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor( + numBlocks: *mut ::std::os::raw::c_int, + func: CUfunction, + blockSize: ::std::os::raw::c_int, + dynamicSMemSize: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + numBlocks: *mut ::std::os::raw::c_int, + func: CUfunction, + blockSize: ::std::os::raw::c_int, + dynamicSMemSize: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuOccupancyMaxPotentialBlockSize( + minGridSize: *mut ::std::os::raw::c_int, + blockSize: *mut ::std::os::raw::c_int, + func: CUfunction, + blockSizeToDynamicSMemSize: CUoccupancyB2DSize, + dynamicSMemSize: usize, + blockSizeLimit: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuOccupancyMaxPotentialBlockSizeWithFlags( + minGridSize: *mut ::std::os::raw::c_int, + blockSize: *mut ::std::os::raw::c_int, + func: CUfunction, + blockSizeToDynamicSMemSize: CUoccupancyB2DSize, + dynamicSMemSize: usize, + blockSizeLimit: ::std::os::raw::c_int, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuOccupancyAvailableDynamicSMemPerBlock( + dynamicSmemSize: *mut usize, + func: CUfunction, + numBlocks: ::std::os::raw::c_int, + blockSize: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetArray( + hTexRef: CUtexref, + hArray: CUarray, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetMipmappedArray( + hTexRef: CUtexref, + hMipmappedArray: CUmipmappedArray, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddress_v2( + ByteOffset: *mut usize, + hTexRef: CUtexref, + dptr: CUdeviceptr, + bytes: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddress2D_v3( + hTexRef: CUtexref, + desc: *const CUDA_ARRAY_DESCRIPTOR, + dptr: CUdeviceptr, + Pitch: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetFormat( + hTexRef: CUtexref, + fmt: CUarray_format, + NumPackedComponents: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddressMode( + hTexRef: CUtexref, + dim: ::std::os::raw::c_int, + am: CUaddress_mode, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetMipmapLevelClamp( + hTexRef: CUtexref, + minMipmapLevelClamp: f32, + maxMipmapLevelClamp: f32, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetMaxAnisotropy( + hTexRef: CUtexref, + maxAniso: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetMipmappedArray( + phMipmappedArray: *mut CUmipmappedArray, + hTexRef: CUtexref, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetAddressMode( + pam: *mut CUaddress_mode, + hTexRef: CUtexref, + dim: ::std::os::raw::c_int, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetFormat( + pFormat: *mut CUarray_format, + pNumChannels: *mut ::std::os::raw::c_int, + hTexRef: CUtexref, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetMipmapLevelClamp( + pminMipmapLevelClamp: *mut f32, + pmaxMipmapLevelClamp: *mut f32, + hTexRef: CUtexref, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetMaxAnisotropy( + pmaxAniso: *mut ::std::os::raw::c_int, + hTexRef: CUtexref, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetFlags(pFlags: *mut ::std::os::raw::c_uint, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult; +} +extern "C" { + pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuSurfRefSetArray( + hSurfRef: CUsurfref, + hArray: CUarray, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult; +} +extern "C" { + pub fn cuTexObjectCreate( + pTexObject: *mut CUtexObject, + pResDesc: *const CUDA_RESOURCE_DESC, + pTexDesc: *const CUDA_TEXTURE_DESC, + pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult; +} +extern "C" { + pub fn cuTexObjectGetResourceDesc( + pResDesc: *mut CUDA_RESOURCE_DESC, + texObject: CUtexObject, + ) -> CUresult; +} +extern "C" { + pub fn cuTexObjectGetTextureDesc( + pTexDesc: *mut CUDA_TEXTURE_DESC, + texObject: CUtexObject, + ) -> CUresult; +} +extern "C" { + pub fn cuTexObjectGetResourceViewDesc( + pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC, + texObject: CUtexObject, + ) -> CUresult; +} +extern "C" { + pub fn cuSurfObjectCreate( + pSurfObject: *mut CUsurfObject, + pResDesc: *const CUDA_RESOURCE_DESC, + ) -> CUresult; +} +extern "C" { + pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult; +} +extern "C" { + pub fn cuSurfObjectGetResourceDesc( + pResDesc: *mut CUDA_RESOURCE_DESC, + surfObject: CUsurfObject, + ) -> CUresult; +} +extern "C" { + pub fn cuDeviceCanAccessPeer( + canAccessPeer: *mut ::std::os::raw::c_int, + dev: CUdevice, + peerDev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: ::std::os::raw::c_uint) + -> CUresult; +} +extern "C" { + pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuDeviceGetP2PAttribute( + value: *mut ::std::os::raw::c_int, + attrib: CUdevice_P2PAttribute, + srcDevice: CUdevice, + dstDevice: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult; +} +extern "C" { + pub fn cuGraphicsSubResourceGetMappedArray( + pArray: *mut CUarray, + resource: CUgraphicsResource, + arrayIndex: ::std::os::raw::c_uint, + mipLevel: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsResourceGetMappedMipmappedArray( + pMipmappedArray: *mut CUmipmappedArray, + resource: CUgraphicsResource, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsResourceGetMappedPointer_v2( + pDevPtr: *mut CUdeviceptr, + pSize: *mut usize, + resource: CUgraphicsResource, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsResourceSetMapFlags_v2( + resource: CUgraphicsResource, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsMapResources_ptsz( + count: ::std::os::raw::c_uint, + resources: *mut CUgraphicsResource, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsUnmapResources_ptsz( + count: ::std::os::raw::c_uint, + resources: *mut CUgraphicsResource, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuGetProcAddress( + symbol: *const ::std::os::raw::c_char, + pfn: *mut *mut ::std::os::raw::c_void, + cudaVersion: ::std::os::raw::c_int, + flags: cuuint64_t, + ) -> CUresult; +} +extern "C" { + pub fn cuGetExportTable( + ppExportTable: *mut *const ::std::os::raw::c_void, + pExportTableId: *const CUuuid, + ) -> CUresult; +} +extern "C" { + pub fn cuMemHostRegister( + p: *mut ::std::os::raw::c_void, + bytesize: usize, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsResourceSetMapFlags( + resource: CUgraphicsResource, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkCreate( + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + stateOut: *mut CUlinkState, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkAddData( + state: CUlinkState, + type_: CUjitInputType, + data: *mut ::std::os::raw::c_void, + size: usize, + name: *const ::std::os::raw::c_char, + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLinkAddFile( + state: CUlinkState, + type_: CUjitInputType, + path: *const ::std::os::raw::c_char, + numOptions: ::std::os::raw::c_uint, + options: *mut CUjit_option, + optionValues: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddress2D_v2( + hTexRef: CUtexref, + desc: *const CUDA_ARRAY_DESCRIPTOR, + dptr: CUdeviceptr, + Pitch: usize, + ) -> CUresult; +} +#[repr(transparent)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUdeviceptr_v1(pub ::std::os::raw::c_uint); +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMCPY2D_v1_st { + pub srcXInBytes: ::std::os::raw::c_uint, + pub srcY: ::std::os::raw::c_uint, + pub srcMemoryType: CUmemorytype, + pub srcHost: *const ::std::os::raw::c_void, + pub srcDevice: CUdeviceptr_v1, + pub srcArray: CUarray, + pub srcPitch: ::std::os::raw::c_uint, + pub dstXInBytes: ::std::os::raw::c_uint, + pub dstY: ::std::os::raw::c_uint, + pub dstMemoryType: CUmemorytype, + pub dstHost: *mut ::std::os::raw::c_void, + pub dstDevice: CUdeviceptr_v1, + pub dstArray: CUarray, + pub dstPitch: ::std::os::raw::c_uint, + pub WidthInBytes: ::std::os::raw::c_uint, + pub Height: ::std::os::raw::c_uint, +} +pub type CUDA_MEMCPY2D_v1 = CUDA_MEMCPY2D_v1_st; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_MEMCPY3D_v1_st { + pub srcXInBytes: ::std::os::raw::c_uint, + pub srcY: ::std::os::raw::c_uint, + pub srcZ: ::std::os::raw::c_uint, + pub srcLOD: ::std::os::raw::c_uint, + pub srcMemoryType: CUmemorytype, + pub srcHost: *const ::std::os::raw::c_void, + pub srcDevice: CUdeviceptr_v1, + pub srcArray: CUarray, + pub reserved0: *mut ::std::os::raw::c_void, + pub srcPitch: ::std::os::raw::c_uint, + pub srcHeight: ::std::os::raw::c_uint, + pub dstXInBytes: ::std::os::raw::c_uint, + pub dstY: ::std::os::raw::c_uint, + pub dstZ: ::std::os::raw::c_uint, + pub dstLOD: ::std::os::raw::c_uint, + pub dstMemoryType: CUmemorytype, + pub dstHost: *mut ::std::os::raw::c_void, + pub dstDevice: CUdeviceptr_v1, + pub dstArray: CUarray, + pub reserved1: *mut ::std::os::raw::c_void, + pub dstPitch: ::std::os::raw::c_uint, + pub dstHeight: ::std::os::raw::c_uint, + pub WidthInBytes: ::std::os::raw::c_uint, + pub Height: ::std::os::raw::c_uint, + pub Depth: ::std::os::raw::c_uint, +} +pub type CUDA_MEMCPY3D_v1 = CUDA_MEMCPY3D_v1_st; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY_DESCRIPTOR_v1_st { + pub Width: ::std::os::raw::c_uint, + pub Height: ::std::os::raw::c_uint, + pub Format: CUarray_format, + pub NumChannels: ::std::os::raw::c_uint, +} +pub type CUDA_ARRAY_DESCRIPTOR_v1 = CUDA_ARRAY_DESCRIPTOR_v1_st; +#[repr(C)] +#[derive(Copy, Clone, PartialEq, Eq)] +pub struct CUDA_ARRAY3D_DESCRIPTOR_v1_st { + pub Width: ::std::os::raw::c_uint, + pub Height: ::std::os::raw::c_uint, + pub Depth: ::std::os::raw::c_uint, + pub Format: CUarray_format, + pub NumChannels: ::std::os::raw::c_uint, + pub Flags: ::std::os::raw::c_uint, +} +pub type CUDA_ARRAY3D_DESCRIPTOR_v1 = CUDA_ARRAY3D_DESCRIPTOR_v1_st; +extern "C" { + pub fn cuDeviceTotalMem(bytes: *mut ::std::os::raw::c_uint, dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuCtxCreate( + pctx: *mut CUcontext, + flags: ::std::os::raw::c_uint, + dev: CUdevice, + ) -> CUresult; +} +extern "C" { + pub fn cuModuleGetGlobal( + dptr: *mut CUdeviceptr_v1, + bytes: *mut ::std::os::raw::c_uint, + hmod: CUmodule, + name: *const ::std::os::raw::c_char, + ) -> CUresult; +} +extern "C" { + pub fn cuMemGetInfo( + free: *mut ::std::os::raw::c_uint, + total: *mut ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAlloc(dptr: *mut CUdeviceptr_v1, bytesize: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuMemAllocPitch( + dptr: *mut CUdeviceptr_v1, + pPitch: *mut ::std::os::raw::c_uint, + WidthInBytes: ::std::os::raw::c_uint, + Height: ::std::os::raw::c_uint, + ElementSizeBytes: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemFree(dptr: CUdeviceptr_v1) -> CUresult; +} +extern "C" { + pub fn cuMemGetAddressRange( + pbase: *mut CUdeviceptr_v1, + psize: *mut ::std::os::raw::c_uint, + dptr: CUdeviceptr_v1, + ) -> CUresult; +} +extern "C" { + pub fn cuMemAllocHost( + pp: *mut *mut ::std::os::raw::c_void, + bytesize: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemHostGetDevicePointer( + pdptr: *mut CUdeviceptr_v1, + p: *mut ::std::os::raw::c_void, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoD( + dstDevice: CUdeviceptr_v1, + srcHost: *const ::std::os::raw::c_void, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoH( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr_v1, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoD( + dstDevice: CUdeviceptr_v1, + srcDevice: CUdeviceptr_v1, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoA( + dstArray: CUarray, + dstOffset: ::std::os::raw::c_uint, + srcDevice: CUdeviceptr_v1, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoD( + dstDevice: CUdeviceptr_v1, + srcArray: CUarray, + srcOffset: ::std::os::raw::c_uint, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoA( + dstArray: CUarray, + dstOffset: ::std::os::raw::c_uint, + srcHost: *const ::std::os::raw::c_void, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoH( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: ::std::os::raw::c_uint, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoA( + dstArray: CUarray, + dstOffset: ::std::os::raw::c_uint, + srcArray: CUarray, + srcOffset: ::std::os::raw::c_uint, + ByteCount: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoAAsync( + dstArray: CUarray, + dstOffset: ::std::os::raw::c_uint, + srcHost: *const ::std::os::raw::c_void, + ByteCount: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoHAsync( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: ::std::os::raw::c_uint, + ByteCount: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2D(pCopy: *const CUDA_MEMCPY2D_v1) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DUnaligned(pCopy: *const CUDA_MEMCPY2D_v1) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3D(pCopy: *const CUDA_MEMCPY3D_v1) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoDAsync( + dstDevice: CUdeviceptr_v1, + srcHost: *const ::std::os::raw::c_void, + ByteCount: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoHAsync( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr_v1, + ByteCount: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoDAsync( + dstDevice: CUdeviceptr_v1, + srcDevice: CUdeviceptr_v1, + ByteCount: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DAsync(pCopy: *const CUDA_MEMCPY2D_v1, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DAsync(pCopy: *const CUDA_MEMCPY3D_v1, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemsetD8( + dstDevice: CUdeviceptr_v1, + uc: ::std::os::raw::c_uchar, + N: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD16( + dstDevice: CUdeviceptr_v1, + us: ::std::os::raw::c_ushort, + N: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD32( + dstDevice: CUdeviceptr_v1, + ui: ::std::os::raw::c_uint, + N: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D8( + dstDevice: CUdeviceptr_v1, + dstPitch: ::std::os::raw::c_uint, + uc: ::std::os::raw::c_uchar, + Width: ::std::os::raw::c_uint, + Height: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D16( + dstDevice: CUdeviceptr_v1, + dstPitch: ::std::os::raw::c_uint, + us: ::std::os::raw::c_ushort, + Width: ::std::os::raw::c_uint, + Height: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D32( + dstDevice: CUdeviceptr_v1, + dstPitch: ::std::os::raw::c_uint, + ui: ::std::os::raw::c_uint, + Width: ::std::os::raw::c_uint, + Height: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayCreate( + pHandle: *mut CUarray, + pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR_v1, + ) -> CUresult; +} +extern "C" { + pub fn cuArrayGetDescriptor( + pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR_v1, + hArray: CUarray, + ) -> CUresult; +} +extern "C" { + pub fn cuArray3DCreate( + pHandle: *mut CUarray, + pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR_v1, + ) -> CUresult; +} +extern "C" { + pub fn cuArray3DGetDescriptor( + pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR_v1, + hArray: CUarray, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddress( + ByteOffset: *mut ::std::os::raw::c_uint, + hTexRef: CUtexref, + dptr: CUdeviceptr_v1, + bytes: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefSetAddress2D( + hTexRef: CUtexref, + desc: *const CUDA_ARRAY_DESCRIPTOR_v1, + dptr: CUdeviceptr_v1, + Pitch: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuTexRefGetAddress(pdptr: *mut CUdeviceptr_v1, hTexRef: CUtexref) -> CUresult; +} +extern "C" { + pub fn cuGraphicsResourceGetMappedPointer( + pDevPtr: *mut CUdeviceptr_v1, + pSize: *mut ::std::os::raw::c_uint, + resource: CUgraphicsResource, + ) -> CUresult; +} +extern "C" { + pub fn cuCtxDestroy(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxPopCurrent(pctx: *mut CUcontext) -> CUresult; +} +extern "C" { + pub fn cuCtxPushCurrent(ctx: CUcontext) -> CUresult; +} +extern "C" { + pub fn cuStreamDestroy(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuEventDestroy(hEvent: CUevent) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult; +} +extern "C" { + pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoD_v2( + dstDevice: CUdeviceptr, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoH_v2( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoD_v2( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoA_v2( + dstArray: CUarray, + dstOffset: usize, + srcDevice: CUdeviceptr, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoD_v2( + dstDevice: CUdeviceptr, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoA_v2( + dstArray: CUarray, + dstOffset: usize, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoH_v2( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoA_v2( + dstArray: CUarray, + dstOffset: usize, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoAAsync_v2( + dstArray: CUarray, + dstOffset: usize, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAtoHAsync_v2( + dstHost: *mut ::std::os::raw::c_void, + srcArray: CUarray, + srcOffset: usize, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult; +} +extern "C" { + pub fn cuMemcpyHtoDAsync_v2( + dstDevice: CUdeviceptr, + srcHost: *const ::std::os::raw::c_void, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoHAsync_v2( + dstHost: *mut ::std::os::raw::c_void, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyDtoDAsync_v2( + dstDevice: CUdeviceptr, + srcDevice: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize) + -> CUresult; +} +extern "C" { + pub fn cuMemsetD16_v2( + dstDevice: CUdeviceptr, + us: ::std::os::raw::c_ushort, + N: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize) + -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D8_v2( + dstDevice: CUdeviceptr, + dstPitch: usize, + uc: ::std::os::raw::c_uchar, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D16_v2( + dstDevice: CUdeviceptr, + dstPitch: usize, + us: ::std::os::raw::c_ushort, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D32_v2( + dstDevice: CUdeviceptr, + dstPitch: usize, + ui: ::std::os::raw::c_uint, + Width: usize, + Height: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult; +} +extern "C" { + pub fn cuMemcpyAsync( + dst: CUdeviceptr, + src: CUdeviceptr, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyPeer( + dstDevice: CUdeviceptr, + dstContext: CUcontext, + srcDevice: CUdeviceptr, + srcContext: CUcontext, + ByteCount: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpyPeerAsync( + dstDevice: CUdeviceptr, + dstContext: CUcontext, + srcDevice: CUdeviceptr, + srcContext: CUcontext, + ByteCount: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult; +} +extern "C" { + pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemsetD8Async( + dstDevice: CUdeviceptr, + uc: ::std::os::raw::c_uchar, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD16Async( + dstDevice: CUdeviceptr, + us: ::std::os::raw::c_ushort, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD32Async( + dstDevice: CUdeviceptr, + ui: ::std::os::raw::c_uint, + N: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D8Async( + dstDevice: CUdeviceptr, + dstPitch: usize, + uc: ::std::os::raw::c_uchar, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D16Async( + dstDevice: CUdeviceptr, + dstPitch: usize, + us: ::std::os::raw::c_ushort, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemsetD2D32Async( + dstDevice: CUdeviceptr, + dstPitch: usize, + ui: ::std::os::raw::c_uint, + Width: usize, + Height: usize, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int) + -> CUresult; +} +extern "C" { + pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult; +} +extern "C" { + pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitEvent( + hStream: CUstream, + hEvent: CUevent, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamAddCallback( + hStream: CUstream, + callback: CUstreamCallback, + userData: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamAttachMemAsync( + hStream: CUstream, + dptr: CUdeviceptr, + length: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamQuery(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuEventRecordWithFlags( + hEvent: CUevent, + hStream: CUstream, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchKernel( + f: CUfunction, + gridDimX: ::std::os::raw::c_uint, + gridDimY: ::std::os::raw::c_uint, + gridDimZ: ::std::os::raw::c_uint, + blockDimX: ::std::os::raw::c_uint, + blockDimY: ::std::os::raw::c_uint, + blockDimZ: ::std::os::raw::c_uint, + sharedMemBytes: ::std::os::raw::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::std::os::raw::c_void, + extra: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchHostFunc( + hStream: CUstream, + fn_: CUhostFn, + userData: *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsMapResources( + count: ::std::os::raw::c_uint, + resources: *mut CUgraphicsResource, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphicsUnmapResources( + count: ::std::os::raw::c_uint, + resources: *mut CUgraphicsResource, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWriteValue32( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint32_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitValue32( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint32_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWriteValue64( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint64_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamWaitValue64( + stream: CUstream, + addr: CUdeviceptr, + value: cuuint64_t, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamBatchMemOp( + stream: CUstream, + count: ::std::os::raw::c_uint, + paramArray: *mut CUstreamBatchMemOpParams, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuMemPrefetchAsync( + devPtr: CUdeviceptr, + count: usize, + dstDevice: CUdevice, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuLaunchCooperativeKernel( + f: CUfunction, + gridDimX: ::std::os::raw::c_uint, + gridDimY: ::std::os::raw::c_uint, + gridDimZ: ::std::os::raw::c_uint, + blockDimX: ::std::os::raw::c_uint, + blockDimY: ::std::os::raw::c_uint, + blockDimZ: ::std::os::raw::c_uint, + sharedMemBytes: ::std::os::raw::c_uint, + hStream: CUstream, + kernelParams: *mut *mut ::std::os::raw::c_void, + ) -> CUresult; +} +extern "C" { + pub fn cuSignalExternalSemaphoresAsync( + extSemArray: *const CUexternalSemaphore, + paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS, + numExtSems: ::std::os::raw::c_uint, + stream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuWaitExternalSemaphoresAsync( + extSemArray: *const CUexternalSemaphore, + paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS, + numExtSems: ::std::os::raw::c_uint, + stream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamBeginCapture(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamBeginCapture_ptsz(hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult; +} +extern "C" { + pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult; +} +extern "C" { + pub fn cuStreamIsCapturing( + hStream: CUstream, + captureStatus: *mut CUstreamCaptureStatus, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetCaptureInfo( + hStream: CUstream, + captureStatus_out: *mut CUstreamCaptureStatus, + id_out: *mut cuuint64_t, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamGetCaptureInfo_v2( + hStream: CUstream, + captureStatus_out: *mut CUstreamCaptureStatus, + id_out: *mut cuuint64_t, + graph_out: *mut CUgraph, + dependencies_out: *mut *const CUgraphNode, + numDependencies_out: *mut usize, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphUpload(hGraph: CUgraphExec, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuGraphLaunch(hGraph: CUgraphExec, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamCopyAttributes(dstStream: CUstream, srcStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuStreamGetAttribute( + hStream: CUstream, + attr: CUstreamAttrID, + value: *mut CUstreamAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamSetAttribute( + hStream: CUstream, + attr: CUstreamAttrID, + param: *const CUstreamAttrValue, + ) -> CUresult; +} +extern "C" { + pub fn cuIpcOpenMemHandle( + pdptr: *mut CUdeviceptr, + handle: CUipcMemHandle, + Flags: ::std::os::raw::c_uint, + ) -> CUresult; +} +extern "C" { + pub fn cuGraphInstantiate( + phGraphExec: *mut CUgraphExec, + hGraph: CUgraph, + phErrorNode: *mut CUgraphNode, + logBuffer: *mut ::std::os::raw::c_char, + bufferSize: usize, + ) -> CUresult; +} +extern "C" { + pub fn cuMemMapArrayAsync( + mapInfoList: *mut CUarrayMapInfo, + count: ::std::os::raw::c_uint, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuMemFreeAsync(dptr: CUdeviceptr, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemAllocAsync(dptr: *mut CUdeviceptr, bytesize: usize, hStream: CUstream) -> CUresult; +} +extern "C" { + pub fn cuMemAllocFromPoolAsync( + dptr: *mut CUdeviceptr, + bytesize: usize, + pool: CUmemoryPool, + hStream: CUstream, + ) -> CUresult; +} +extern "C" { + pub fn cuStreamUpdateCaptureDependencies( + hStream: CUstream, + dependencies: *mut CUgraphNode, + numDependencies: usize, + flags: ::std::os::raw::c_uint, + ) -> CUresult; +} diff --git a/cuda_base/src/lib.rs b/cuda_base/src/lib.rs new file mode 100644 index 0000000..57c7156 --- /dev/null +++ b/cuda_base/src/lib.rs @@ -0,0 +1,485 @@ +extern crate proc_macro; + +use std::collections::hash_map; +use std::iter; + +use proc_macro::TokenStream; +use proc_macro2::Span; +use quote::{format_ident, quote, ToTokens}; +use rustc_hash::{FxHashMap, FxHashSet}; +use syn::parse::{Parse, ParseStream}; +use syn::punctuated::Punctuated; +use syn::token::Brace; +use syn::visit_mut::VisitMut; +use syn::{ + bracketed, parse_macro_input, Abi, Fields, File, FnArg, ForeignItem, ForeignItemFn, Ident, + Item, ItemForeignMod, ItemMacro, LitStr, Macro, MacroDelimiter, PatType, Path, PathArguments, + PathSegment, ReturnType, Signature, Token, Type, TypeArray, TypePath, TypePtr, +}; + +const CUDA_RS: &'static str = include_str! {"cuda.rs"}; + +// This macro copies cuda.rs as-is with some changes: +// * All function declarations are filtered out +// * CUdeviceptr_v2 is redefined from `unsigned long long` to `*void` +// * `extern "C"` gets replaced by `extern "system"` +// * CUuuid_st is redefined to use uchar instead of char +#[proc_macro] +pub fn cuda_type_declarations(_: TokenStream) -> TokenStream { + let mut cuda_module = syn::parse_str::(CUDA_RS).unwrap(); + cuda_module.items = cuda_module + .items + .into_iter() + .filter_map(|item| match item { + Item::ForeignMod(_) => None, + Item::Struct(mut struct_) => { + if "CUdeviceptr_v2" == struct_.ident.to_string() { + match &mut struct_.fields { + Fields::Unnamed(ref mut fields) => { + fields.unnamed[0].ty = + absolute_path_to_mut_ptr(&["std", "os", "raw", "c_void"]) + } + _ => unreachable!(), + } + } else if "CUuuid_st" == struct_.ident.to_string() { + match &mut struct_.fields { + Fields::Named(ref mut fields) => match fields.named[0].ty { + Type::Array(TypeArray { ref mut elem, .. }) => { + *elem = Box::new(Type::Path(TypePath { + qself: None, + path: segments_to_path(&["std", "os", "raw", "c_uchar"]), + })) + } + _ => unreachable!(), + }, + _ => panic!(), + } + } + Some(Item::Struct(struct_)) + } + i => Some(i), + }) + .collect::>(); + syn::visit_mut::visit_file_mut(&mut FixAbi, &mut cuda_module); + cuda_module.into_token_stream().into() +} + +fn segments_to_path(path: &[&'static str]) -> Path { + let mut segments = Punctuated::new(); + for ident in path { + let ident = PathSegment { + ident: Ident::new(ident, Span::call_site()), + arguments: PathArguments::None, + }; + segments.push(ident); + } + Path { + leading_colon: Some(Token![::](Span::call_site())), + segments, + } +} + +fn absolute_path_to_mut_ptr(path: &[&'static str]) -> Type { + Type::Ptr(TypePtr { + star_token: Token![*](Span::call_site()), + const_token: None, + mutability: Some(Token![mut](Span::call_site())), + elem: Box::new(Type::Path(TypePath { + qself: None, + path: segments_to_path(path), + })), + }) +} + +struct FixAbi; + +impl VisitMut for FixAbi { + fn visit_abi_mut(&mut self, i: &mut Abi) { + if let Some(ref mut name) = i.name { + *name = LitStr::new("system", Span::call_site()); + } + } +} + +// This macro accepts following arguments: +// * `type_path`: path to the module with type definitions (in the module tree) +// * `normal_macro`: ident for a normal macro +// * `override_macro`: ident for an override macro +// * `override_fns`: list of override functions +// Then macro goes through every function in rust.rs, and for every fn `foo`: +// * if `foo` is contained in `override_fns` then pass it into `override_macro` +// * if `foo` is not contained in `override_fns` pass it to `normal_macro` +// Both `override_macro` and `normal_macro` expect this format: +// macro_foo!("system" fn cuCtxDetach(ctx: CUcontext) -> CUresult) +// Additionally, it does a fixup of CUDA types so they get prefixed with `type_path` +#[proc_macro] +pub fn cuda_function_declarations(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as FnDeclInput); + let cuda_module = syn::parse_str::(CUDA_RS).unwrap(); + let override_fns = input + .override_fns + .iter() + .map(ToString::to_string) + .collect::>(); + cuda_module + .items + .into_iter() + .filter_map(|item| match item { + Item::ForeignMod(ItemForeignMod { mut items, .. }) => match items.pop().unwrap() { + ForeignItem::Fn(ForeignItemFn { + sig: + Signature { + ident, + inputs, + output, + .. + }, + .. + }) => { + let path = if override_fns.contains(&ident.to_string()) { + &input.override_macro + } else { + &input.normal_macro + } + .clone(); + let inputs = inputs + .into_iter() + .map(|fn_arg| match fn_arg { + FnArg::Typed(mut pat_type) => { + pat_type.ty = + prepend_cuda_path_to_type(&input.type_path, pat_type.ty); + FnArg::Typed(pat_type) + } + _ => unreachable!(), + }) + .collect::>(); + let output = match output { + ReturnType::Type(_, type_) => type_, + ReturnType::Default => unreachable!(), + }; + let type_path = input.type_path.clone(); + let tokens = quote! { + "system" fn #ident(#inputs) -> #type_path :: #output + }; + Some(Item::Macro(ItemMacro { + attrs: Vec::new(), + ident: None, + mac: Macro { + path, + bang_token: Token![!](Span::call_site()), + delimiter: MacroDelimiter::Brace(Brace { + span: Span::call_site(), + }), + tokens, + }, + semi_token: None, + })) + } + _ => unreachable!(), + }, + _ => None, + }) + .map(Item::into_token_stream) + .collect::() + .into() +} + +fn prepend_cuda_path_to_type(base_path: &Path, type_: Box) -> Box { + match *type_ { + Type::Path(mut type_path) => { + type_path.path = prepend_cuda_path_to_path(base_path, type_path.path); + Box::new(Type::Path(type_path)) + } + Type::Ptr(mut type_ptr) => { + type_ptr.elem = prepend_cuda_path_to_type(base_path, type_ptr.elem); + Box::new(Type::Ptr(type_ptr)) + } + _ => unreachable!(), + } +} + +fn prepend_cuda_path_to_path(base_path: &Path, path: Path) -> Path { + if path.leading_colon.is_some() { + return path; + } + if path.segments.len() == 1 { + let ident = path.segments[0].ident.to_string(); + if ident.starts_with("CU") || ident.starts_with("cu") { + let mut base_path = base_path.clone(); + base_path.segments.extend(path.segments); + return base_path; + } + } + path +} + +struct FnDeclInput { + type_path: Path, + normal_macro: Path, + override_macro: Path, + override_fns: Punctuated, +} + +impl Parse for FnDeclInput { + fn parse(input: ParseStream) -> syn::Result { + let type_path = input.parse::()?; + input.parse::()?; + let normal_macro = input.parse::()?; + input.parse::()?; + let override_macro = input.parse::()?; + input.parse::()?; + let override_fns_content; + bracketed!(override_fns_content in input); + let override_fns = override_fns_content.parse_terminated(Ident::parse)?; + Ok(Self { + type_path, + normal_macro, + override_macro, + override_fns, + }) + } +} + +// This trait accepts following parameters: +// * `type_path`: path to the module with type definitions (in the module tree) +// * `trait_`: name of the trait to be derived +// * `ignore_structs`: bracketed list of types to ignore +// * `ignore_fns`: bracketed list of fns to ignore +#[proc_macro] +pub fn cuda_derive_display_trait(tokens: TokenStream) -> TokenStream { + let input = parse_macro_input!(tokens as DeriveDisplayInput); + let cuda_module = syn::parse_str::(CUDA_RS).unwrap(); + let mut derive_state = DeriveDisplayState::new(input); + cuda_module + .items + .into_iter() + .filter_map(|i| cuda_derive_display_trait_for_item(&mut derive_state, i)) + .collect::() + .into() +} + +fn cuda_derive_display_trait_for_item( + state: &mut DeriveDisplayState, + item: Item, +) -> Option { + let path_prefix = &state.type_path; + let path_prefix_iter = iter::repeat(&path_prefix); + let trait_ = &state.trait_; + let trait_iter = iter::repeat(&state.trait_); + match item { + Item::Const(_) => None, + Item::ForeignMod(ItemForeignMod { mut items, .. }) => match items.pop().unwrap() { + ForeignItem::Fn(ForeignItemFn { + sig: Signature { ident, inputs, .. }, + .. + }) => { + if state.ignore_fns.contains(&ident) { + return None; + } + let inputs = inputs + .into_iter() + .map(|fn_arg| match fn_arg { + FnArg::Typed(mut pat_type) => { + pat_type.ty = prepend_cuda_path_to_type(path_prefix, pat_type.ty); + FnArg::Typed(pat_type) + } + _ => unreachable!(), + }) + .collect::>(); + let inputs_iter = inputs.iter(); + let mut arg_name_iter = inputs.iter().map(|fn_arg| match fn_arg { + FnArg::Typed(PatType { pat, .. }) => pat, + _ => unreachable!(), + }); + let fn_name = format_ident!("write_{}", ident); + Some(match arg_name_iter.next() { + Some(first_arg_name) => quote! { + pub fn #fn_name(writer: &mut (impl std::io::Write + ?Sized), #(#inputs_iter,)*) -> std::io::Result<()> { + writer.write_all(concat!("(", stringify!(#first_arg_name), ": ").as_bytes())?; + CudaDisplay::write(&#first_arg_name, writer)?; + #( + writer.write_all(b", ")?; + writer.write_all(concat!(stringify!(#arg_name_iter), ": ").as_bytes())?; + CudaDisplay::write(&#arg_name_iter, writer)?; + )* + writer.write_all(b")") + } + }, + None => quote! { + pub fn #fn_name(writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"()") + } + }, + }) + } + _ => unreachable!(), + }, + Item::Impl(mut item_impl) => { + let enum_ = match *(item_impl.self_ty) { + Type::Path(mut path) => path.path.segments.pop().unwrap().into_value().ident, + _ => unreachable!(), + }; + let variant_ = match item_impl.items.pop().unwrap() { + syn::ImplItem::Const(item_const) => item_const.ident, + _ => unreachable!(), + }; + state.record_enum_variant(enum_, variant_); + None + } + Item::Struct(item_struct) => { + let item_struct_name = item_struct.ident.to_string(); + if state.ignore_structs.contains(&item_struct.ident) { + return None; + } + if item_struct_name.ends_with("_enum") { + let enum_ = &item_struct.ident; + let enum_iter = iter::repeat(&item_struct.ident); + let variants = state.enums.get(&item_struct.ident).unwrap().iter(); + Some(quote! { + impl #trait_ for #path_prefix :: #enum_ { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + match self { + #(& #path_prefix_iter :: #enum_iter :: #variants => writer.write_all(stringify!(#variants).as_bytes()),)* + _ => write!(writer, "{}", self.0) + } + } + } + }) + } else { + let struct_ = &item_struct.ident; + let (first_field, rest_of_fields) = match item_struct.fields { + Fields::Named(fields) => { + let mut all_idents = fields.named.into_iter().filter_map(|f| { + let f_ident = f.ident.unwrap(); + let name = f_ident.to_string(); + if name.starts_with("reserved") || name == "_unused" { + None + } else { + Some(f_ident) + } + }); + let first = match all_idents.next() { + Some(f) => f, + None => return None, + }; + (first, all_idents) + } + _ => return None, + }; + Some(quote! { + impl #trait_ for #path_prefix :: #struct_ { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(concat!("{ ", stringify!(#first_field), ": ").as_bytes())?; + #trait_::write(&self.#first_field, writer)?; + #( + writer.write_all(concat!(", ", stringify!(#rest_of_fields), ": ").as_bytes())?; + #trait_iter::write(&self.#rest_of_fields, writer)?; + )* + writer.write_all(b" }") + } + } + }) + } + } + Item::Type(item_type) => match *(item_type.ty) { + Type::Ptr(_) => { + let type_ = item_type.ident; + Some(quote! { + impl #trait_ for #path_prefix :: #type_ { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", *self) + } + } + }) + } + Type::Path(type_path) => { + if type_path.path.leading_colon.is_some() { + let option_seg = type_path.path.segments.last().unwrap(); + if option_seg.ident == "Option" { + match &option_seg.arguments { + PathArguments::AngleBracketed(generic) => match generic.args[0] { + syn::GenericArgument::Type(Type::BareFn(_)) => { + let type_ = &item_type.ident; + return Some(quote! { + impl #trait_ for #path_prefix :: #type_ { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", unsafe { std::mem::transmute::<#path_prefix :: #type_, *mut ::std::ffi::c_void>(*self) }) + } + } + }); + } + _ => unreachable!(), + }, + _ => unreachable!(), + } + } + } + None + } + _ => unreachable!(), + }, + Item::Union(_) => None, + Item::Use(_) => None, + _ => unreachable!(), + } +} + +struct DeriveDisplayState { + type_path: Path, + trait_: Path, + ignore_structs: FxHashSet, + ignore_fns: FxHashSet, + enums: FxHashMap>, +} + +impl DeriveDisplayState { + fn new(input: DeriveDisplayInput) -> Self { + DeriveDisplayState { + type_path: input.type_path, + trait_: input.trait_, + ignore_structs: input.ignore_structs.into_iter().collect(), + ignore_fns: input.ignore_fns.into_iter().collect(), + enums: Default::default(), + } + } + + fn record_enum_variant(&mut self, enum_: Ident, variant: Ident) { + match self.enums.entry(enum_) { + hash_map::Entry::Occupied(mut entry) => { + entry.get_mut().push(variant); + } + hash_map::Entry::Vacant(entry) => { + entry.insert(vec![variant]); + } + } + } +} + +struct DeriveDisplayInput { + type_path: Path, + trait_: Path, + ignore_structs: Punctuated, + ignore_fns: Punctuated, +} + +impl Parse for DeriveDisplayInput { + fn parse(input: ParseStream) -> syn::Result { + let type_path = input.parse::()?; + input.parse::()?; + let trait_ = input.parse::()?; + input.parse::()?; + let ignore_structs_buffer; + bracketed!(ignore_structs_buffer in input); + let ignore_structs = ignore_structs_buffer.parse_terminated(Ident::parse)?; + input.parse::()?; + let ignore_fns_buffer; + bracketed!(ignore_fns_buffer in input); + let ignore_fns = ignore_fns_buffer.parse_terminated(Ident::parse)?; + Ok(Self { + type_path, + trait_, + ignore_structs, + ignore_fns, + }) + } +} diff --git a/cuda_types/Cargo.toml b/cuda_types/Cargo.toml new file mode 100644 index 0000000..e779830 --- /dev/null +++ b/cuda_types/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "cuda_types" +version = "0.0.0" +authors = ["Andrzej Janik "] +edition = "2018" + +[dependencies] +cuda_base = { path = "../cuda_base" } diff --git a/cuda_types/src/lib.rs b/cuda_types/src/lib.rs new file mode 100644 index 0000000..6d24020 --- /dev/null +++ b/cuda_types/src/lib.rs @@ -0,0 +1,3 @@ +use cuda_base::cuda_type_declarations; + +cuda_type_declarations!(); \ No newline at end of file diff --git a/zluda_dump/Cargo.toml b/zluda_dump/Cargo.toml index b8f82ac..89381aa 100644 --- a/zluda_dump/Cargo.toml +++ b/zluda_dump/Cargo.toml @@ -18,6 +18,8 @@ lazy_static = "1.4" # we don't need elf32, but goblin has a bug where elf64 does not build without elf32 goblin = { version = "0.4", default-features = false, features = ["elf64", "elf32", "archive"] } paste = "1.0" +cuda_base = { path = "../cuda_base" } +cuda_types = { path = "../cuda_types" } [target.'cfg(windows)'.dependencies] winapi = { version = "0.3", features = ["libloaderapi", "debugapi", "std"] } diff --git a/zluda_dump/src/cuda.rs b/zluda_dump/src/cuda.rs deleted file mode 100644 index 3836137..0000000 --- a/zluda_dump/src/cuda.rs +++ /dev/null @@ -1,4417 +0,0 @@ -/* automatically generated by rust-bindgen 0.56.0 */ - -pub type __uint32_t = ::std::os::raw::c_uint; -pub type __uint64_t = ::std::os::raw::c_ulong; -pub type cuuint32_t = u32; -pub type cuuint64_t = u64; -#[repr(transparent)] -#[derive(Copy, Clone)] -pub struct CUdeviceptr(pub usize); -#[repr(transparent)] -#[derive(Copy, Clone)] -pub struct CUdevice(pub ::std::os::raw::c_int); -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUctx_st { - _unused: [u8; 0], -} -pub type CUcontext = *mut CUctx_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmod_st { - _unused: [u8; 0], -} -pub type CUmodule = *mut CUmod_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUfunc_st { - _unused: [u8; 0], -} -pub type CUfunction = *mut CUfunc_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUarray_st { - _unused: [u8; 0], -} -pub type CUarray = *mut CUarray_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmipmappedArray_st { - _unused: [u8; 0], -} -pub type CUmipmappedArray = *mut CUmipmappedArray_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUtexref_st { - _unused: [u8; 0], -} -pub type CUtexref = *mut CUtexref_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUsurfref_st { - _unused: [u8; 0], -} -pub type CUsurfref = *mut CUsurfref_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUevent_st { - _unused: [u8; 0], -} -pub type CUevent = *mut CUevent_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUstream_st { - _unused: [u8; 0], -} -pub type CUstream = *mut CUstream_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUgraphicsResource_st { - _unused: [u8; 0], -} -pub type CUgraphicsResource = *mut CUgraphicsResource_st; -pub type CUtexObject = ::std::os::raw::c_ulonglong; -pub type CUsurfObject = ::std::os::raw::c_ulonglong; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUextMemory_st { - _unused: [u8; 0], -} -pub type CUexternalMemory = *mut CUextMemory_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUextSemaphore_st { - _unused: [u8; 0], -} -pub type CUexternalSemaphore = *mut CUextSemaphore_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUgraph_st { - _unused: [u8; 0], -} -pub type CUgraph = *mut CUgraph_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUgraphNode_st { - _unused: [u8; 0], -} -pub type CUgraphNode = *mut CUgraphNode_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUgraphExec_st { - _unused: [u8; 0], -} -pub type CUgraphExec = *mut CUgraphExec_st; -#[repr(C)] -#[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub struct CUuuid_st { - pub bytes: [::std::os::raw::c_uchar; 16usize], -} -pub type CUuuid = CUuuid_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUipcEventHandle_st { - pub reserved: [::std::os::raw::c_char; 64usize], -} -pub type CUipcEventHandle = CUipcEventHandle_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUipcMemHandle_st { - pub reserved: [::std::os::raw::c_char; 64usize], -} -pub type CUipcMemHandle = CUipcMemHandle_st; -impl CUstreamBatchMemOpType_enum { - pub const CU_STREAM_MEM_OP_WAIT_VALUE_32: CUstreamBatchMemOpType_enum = - CUstreamBatchMemOpType_enum(1); -} -impl CUstreamBatchMemOpType_enum { - pub const CU_STREAM_MEM_OP_WRITE_VALUE_32: CUstreamBatchMemOpType_enum = - CUstreamBatchMemOpType_enum(2); -} -impl CUstreamBatchMemOpType_enum { - pub const CU_STREAM_MEM_OP_WAIT_VALUE_64: CUstreamBatchMemOpType_enum = - CUstreamBatchMemOpType_enum(4); -} -impl CUstreamBatchMemOpType_enum { - pub const CU_STREAM_MEM_OP_WRITE_VALUE_64: CUstreamBatchMemOpType_enum = - CUstreamBatchMemOpType_enum(5); -} -impl CUstreamBatchMemOpType_enum { - pub const CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES: CUstreamBatchMemOpType_enum = - CUstreamBatchMemOpType_enum(3); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUstreamBatchMemOpType_enum(pub ::std::os::raw::c_uint); -pub use self::CUstreamBatchMemOpType_enum as CUstreamBatchMemOpType; -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUstreamBatchMemOpParams_union { - pub operation: CUstreamBatchMemOpType, - pub waitValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st, - pub writeValue: CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st, - pub flushRemoteWrites: CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st, - pub pad: [cuuint64_t; 6usize], - _bindgen_union_align: [u64; 6usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st { - pub operation: CUstreamBatchMemOpType, - pub address: CUdeviceptr, - pub __bindgen_anon_1: - CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, - pub alias: CUdeviceptr, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1 { - pub value: cuuint32_t, - pub value64: cuuint64_t, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st { - pub operation: CUstreamBatchMemOpType, - pub address: CUdeviceptr, - pub __bindgen_anon_1: - CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, - pub alias: CUdeviceptr, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st__bindgen_ty_1 { - pub value: cuuint32_t, - pub value64: cuuint64_t, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUstreamBatchMemOpParams_union_CUstreamMemOpFlushRemoteWritesParams_st { - pub operation: CUstreamBatchMemOpType, - pub flags: ::std::os::raw::c_uint, -} -pub type CUstreamBatchMemOpParams = CUstreamBatchMemOpParams_union; -impl CUarray_format_enum { - pub const CU_AD_FORMAT_UNSIGNED_INT8: CUarray_format_enum = CUarray_format_enum(1); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_UNSIGNED_INT16: CUarray_format_enum = CUarray_format_enum(2); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_UNSIGNED_INT32: CUarray_format_enum = CUarray_format_enum(3); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_SIGNED_INT8: CUarray_format_enum = CUarray_format_enum(8); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_SIGNED_INT16: CUarray_format_enum = CUarray_format_enum(9); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_SIGNED_INT32: CUarray_format_enum = CUarray_format_enum(10); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_HALF: CUarray_format_enum = CUarray_format_enum(16); -} -impl CUarray_format_enum { - pub const CU_AD_FORMAT_FLOAT: CUarray_format_enum = CUarray_format_enum(32); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUarray_format_enum(pub ::std::os::raw::c_uint); -pub use self::CUarray_format_enum as CUarray_format; -impl CUaddress_mode_enum { - pub const CU_TR_ADDRESS_MODE_WRAP: CUaddress_mode_enum = CUaddress_mode_enum(0); -} -impl CUaddress_mode_enum { - pub const CU_TR_ADDRESS_MODE_CLAMP: CUaddress_mode_enum = CUaddress_mode_enum(1); -} -impl CUaddress_mode_enum { - pub const CU_TR_ADDRESS_MODE_MIRROR: CUaddress_mode_enum = CUaddress_mode_enum(2); -} -impl CUaddress_mode_enum { - pub const CU_TR_ADDRESS_MODE_BORDER: CUaddress_mode_enum = CUaddress_mode_enum(3); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUaddress_mode_enum(pub ::std::os::raw::c_uint); -pub use self::CUaddress_mode_enum as CUaddress_mode; -impl CUfilter_mode_enum { - pub const CU_TR_FILTER_MODE_POINT: CUfilter_mode_enum = CUfilter_mode_enum(0); -} -impl CUfilter_mode_enum { - pub const CU_TR_FILTER_MODE_LINEAR: CUfilter_mode_enum = CUfilter_mode_enum(1); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUfilter_mode_enum(pub ::std::os::raw::c_uint); -pub use self::CUfilter_mode_enum as CUfilter_mode; -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(1); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X: CUdevice_attribute_enum = - CUdevice_attribute_enum(2); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y: CUdevice_attribute_enum = - CUdevice_attribute_enum(3); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z: CUdevice_attribute_enum = - CUdevice_attribute_enum(4); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X: CUdevice_attribute_enum = - CUdevice_attribute_enum(5); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y: CUdevice_attribute_enum = - CUdevice_attribute_enum(6); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z: CUdevice_attribute_enum = - CUdevice_attribute_enum(7); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(8); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(8); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY: CUdevice_attribute_enum = - CUdevice_attribute_enum(9); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_WARP_SIZE: CUdevice_attribute_enum = CUdevice_attribute_enum(10); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_PITCH: CUdevice_attribute_enum = CUdevice_attribute_enum(11); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(12); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(12); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CLOCK_RATE: CUdevice_attribute_enum = CUdevice_attribute_enum(13); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT: CUdevice_attribute_enum = - CUdevice_attribute_enum(14); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_GPU_OVERLAP: CUdevice_attribute_enum = - CUdevice_attribute_enum(15); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT: CUdevice_attribute_enum = - CUdevice_attribute_enum(16); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT: CUdevice_attribute_enum = - CUdevice_attribute_enum(17); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_INTEGRATED: CUdevice_attribute_enum = CUdevice_attribute_enum(18); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY: CUdevice_attribute_enum = - CUdevice_attribute_enum(19); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COMPUTE_MODE: CUdevice_attribute_enum = - CUdevice_attribute_enum(20); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(21); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(22); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(23); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(24); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(25); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(26); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(27); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(28); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(29); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(27); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(28); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES: CUdevice_attribute_enum = - CUdevice_attribute_enum(29); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT: CUdevice_attribute_enum = - CUdevice_attribute_enum(30); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS: CUdevice_attribute_enum = - CUdevice_attribute_enum(31); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_ECC_ENABLED: CUdevice_attribute_enum = - CUdevice_attribute_enum(32); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_PCI_BUS_ID: CUdevice_attribute_enum = CUdevice_attribute_enum(33); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: CUdevice_attribute_enum = - CUdevice_attribute_enum(34); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_TCC_DRIVER: CUdevice_attribute_enum = CUdevice_attribute_enum(35); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: CUdevice_attribute_enum = - CUdevice_attribute_enum(36); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(37); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: CUdevice_attribute_enum = - CUdevice_attribute_enum(38); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(39); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT: CUdevice_attribute_enum = - CUdevice_attribute_enum(40); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: CUdevice_attribute_enum = - CUdevice_attribute_enum(41); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(42); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(43); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER: CUdevice_attribute_enum = - CUdevice_attribute_enum(44); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(45); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(46); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: CUdevice_attribute_enum = - CUdevice_attribute_enum(47); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: CUdevice_attribute_enum = - CUdevice_attribute_enum(48); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: CUdevice_attribute_enum = - CUdevice_attribute_enum(49); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID: CUdevice_attribute_enum = - CUdevice_attribute_enum(50); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT: CUdevice_attribute_enum = - CUdevice_attribute_enum(51); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(52); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(53); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(54); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(55); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(56); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(57); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(58); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(59); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(60); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(61); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(62); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(63); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(64); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(65); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(66); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(67); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS: CUdevice_attribute_enum = - CUdevice_attribute_enum(68); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(69); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(70); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(71); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH: CUdevice_attribute_enum = - CUdevice_attribute_enum(72); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(73); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT: CUdevice_attribute_enum = - CUdevice_attribute_enum(74); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(75); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(76); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: CUdevice_attribute_enum = - CUdevice_attribute_enum(77); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(78); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(79); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(80); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(81); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(82); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: CUdevice_attribute_enum = - CUdevice_attribute_enum(83); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: CUdevice_attribute_enum = - CUdevice_attribute_enum(84); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: CUdevice_attribute_enum = - CUdevice_attribute_enum(85); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(86); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: CUdevice_attribute_enum = - CUdevice_attribute_enum(87); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: CUdevice_attribute_enum = - CUdevice_attribute_enum(88); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: CUdevice_attribute_enum = - CUdevice_attribute_enum(89); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(90); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: CUdevice_attribute_enum = - CUdevice_attribute_enum(91); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS: CUdevice_attribute_enum = - CUdevice_attribute_enum(92); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS: CUdevice_attribute_enum = - CUdevice_attribute_enum(93); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(94); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH: CUdevice_attribute_enum = - CUdevice_attribute_enum(95); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH: CUdevice_attribute_enum = - CUdevice_attribute_enum(96); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: CUdevice_attribute_enum = - CUdevice_attribute_enum(97); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES: CUdevice_attribute_enum = - CUdevice_attribute_enum(98); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(99); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES: - CUdevice_attribute_enum = CUdevice_attribute_enum(100); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST: CUdevice_attribute_enum = - CUdevice_attribute_enum(101); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(102); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED: - CUdevice_attribute_enum = CUdevice_attribute_enum(103); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(104); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(105); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR: CUdevice_attribute_enum = - CUdevice_attribute_enum(106); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(107); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE: CUdevice_attribute_enum = - CUdevice_attribute_enum(108); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE: CUdevice_attribute_enum = - CUdevice_attribute_enum(109); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(110); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK: CUdevice_attribute_enum = - CUdevice_attribute_enum(111); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(112); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED: CUdevice_attribute_enum = - CUdevice_attribute_enum(113); -} -impl CUdevice_attribute_enum { - pub const CU_DEVICE_ATTRIBUTE_MAX: CUdevice_attribute_enum = CUdevice_attribute_enum(114); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUdevice_attribute_enum(pub ::std::os::raw::c_uint); -pub use self::CUdevice_attribute_enum as CUdevice_attribute; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUdevprop_st { - pub maxThreadsPerBlock: ::std::os::raw::c_int, - pub maxThreadsDim: [::std::os::raw::c_int; 3usize], - pub maxGridSize: [::std::os::raw::c_int; 3usize], - pub sharedMemPerBlock: ::std::os::raw::c_int, - pub totalConstantMemory: ::std::os::raw::c_int, - pub SIMDWidth: ::std::os::raw::c_int, - pub memPitch: ::std::os::raw::c_int, - pub regsPerBlock: ::std::os::raw::c_int, - pub clockRate: ::std::os::raw::c_int, - pub textureAlign: ::std::os::raw::c_int, -} -pub type CUdevprop = CUdevprop_st; -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_CONTEXT: CUpointer_attribute_enum = CUpointer_attribute_enum(1); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_MEMORY_TYPE: CUpointer_attribute_enum = - CUpointer_attribute_enum(2); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_DEVICE_POINTER: CUpointer_attribute_enum = - CUpointer_attribute_enum(3); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_HOST_POINTER: CUpointer_attribute_enum = - CUpointer_attribute_enum(4); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_P2P_TOKENS: CUpointer_attribute_enum = - CUpointer_attribute_enum(5); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: CUpointer_attribute_enum = - CUpointer_attribute_enum(6); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_BUFFER_ID: CUpointer_attribute_enum = - CUpointer_attribute_enum(7); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_IS_MANAGED: CUpointer_attribute_enum = - CUpointer_attribute_enum(8); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL: CUpointer_attribute_enum = - CUpointer_attribute_enum(9); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE: CUpointer_attribute_enum = - CUpointer_attribute_enum(10); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_RANGE_START_ADDR: CUpointer_attribute_enum = - CUpointer_attribute_enum(11); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_RANGE_SIZE: CUpointer_attribute_enum = - CUpointer_attribute_enum(12); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_MAPPED: CUpointer_attribute_enum = CUpointer_attribute_enum(13); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES: CUpointer_attribute_enum = - CUpointer_attribute_enum(14); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE: CUpointer_attribute_enum = - CUpointer_attribute_enum(15); -} -impl CUpointer_attribute_enum { - pub const CU_POINTER_ATTRIBUTE_ACCESS_FLAGS: CUpointer_attribute_enum = - CUpointer_attribute_enum(16); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUpointer_attribute_enum(pub ::std::os::raw::c_uint); -pub use self::CUpointer_attribute_enum as CUpointer_attribute; -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: CUfunction_attribute_enum = - CUfunction_attribute_enum(0); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: CUfunction_attribute_enum = - CUfunction_attribute_enum(1); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: CUfunction_attribute_enum = - CUfunction_attribute_enum(2); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: CUfunction_attribute_enum = - CUfunction_attribute_enum(3); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_NUM_REGS: CUfunction_attribute_enum = CUfunction_attribute_enum(4); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_PTX_VERSION: CUfunction_attribute_enum = - CUfunction_attribute_enum(5); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_BINARY_VERSION: CUfunction_attribute_enum = - CUfunction_attribute_enum(6); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_CACHE_MODE_CA: CUfunction_attribute_enum = - CUfunction_attribute_enum(7); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: CUfunction_attribute_enum = - CUfunction_attribute_enum(8); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: CUfunction_attribute_enum = - CUfunction_attribute_enum(9); -} -impl CUfunction_attribute_enum { - pub const CU_FUNC_ATTRIBUTE_MAX: CUfunction_attribute_enum = CUfunction_attribute_enum(10); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUfunction_attribute_enum(pub ::std::os::raw::c_uint); -pub use self::CUfunction_attribute_enum as CUfunction_attribute; -impl CUfunc_cache_enum { - pub const CU_FUNC_CACHE_PREFER_NONE: CUfunc_cache_enum = CUfunc_cache_enum(0); -} -impl CUfunc_cache_enum { - pub const CU_FUNC_CACHE_PREFER_SHARED: CUfunc_cache_enum = CUfunc_cache_enum(1); -} -impl CUfunc_cache_enum { - pub const CU_FUNC_CACHE_PREFER_L1: CUfunc_cache_enum = CUfunc_cache_enum(2); -} -impl CUfunc_cache_enum { - pub const CU_FUNC_CACHE_PREFER_EQUAL: CUfunc_cache_enum = CUfunc_cache_enum(3); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUfunc_cache_enum(pub ::std::os::raw::c_uint); -pub use self::CUfunc_cache_enum as CUfunc_cache; -impl CUsharedconfig_enum { - pub const CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: CUsharedconfig_enum = CUsharedconfig_enum(0); -} -impl CUsharedconfig_enum { - pub const CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: CUsharedconfig_enum = - CUsharedconfig_enum(1); -} -impl CUsharedconfig_enum { - pub const CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: CUsharedconfig_enum = - CUsharedconfig_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUsharedconfig_enum(pub ::std::os::raw::c_uint); -pub use self::CUsharedconfig_enum as CUsharedconfig; -impl CUmemorytype_enum { - pub const CU_MEMORYTYPE_HOST: CUmemorytype_enum = CUmemorytype_enum(1); -} -impl CUmemorytype_enum { - pub const CU_MEMORYTYPE_DEVICE: CUmemorytype_enum = CUmemorytype_enum(2); -} -impl CUmemorytype_enum { - pub const CU_MEMORYTYPE_ARRAY: CUmemorytype_enum = CUmemorytype_enum(3); -} -impl CUmemorytype_enum { - pub const CU_MEMORYTYPE_UNIFIED: CUmemorytype_enum = CUmemorytype_enum(4); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemorytype_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemorytype_enum as CUmemorytype; -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_SET_READ_MOSTLY: CUmem_advise_enum = CUmem_advise_enum(1); -} -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_UNSET_READ_MOSTLY: CUmem_advise_enum = CUmem_advise_enum(2); -} -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_SET_PREFERRED_LOCATION: CUmem_advise_enum = CUmem_advise_enum(3); -} -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: CUmem_advise_enum = CUmem_advise_enum(4); -} -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_SET_ACCESSED_BY: CUmem_advise_enum = CUmem_advise_enum(5); -} -impl CUmem_advise_enum { - pub const CU_MEM_ADVISE_UNSET_ACCESSED_BY: CUmem_advise_enum = CUmem_advise_enum(6); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmem_advise_enum(pub ::std::os::raw::c_uint); -pub use self::CUmem_advise_enum as CUmem_advise; -impl CUmem_range_attribute_enum { - pub const CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: CUmem_range_attribute_enum = - CUmem_range_attribute_enum(1); -} -impl CUmem_range_attribute_enum { - pub const CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: CUmem_range_attribute_enum = - CUmem_range_attribute_enum(2); -} -impl CUmem_range_attribute_enum { - pub const CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: CUmem_range_attribute_enum = - CUmem_range_attribute_enum(3); -} -impl CUmem_range_attribute_enum { - pub const CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: CUmem_range_attribute_enum = - CUmem_range_attribute_enum(4); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmem_range_attribute_enum(pub ::std::os::raw::c_uint); -pub use self::CUmem_range_attribute_enum as CUmem_range_attribute; -impl CUjit_option_enum { - pub const CU_JIT_MAX_REGISTERS: CUjit_option_enum = CUjit_option_enum(0); -} -impl CUjit_option_enum { - pub const CU_JIT_THREADS_PER_BLOCK: CUjit_option_enum = CUjit_option_enum(1); -} -impl CUjit_option_enum { - pub const CU_JIT_WALL_TIME: CUjit_option_enum = CUjit_option_enum(2); -} -impl CUjit_option_enum { - pub const CU_JIT_INFO_LOG_BUFFER: CUjit_option_enum = CUjit_option_enum(3); -} -impl CUjit_option_enum { - pub const CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES: CUjit_option_enum = CUjit_option_enum(4); -} -impl CUjit_option_enum { - pub const CU_JIT_ERROR_LOG_BUFFER: CUjit_option_enum = CUjit_option_enum(5); -} -impl CUjit_option_enum { - pub const CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES: CUjit_option_enum = CUjit_option_enum(6); -} -impl CUjit_option_enum { - pub const CU_JIT_OPTIMIZATION_LEVEL: CUjit_option_enum = CUjit_option_enum(7); -} -impl CUjit_option_enum { - pub const CU_JIT_TARGET_FROM_CUCONTEXT: CUjit_option_enum = CUjit_option_enum(8); -} -impl CUjit_option_enum { - pub const CU_JIT_TARGET: CUjit_option_enum = CUjit_option_enum(9); -} -impl CUjit_option_enum { - pub const CU_JIT_FALLBACK_STRATEGY: CUjit_option_enum = CUjit_option_enum(10); -} -impl CUjit_option_enum { - pub const CU_JIT_GENERATE_DEBUG_INFO: CUjit_option_enum = CUjit_option_enum(11); -} -impl CUjit_option_enum { - pub const CU_JIT_LOG_VERBOSE: CUjit_option_enum = CUjit_option_enum(12); -} -impl CUjit_option_enum { - pub const CU_JIT_GENERATE_LINE_INFO: CUjit_option_enum = CUjit_option_enum(13); -} -impl CUjit_option_enum { - pub const CU_JIT_CACHE_MODE: CUjit_option_enum = CUjit_option_enum(14); -} -impl CUjit_option_enum { - pub const CU_JIT_NEW_SM3X_OPT: CUjit_option_enum = CUjit_option_enum(15); -} -impl CUjit_option_enum { - pub const CU_JIT_FAST_COMPILE: CUjit_option_enum = CUjit_option_enum(16); -} -impl CUjit_option_enum { - pub const CU_JIT_GLOBAL_SYMBOL_NAMES: CUjit_option_enum = CUjit_option_enum(17); -} -impl CUjit_option_enum { - pub const CU_JIT_GLOBAL_SYMBOL_ADDRESSES: CUjit_option_enum = CUjit_option_enum(18); -} -impl CUjit_option_enum { - pub const CU_JIT_GLOBAL_SYMBOL_COUNT: CUjit_option_enum = CUjit_option_enum(19); -} -impl CUjit_option_enum { - pub const CU_JIT_NUM_OPTIONS: CUjit_option_enum = CUjit_option_enum(20); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUjit_option_enum(pub ::std::os::raw::c_uint); -pub use self::CUjit_option_enum as CUjit_option; -impl CUjitInputType_enum { - pub const CU_JIT_INPUT_CUBIN: CUjitInputType_enum = CUjitInputType_enum(0); -} -impl CUjitInputType_enum { - pub const CU_JIT_INPUT_PTX: CUjitInputType_enum = CUjitInputType_enum(1); -} -impl CUjitInputType_enum { - pub const CU_JIT_INPUT_FATBINARY: CUjitInputType_enum = CUjitInputType_enum(2); -} -impl CUjitInputType_enum { - pub const CU_JIT_INPUT_OBJECT: CUjitInputType_enum = CUjitInputType_enum(3); -} -impl CUjitInputType_enum { - pub const CU_JIT_INPUT_LIBRARY: CUjitInputType_enum = CUjitInputType_enum(4); -} -impl CUjitInputType_enum { - pub const CU_JIT_NUM_INPUT_TYPES: CUjitInputType_enum = CUjitInputType_enum(5); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUjitInputType_enum(pub ::std::os::raw::c_uint); -pub use self::CUjitInputType_enum as CUjitInputType; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUlinkState_st { - _unused: [u8; 0], -} -pub type CUlinkState = *mut CUlinkState_st; -impl CUlimit_enum { - pub const CU_LIMIT_STACK_SIZE: CUlimit_enum = CUlimit_enum(0); -} -impl CUlimit_enum { - pub const CU_LIMIT_PRINTF_FIFO_SIZE: CUlimit_enum = CUlimit_enum(1); -} -impl CUlimit_enum { - pub const CU_LIMIT_MALLOC_HEAP_SIZE: CUlimit_enum = CUlimit_enum(2); -} -impl CUlimit_enum { - pub const CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH: CUlimit_enum = CUlimit_enum(3); -} -impl CUlimit_enum { - pub const CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT: CUlimit_enum = CUlimit_enum(4); -} -impl CUlimit_enum { - pub const CU_LIMIT_MAX_L2_FETCH_GRANULARITY: CUlimit_enum = CUlimit_enum(5); -} -impl CUlimit_enum { - pub const CU_LIMIT_PERSISTING_L2_CACHE_SIZE: CUlimit_enum = CUlimit_enum(6); -} -impl CUlimit_enum { - pub const CU_LIMIT_MAX: CUlimit_enum = CUlimit_enum(7); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUlimit_enum(pub ::std::os::raw::c_uint); -pub use self::CUlimit_enum as CUlimit; -impl CUresourcetype_enum { - pub const CU_RESOURCE_TYPE_ARRAY: CUresourcetype_enum = CUresourcetype_enum(0); -} -impl CUresourcetype_enum { - pub const CU_RESOURCE_TYPE_MIPMAPPED_ARRAY: CUresourcetype_enum = CUresourcetype_enum(1); -} -impl CUresourcetype_enum { - pub const CU_RESOURCE_TYPE_LINEAR: CUresourcetype_enum = CUresourcetype_enum(2); -} -impl CUresourcetype_enum { - pub const CU_RESOURCE_TYPE_PITCH2D: CUresourcetype_enum = CUresourcetype_enum(3); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUresourcetype_enum(pub ::std::os::raw::c_uint); -pub use self::CUresourcetype_enum as CUresourcetype; -pub type CUhostFn = - ::std::option::Option; -impl CUaccessProperty_enum { - pub const CU_ACCESS_PROPERTY_NORMAL: CUaccessProperty_enum = CUaccessProperty_enum(0); -} -impl CUaccessProperty_enum { - pub const CU_ACCESS_PROPERTY_STREAMING: CUaccessProperty_enum = CUaccessProperty_enum(1); -} -impl CUaccessProperty_enum { - pub const CU_ACCESS_PROPERTY_PERSISTING: CUaccessProperty_enum = CUaccessProperty_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUaccessProperty_enum(pub ::std::os::raw::c_uint); -pub use self::CUaccessProperty_enum as CUaccessProperty; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUaccessPolicyWindow_st { - pub base_ptr: *mut ::std::os::raw::c_void, - pub num_bytes: usize, - pub hitRatio: f32, - pub hitProp: CUaccessProperty, - pub missProp: CUaccessProperty, -} -pub type CUaccessPolicyWindow = CUaccessPolicyWindow_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_KERNEL_NODE_PARAMS_st { - pub func: CUfunction, - pub gridDimX: ::std::os::raw::c_uint, - pub gridDimY: ::std::os::raw::c_uint, - pub gridDimZ: ::std::os::raw::c_uint, - pub blockDimX: ::std::os::raw::c_uint, - pub blockDimY: ::std::os::raw::c_uint, - pub blockDimZ: ::std::os::raw::c_uint, - pub sharedMemBytes: ::std::os::raw::c_uint, - pub kernelParams: *mut *mut ::std::os::raw::c_void, - pub extra: *mut *mut ::std::os::raw::c_void, -} -pub type CUDA_KERNEL_NODE_PARAMS = CUDA_KERNEL_NODE_PARAMS_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_MEMSET_NODE_PARAMS_st { - pub dst: CUdeviceptr, - pub pitch: usize, - pub value: ::std::os::raw::c_uint, - pub elementSize: ::std::os::raw::c_uint, - pub width: usize, - pub height: usize, -} -pub type CUDA_MEMSET_NODE_PARAMS = CUDA_MEMSET_NODE_PARAMS_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_HOST_NODE_PARAMS_st { - pub fn_: CUhostFn, - pub userData: *mut ::std::os::raw::c_void, -} -pub type CUDA_HOST_NODE_PARAMS = CUDA_HOST_NODE_PARAMS_st; -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_KERNEL: CUgraphNodeType_enum = CUgraphNodeType_enum(0); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_MEMCPY: CUgraphNodeType_enum = CUgraphNodeType_enum(1); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_MEMSET: CUgraphNodeType_enum = CUgraphNodeType_enum(2); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_HOST: CUgraphNodeType_enum = CUgraphNodeType_enum(3); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_GRAPH: CUgraphNodeType_enum = CUgraphNodeType_enum(4); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_EMPTY: CUgraphNodeType_enum = CUgraphNodeType_enum(5); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_WAIT_EVENT: CUgraphNodeType_enum = CUgraphNodeType_enum(6); -} -impl CUgraphNodeType_enum { - pub const CU_GRAPH_NODE_TYPE_EVENT_RECORD: CUgraphNodeType_enum = CUgraphNodeType_enum(7); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUgraphNodeType_enum(pub ::std::os::raw::c_uint); -pub use self::CUgraphNodeType_enum as CUgraphNodeType; -impl CUsynchronizationPolicy_enum { - pub const CU_SYNC_POLICY_AUTO: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(1); -} -impl CUsynchronizationPolicy_enum { - pub const CU_SYNC_POLICY_SPIN: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(2); -} -impl CUsynchronizationPolicy_enum { - pub const CU_SYNC_POLICY_YIELD: CUsynchronizationPolicy_enum = CUsynchronizationPolicy_enum(3); -} -impl CUsynchronizationPolicy_enum { - pub const CU_SYNC_POLICY_BLOCKING_SYNC: CUsynchronizationPolicy_enum = - CUsynchronizationPolicy_enum(4); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUsynchronizationPolicy_enum(pub ::std::os::raw::c_uint); -pub use self::CUsynchronizationPolicy_enum as CUsynchronizationPolicy; -impl CUkernelNodeAttrID_enum { - pub const CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW: CUkernelNodeAttrID_enum = - CUkernelNodeAttrID_enum(1); -} -impl CUkernelNodeAttrID_enum { - pub const CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE: CUkernelNodeAttrID_enum = - CUkernelNodeAttrID_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUkernelNodeAttrID_enum(pub ::std::os::raw::c_uint); -pub use self::CUkernelNodeAttrID_enum as CUkernelNodeAttrID; -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUkernelNodeAttrValue_union { - pub accessPolicyWindow: CUaccessPolicyWindow, - pub cooperative: ::std::os::raw::c_int, - _bindgen_union_align: [u64; 4usize], -} -pub type CUkernelNodeAttrValue = CUkernelNodeAttrValue_union; -impl CUstreamCaptureStatus_enum { - pub const CU_STREAM_CAPTURE_STATUS_NONE: CUstreamCaptureStatus_enum = - CUstreamCaptureStatus_enum(0); -} -impl CUstreamCaptureStatus_enum { - pub const CU_STREAM_CAPTURE_STATUS_ACTIVE: CUstreamCaptureStatus_enum = - CUstreamCaptureStatus_enum(1); -} -impl CUstreamCaptureStatus_enum { - pub const CU_STREAM_CAPTURE_STATUS_INVALIDATED: CUstreamCaptureStatus_enum = - CUstreamCaptureStatus_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUstreamCaptureStatus_enum(pub ::std::os::raw::c_uint); -pub use self::CUstreamCaptureStatus_enum as CUstreamCaptureStatus; -impl CUstreamCaptureMode_enum { - pub const CU_STREAM_CAPTURE_MODE_GLOBAL: CUstreamCaptureMode_enum = CUstreamCaptureMode_enum(0); -} -impl CUstreamCaptureMode_enum { - pub const CU_STREAM_CAPTURE_MODE_THREAD_LOCAL: CUstreamCaptureMode_enum = - CUstreamCaptureMode_enum(1); -} -impl CUstreamCaptureMode_enum { - pub const CU_STREAM_CAPTURE_MODE_RELAXED: CUstreamCaptureMode_enum = - CUstreamCaptureMode_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUstreamCaptureMode_enum(pub ::std::os::raw::c_uint); -pub use self::CUstreamCaptureMode_enum as CUstreamCaptureMode; -impl CUstreamAttrID_enum { - pub const CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW: CUstreamAttrID_enum = - CUstreamAttrID_enum(1); -} -impl CUstreamAttrID_enum { - pub const CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY: CUstreamAttrID_enum = - CUstreamAttrID_enum(3); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUstreamAttrID_enum(pub ::std::os::raw::c_uint); -pub use self::CUstreamAttrID_enum as CUstreamAttrID; -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUstreamAttrValue_union { - pub accessPolicyWindow: CUaccessPolicyWindow, - pub syncPolicy: CUsynchronizationPolicy, - _bindgen_union_align: [u64; 4usize], -} -pub type CUstreamAttrValue = CUstreamAttrValue_union; -impl cudaError_enum { - pub const CUDA_SUCCESS: cudaError_enum = cudaError_enum(0); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_VALUE: cudaError_enum = cudaError_enum(1); -} -impl cudaError_enum { - pub const CUDA_ERROR_OUT_OF_MEMORY: cudaError_enum = cudaError_enum(2); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_INITIALIZED: cudaError_enum = cudaError_enum(3); -} -impl cudaError_enum { - pub const CUDA_ERROR_DEINITIALIZED: cudaError_enum = cudaError_enum(4); -} -impl cudaError_enum { - pub const CUDA_ERROR_PROFILER_DISABLED: cudaError_enum = cudaError_enum(5); -} -impl cudaError_enum { - pub const CUDA_ERROR_PROFILER_NOT_INITIALIZED: cudaError_enum = cudaError_enum(6); -} -impl cudaError_enum { - pub const CUDA_ERROR_PROFILER_ALREADY_STARTED: cudaError_enum = cudaError_enum(7); -} -impl cudaError_enum { - pub const CUDA_ERROR_PROFILER_ALREADY_STOPPED: cudaError_enum = cudaError_enum(8); -} -impl cudaError_enum { - pub const CUDA_ERROR_STUB_LIBRARY: cudaError_enum = cudaError_enum(34); -} -impl cudaError_enum { - pub const CUDA_ERROR_NO_DEVICE: cudaError_enum = cudaError_enum(100); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_DEVICE: cudaError_enum = cudaError_enum(101); -} -impl cudaError_enum { - pub const CUDA_ERROR_DEVICE_NOT_LICENSED: cudaError_enum = cudaError_enum(102); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_IMAGE: cudaError_enum = cudaError_enum(200); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_CONTEXT: cudaError_enum = cudaError_enum(201); -} -impl cudaError_enum { - pub const CUDA_ERROR_CONTEXT_ALREADY_CURRENT: cudaError_enum = cudaError_enum(202); -} -impl cudaError_enum { - pub const CUDA_ERROR_MAP_FAILED: cudaError_enum = cudaError_enum(205); -} -impl cudaError_enum { - pub const CUDA_ERROR_UNMAP_FAILED: cudaError_enum = cudaError_enum(206); -} -impl cudaError_enum { - pub const CUDA_ERROR_ARRAY_IS_MAPPED: cudaError_enum = cudaError_enum(207); -} -impl cudaError_enum { - pub const CUDA_ERROR_ALREADY_MAPPED: cudaError_enum = cudaError_enum(208); -} -impl cudaError_enum { - pub const CUDA_ERROR_NO_BINARY_FOR_GPU: cudaError_enum = cudaError_enum(209); -} -impl cudaError_enum { - pub const CUDA_ERROR_ALREADY_ACQUIRED: cudaError_enum = cudaError_enum(210); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_MAPPED: cudaError_enum = cudaError_enum(211); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_MAPPED_AS_ARRAY: cudaError_enum = cudaError_enum(212); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_MAPPED_AS_POINTER: cudaError_enum = cudaError_enum(213); -} -impl cudaError_enum { - pub const CUDA_ERROR_ECC_UNCORRECTABLE: cudaError_enum = cudaError_enum(214); -} -impl cudaError_enum { - pub const CUDA_ERROR_UNSUPPORTED_LIMIT: cudaError_enum = cudaError_enum(215); -} -impl cudaError_enum { - pub const CUDA_ERROR_CONTEXT_ALREADY_IN_USE: cudaError_enum = cudaError_enum(216); -} -impl cudaError_enum { - pub const CUDA_ERROR_PEER_ACCESS_UNSUPPORTED: cudaError_enum = cudaError_enum(217); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_PTX: cudaError_enum = cudaError_enum(218); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_GRAPHICS_CONTEXT: cudaError_enum = cudaError_enum(219); -} -impl cudaError_enum { - pub const CUDA_ERROR_NVLINK_UNCORRECTABLE: cudaError_enum = cudaError_enum(220); -} -impl cudaError_enum { - pub const CUDA_ERROR_JIT_COMPILER_NOT_FOUND: cudaError_enum = cudaError_enum(221); -} -impl cudaError_enum { - pub const CUDA_ERROR_UNSUPPORTED_PTX_VERSION: cudaError_enum = cudaError_enum(222); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_SOURCE: cudaError_enum = cudaError_enum(300); -} -impl cudaError_enum { - pub const CUDA_ERROR_FILE_NOT_FOUND: cudaError_enum = cudaError_enum(301); -} -impl cudaError_enum { - pub const CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: cudaError_enum = cudaError_enum(302); -} -impl cudaError_enum { - pub const CUDA_ERROR_SHARED_OBJECT_INIT_FAILED: cudaError_enum = cudaError_enum(303); -} -impl cudaError_enum { - pub const CUDA_ERROR_OPERATING_SYSTEM: cudaError_enum = cudaError_enum(304); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_HANDLE: cudaError_enum = cudaError_enum(400); -} -impl cudaError_enum { - pub const CUDA_ERROR_ILLEGAL_STATE: cudaError_enum = cudaError_enum(401); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_FOUND: cudaError_enum = cudaError_enum(500); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_READY: cudaError_enum = cudaError_enum(600); -} -impl cudaError_enum { - pub const CUDA_ERROR_ILLEGAL_ADDRESS: cudaError_enum = cudaError_enum(700); -} -impl cudaError_enum { - pub const CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES: cudaError_enum = cudaError_enum(701); -} -impl cudaError_enum { - pub const CUDA_ERROR_LAUNCH_TIMEOUT: cudaError_enum = cudaError_enum(702); -} -impl cudaError_enum { - pub const CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: cudaError_enum = cudaError_enum(703); -} -impl cudaError_enum { - pub const CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED: cudaError_enum = cudaError_enum(704); -} -impl cudaError_enum { - pub const CUDA_ERROR_PEER_ACCESS_NOT_ENABLED: cudaError_enum = cudaError_enum(705); -} -impl cudaError_enum { - pub const CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE: cudaError_enum = cudaError_enum(708); -} -impl cudaError_enum { - pub const CUDA_ERROR_CONTEXT_IS_DESTROYED: cudaError_enum = cudaError_enum(709); -} -impl cudaError_enum { - pub const CUDA_ERROR_ASSERT: cudaError_enum = cudaError_enum(710); -} -impl cudaError_enum { - pub const CUDA_ERROR_TOO_MANY_PEERS: cudaError_enum = cudaError_enum(711); -} -impl cudaError_enum { - pub const CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED: cudaError_enum = cudaError_enum(712); -} -impl cudaError_enum { - pub const CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED: cudaError_enum = cudaError_enum(713); -} -impl cudaError_enum { - pub const CUDA_ERROR_HARDWARE_STACK_ERROR: cudaError_enum = cudaError_enum(714); -} -impl cudaError_enum { - pub const CUDA_ERROR_ILLEGAL_INSTRUCTION: cudaError_enum = cudaError_enum(715); -} -impl cudaError_enum { - pub const CUDA_ERROR_MISALIGNED_ADDRESS: cudaError_enum = cudaError_enum(716); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_ADDRESS_SPACE: cudaError_enum = cudaError_enum(717); -} -impl cudaError_enum { - pub const CUDA_ERROR_INVALID_PC: cudaError_enum = cudaError_enum(718); -} -impl cudaError_enum { - pub const CUDA_ERROR_LAUNCH_FAILED: cudaError_enum = cudaError_enum(719); -} -impl cudaError_enum { - pub const CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE: cudaError_enum = cudaError_enum(720); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_PERMITTED: cudaError_enum = cudaError_enum(800); -} -impl cudaError_enum { - pub const CUDA_ERROR_NOT_SUPPORTED: cudaError_enum = cudaError_enum(801); -} -impl cudaError_enum { - pub const CUDA_ERROR_SYSTEM_NOT_READY: cudaError_enum = cudaError_enum(802); -} -impl cudaError_enum { - pub const CUDA_ERROR_SYSTEM_DRIVER_MISMATCH: cudaError_enum = cudaError_enum(803); -} -impl cudaError_enum { - pub const CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE: cudaError_enum = cudaError_enum(804); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED: cudaError_enum = cudaError_enum(900); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_INVALIDATED: cudaError_enum = cudaError_enum(901); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_MERGE: cudaError_enum = cudaError_enum(902); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_UNMATCHED: cudaError_enum = cudaError_enum(903); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_UNJOINED: cudaError_enum = cudaError_enum(904); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_ISOLATION: cudaError_enum = cudaError_enum(905); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_IMPLICIT: cudaError_enum = cudaError_enum(906); -} -impl cudaError_enum { - pub const CUDA_ERROR_CAPTURED_EVENT: cudaError_enum = cudaError_enum(907); -} -impl cudaError_enum { - pub const CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD: cudaError_enum = cudaError_enum(908); -} -impl cudaError_enum { - pub const CUDA_ERROR_TIMEOUT: cudaError_enum = cudaError_enum(909); -} -impl cudaError_enum { - pub const CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE: cudaError_enum = cudaError_enum(910); -} -impl cudaError_enum { - pub const CUDA_ERROR_UNKNOWN: cudaError_enum = cudaError_enum(999); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)] -pub struct cudaError_enum(pub ::std::os::raw::c_uint); -pub use self::cudaError_enum as CUresult; -impl CUdevice_P2PAttribute_enum { - pub const CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: CUdevice_P2PAttribute_enum = - CUdevice_P2PAttribute_enum(1); -} -impl CUdevice_P2PAttribute_enum { - pub const CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = - CUdevice_P2PAttribute_enum(2); -} -impl CUdevice_P2PAttribute_enum { - pub const CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: CUdevice_P2PAttribute_enum = - CUdevice_P2PAttribute_enum(3); -} -impl CUdevice_P2PAttribute_enum { - pub const CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = - CUdevice_P2PAttribute_enum(4); -} -impl CUdevice_P2PAttribute_enum { - pub const CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: CUdevice_P2PAttribute_enum = - CUdevice_P2PAttribute_enum(4); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUdevice_P2PAttribute_enum(pub ::std::os::raw::c_uint); -pub use self::CUdevice_P2PAttribute_enum as CUdevice_P2PAttribute; -pub type CUstreamCallback = ::std::option::Option< - unsafe extern "C" fn( - hStream: CUstream, - status: CUresult, - userData: *mut ::std::os::raw::c_void, - ), ->; -pub type CUoccupancyB2DSize = - ::std::option::Option usize>; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_MEMCPY2D_st { - pub srcXInBytes: usize, - pub srcY: usize, - pub srcMemoryType: CUmemorytype, - pub srcHost: *const ::std::os::raw::c_void, - pub srcDevice: CUdeviceptr, - pub srcArray: CUarray, - pub srcPitch: usize, - pub dstXInBytes: usize, - pub dstY: usize, - pub dstMemoryType: CUmemorytype, - pub dstHost: *mut ::std::os::raw::c_void, - pub dstDevice: CUdeviceptr, - pub dstArray: CUarray, - pub dstPitch: usize, - pub WidthInBytes: usize, - pub Height: usize, -} -pub type CUDA_MEMCPY2D = CUDA_MEMCPY2D_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_MEMCPY3D_st { - pub srcXInBytes: usize, - pub srcY: usize, - pub srcZ: usize, - pub srcLOD: usize, - pub srcMemoryType: CUmemorytype, - pub srcHost: *const ::std::os::raw::c_void, - pub srcDevice: CUdeviceptr, - pub srcArray: CUarray, - pub reserved0: *mut ::std::os::raw::c_void, - pub srcPitch: usize, - pub srcHeight: usize, - pub dstXInBytes: usize, - pub dstY: usize, - pub dstZ: usize, - pub dstLOD: usize, - pub dstMemoryType: CUmemorytype, - pub dstHost: *mut ::std::os::raw::c_void, - pub dstDevice: CUdeviceptr, - pub dstArray: CUarray, - pub reserved1: *mut ::std::os::raw::c_void, - pub dstPitch: usize, - pub dstHeight: usize, - pub WidthInBytes: usize, - pub Height: usize, - pub Depth: usize, -} -pub type CUDA_MEMCPY3D = CUDA_MEMCPY3D_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_MEMCPY3D_PEER_st { - pub srcXInBytes: usize, - pub srcY: usize, - pub srcZ: usize, - pub srcLOD: usize, - pub srcMemoryType: CUmemorytype, - pub srcHost: *const ::std::os::raw::c_void, - pub srcDevice: CUdeviceptr, - pub srcArray: CUarray, - pub srcContext: CUcontext, - pub srcPitch: usize, - pub srcHeight: usize, - pub dstXInBytes: usize, - pub dstY: usize, - pub dstZ: usize, - pub dstLOD: usize, - pub dstMemoryType: CUmemorytype, - pub dstHost: *mut ::std::os::raw::c_void, - pub dstDevice: CUdeviceptr, - pub dstArray: CUarray, - pub dstContext: CUcontext, - pub dstPitch: usize, - pub dstHeight: usize, - pub WidthInBytes: usize, - pub Height: usize, - pub Depth: usize, -} -pub type CUDA_MEMCPY3D_PEER = CUDA_MEMCPY3D_PEER_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_ARRAY_DESCRIPTOR_st { - pub Width: usize, - pub Height: usize, - pub Format: CUarray_format, - pub NumChannels: ::std::os::raw::c_uint, -} -pub type CUDA_ARRAY_DESCRIPTOR = CUDA_ARRAY_DESCRIPTOR_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_ARRAY3D_DESCRIPTOR_st { - pub Width: usize, - pub Height: usize, - pub Depth: usize, - pub Format: CUarray_format, - pub NumChannels: ::std::os::raw::c_uint, - pub Flags: ::std::os::raw::c_uint, -} -pub type CUDA_ARRAY3D_DESCRIPTOR = CUDA_ARRAY3D_DESCRIPTOR_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st { - pub tileExtent: CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1, - pub miptailFirstLevel: ::std::os::raw::c_uint, - pub miptailSize: ::std::os::raw::c_ulonglong, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 4usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_ARRAY_SPARSE_PROPERTIES_st__bindgen_ty_1 { - pub width: ::std::os::raw::c_uint, - pub height: ::std::os::raw::c_uint, - pub depth: ::std::os::raw::c_uint, -} -pub type CUDA_ARRAY_SPARSE_PROPERTIES = CUDA_ARRAY_SPARSE_PROPERTIES_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st { - pub resType: CUresourcetype, - pub res: CUDA_RESOURCE_DESC_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUDA_RESOURCE_DESC_st__bindgen_ty_1 { - pub array: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1, - pub mipmap: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2, - pub linear: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3, - pub pitch2D: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4, - pub reserved: CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5, - _bindgen_union_align: [u64; 16usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_1 { - pub hArray: CUarray, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_2 { - pub hMipmappedArray: CUmipmappedArray, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_3 { - pub devPtr: CUdeviceptr, - pub format: CUarray_format, - pub numChannels: ::std::os::raw::c_uint, - pub sizeInBytes: usize, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_4 { - pub devPtr: CUdeviceptr, - pub format: CUarray_format, - pub numChannels: ::std::os::raw::c_uint, - pub width: usize, - pub height: usize, - pub pitchInBytes: usize, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_DESC_st__bindgen_ty_1__bindgen_ty_5 { - pub reserved: [::std::os::raw::c_int; 32usize], -} -pub type CUDA_RESOURCE_DESC = CUDA_RESOURCE_DESC_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_TEXTURE_DESC_st { - pub addressMode: [CUaddress_mode; 3usize], - pub filterMode: CUfilter_mode, - pub flags: ::std::os::raw::c_uint, - pub maxAnisotropy: ::std::os::raw::c_uint, - pub mipmapFilterMode: CUfilter_mode, - pub mipmapLevelBias: f32, - pub minMipmapLevelClamp: f32, - pub maxMipmapLevelClamp: f32, - pub borderColor: [f32; 4usize], - pub reserved: [::std::os::raw::c_int; 12usize], -} -pub type CUDA_TEXTURE_DESC = CUDA_TEXTURE_DESC_st; -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_NONE: CUresourceViewFormat_enum = CUresourceViewFormat_enum(0); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_1X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(1); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_2X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(2); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_4X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(3); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_1X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(4); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_2X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(5); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_4X8: CUresourceViewFormat_enum = CUresourceViewFormat_enum(6); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_1X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(7); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_2X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(8); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_4X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(9); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_1X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(10); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_2X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(11); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_4X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(12); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_1X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(13); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_2X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(14); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UINT_4X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(15); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_1X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(16); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_2X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(17); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SINT_4X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(18); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_1X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(19); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_2X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(20); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_4X16: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(21); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_1X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(22); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_2X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(23); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_FLOAT_4X32: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(24); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC1: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(25); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC2: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(26); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC3: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(27); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC4: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(28); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SIGNED_BC4: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(29); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC5: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(30); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SIGNED_BC5: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(31); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC6H: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(32); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_SIGNED_BC6H: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(33); -} -impl CUresourceViewFormat_enum { - pub const CU_RES_VIEW_FORMAT_UNSIGNED_BC7: CUresourceViewFormat_enum = - CUresourceViewFormat_enum(34); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUresourceViewFormat_enum(pub ::std::os::raw::c_uint); -pub use self::CUresourceViewFormat_enum as CUresourceViewFormat; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_RESOURCE_VIEW_DESC_st { - pub format: CUresourceViewFormat, - pub width: usize, - pub height: usize, - pub depth: usize, - pub firstMipmapLevel: ::std::os::raw::c_uint, - pub lastMipmapLevel: ::std::os::raw::c_uint, - pub firstLayer: ::std::os::raw::c_uint, - pub lastLayer: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -pub type CUDA_RESOURCE_VIEW_DESC = CUDA_RESOURCE_VIEW_DESC_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_LAUNCH_PARAMS_st { - pub function: CUfunction, - pub gridDimX: ::std::os::raw::c_uint, - pub gridDimY: ::std::os::raw::c_uint, - pub gridDimZ: ::std::os::raw::c_uint, - pub blockDimX: ::std::os::raw::c_uint, - pub blockDimY: ::std::os::raw::c_uint, - pub blockDimZ: ::std::os::raw::c_uint, - pub sharedMemBytes: ::std::os::raw::c_uint, - pub hStream: CUstream, - pub kernelParams: *mut *mut ::std::os::raw::c_void, -} -pub type CUDA_LAUNCH_PARAMS = CUDA_LAUNCH_PARAMS_st; -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(1); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(2); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(3); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(4); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(5); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(6); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(7); -} -impl CUexternalMemoryHandleType_enum { - pub const CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF: CUexternalMemoryHandleType_enum = - CUexternalMemoryHandleType_enum(8); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUexternalMemoryHandleType_enum(pub ::std::os::raw::c_uint); -pub use self::CUexternalMemoryHandleType_enum as CUexternalMemoryHandleType; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st { - pub type_: CUexternalMemoryHandleType, - pub handle: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1, - pub size: ::std::os::raw::c_ulonglong, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1 { - pub fd: ::std::os::raw::c_int, - pub win32: CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1, - pub nvSciBufObject: *const ::std::os::raw::c_void, - _bindgen_union_align: [u64; 2usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 { - pub handle: *mut ::std::os::raw::c_void, - pub name: *const ::std::os::raw::c_void, -} -pub type CUDA_EXTERNAL_MEMORY_HANDLE_DESC = CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st { - pub offset: ::std::os::raw::c_ulonglong, - pub size: ::std::os::raw::c_ulonglong, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -pub type CUDA_EXTERNAL_MEMORY_BUFFER_DESC = CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st { - pub offset: ::std::os::raw::c_ulonglong, - pub arrayDesc: CUDA_ARRAY3D_DESCRIPTOR, - pub numLevels: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -pub type CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC = CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st; -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD: CUexternalSemaphoreHandleType_enum = - CUexternalSemaphoreHandleType_enum(1); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32: CUexternalSemaphoreHandleType_enum = - CUexternalSemaphoreHandleType_enum(2); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT: - CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(3); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE: CUexternalSemaphoreHandleType_enum = - CUexternalSemaphoreHandleType_enum(4); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE: CUexternalSemaphoreHandleType_enum = - CUexternalSemaphoreHandleType_enum(5); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC: CUexternalSemaphoreHandleType_enum = - CUexternalSemaphoreHandleType_enum(6); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX: - CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(7); -} -impl CUexternalSemaphoreHandleType_enum { - pub const CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT: - CUexternalSemaphoreHandleType_enum = CUexternalSemaphoreHandleType_enum(8); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUexternalSemaphoreHandleType_enum(pub ::std::os::raw::c_uint); -pub use self::CUexternalSemaphoreHandleType_enum as CUexternalSemaphoreHandleType; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st { - pub type_: CUexternalSemaphoreHandleType, - pub handle: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1 { - pub fd: ::std::os::raw::c_int, - pub win32: CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1, - pub nvSciSyncObj: *const ::std::os::raw::c_void, - _bindgen_union_align: [u64; 2usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1 { - pub handle: *mut ::std::os::raw::c_void, - pub name: *const ::std::os::raw::c_void, -} -pub type CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC = CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st { - pub params: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1 { - pub fence: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1, - pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2, - pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3, - pub reserved: [::std::os::raw::c_uint; 12usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_1 { - pub value: ::std::os::raw::c_ulonglong, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 { - pub fence: *mut ::std::os::raw::c_void, - pub reserved: ::std::os::raw::c_ulonglong, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_3 { - pub key: ::std::os::raw::c_ulonglong, -} -pub type CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS = CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st { - pub params: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 16usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1 { - pub fence: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1, - pub nvSciSync: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2, - pub keyedMutex: CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3, - pub reserved: [::std::os::raw::c_uint; 10usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_1 { - pub value: ::std::os::raw::c_ulonglong, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 { - pub fence: *mut ::std::os::raw::c_void, - pub reserved: ::std::os::raw::c_ulonglong, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_3 { - pub key: ::std::os::raw::c_ulonglong, - pub timeoutMs: ::std::os::raw::c_uint, -} -pub type CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS = CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st; -pub type CUmemGenericAllocationHandle = ::std::os::raw::c_ulonglong; -impl CUmemAllocationHandleType_enum { - pub const CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR: CUmemAllocationHandleType_enum = - CUmemAllocationHandleType_enum(1); -} -impl CUmemAllocationHandleType_enum { - pub const CU_MEM_HANDLE_TYPE_WIN32: CUmemAllocationHandleType_enum = - CUmemAllocationHandleType_enum(2); -} -impl CUmemAllocationHandleType_enum { - pub const CU_MEM_HANDLE_TYPE_WIN32_KMT: CUmemAllocationHandleType_enum = - CUmemAllocationHandleType_enum(4); -} -impl CUmemAllocationHandleType_enum { - pub const CU_MEM_HANDLE_TYPE_MAX: CUmemAllocationHandleType_enum = - CUmemAllocationHandleType_enum(4294967295); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemAllocationHandleType_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemAllocationHandleType_enum as CUmemAllocationHandleType; -impl CUmemAccess_flags_enum { - pub const CU_MEM_ACCESS_FLAGS_PROT_NONE: CUmemAccess_flags_enum = CUmemAccess_flags_enum(0); -} -impl CUmemAccess_flags_enum { - pub const CU_MEM_ACCESS_FLAGS_PROT_READ: CUmemAccess_flags_enum = CUmemAccess_flags_enum(1); -} -impl CUmemAccess_flags_enum { - pub const CU_MEM_ACCESS_FLAGS_PROT_READWRITE: CUmemAccess_flags_enum = - CUmemAccess_flags_enum(3); -} -impl CUmemAccess_flags_enum { - pub const CU_MEM_ACCESS_FLAGS_PROT_MAX: CUmemAccess_flags_enum = - CUmemAccess_flags_enum(4294967295); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemAccess_flags_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemAccess_flags_enum as CUmemAccess_flags; -impl CUmemLocationType_enum { - pub const CU_MEM_LOCATION_TYPE_INVALID: CUmemLocationType_enum = CUmemLocationType_enum(0); -} -impl CUmemLocationType_enum { - pub const CU_MEM_LOCATION_TYPE_DEVICE: CUmemLocationType_enum = CUmemLocationType_enum(1); -} -impl CUmemLocationType_enum { - pub const CU_MEM_LOCATION_TYPE_MAX: CUmemLocationType_enum = CUmemLocationType_enum(4294967295); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemLocationType_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemLocationType_enum as CUmemLocationType; -impl CUmemAllocationType_enum { - pub const CU_MEM_ALLOCATION_TYPE_INVALID: CUmemAllocationType_enum = - CUmemAllocationType_enum(0); -} -impl CUmemAllocationType_enum { - pub const CU_MEM_ALLOCATION_TYPE_PINNED: CUmemAllocationType_enum = CUmemAllocationType_enum(1); -} -impl CUmemAllocationType_enum { - pub const CU_MEM_ALLOCATION_TYPE_MAX: CUmemAllocationType_enum = - CUmemAllocationType_enum(4294967295); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemAllocationType_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemAllocationType_enum as CUmemAllocationType; -impl CUmemAllocationGranularity_flags_enum { - pub const CU_MEM_ALLOC_GRANULARITY_MINIMUM: CUmemAllocationGranularity_flags_enum = - CUmemAllocationGranularity_flags_enum(0); -} -impl CUmemAllocationGranularity_flags_enum { - pub const CU_MEM_ALLOC_GRANULARITY_RECOMMENDED: CUmemAllocationGranularity_flags_enum = - CUmemAllocationGranularity_flags_enum(1); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemAllocationGranularity_flags_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemAllocationGranularity_flags_enum as CUmemAllocationGranularity_flags; -impl CUarraySparseSubresourceType_enum { - pub const CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL: CUarraySparseSubresourceType_enum = - CUarraySparseSubresourceType_enum(0); -} -impl CUarraySparseSubresourceType_enum { - pub const CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL: CUarraySparseSubresourceType_enum = - CUarraySparseSubresourceType_enum(1); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUarraySparseSubresourceType_enum(pub ::std::os::raw::c_uint); -pub use self::CUarraySparseSubresourceType_enum as CUarraySparseSubresourceType; -impl CUmemOperationType_enum { - pub const CU_MEM_OPERATION_TYPE_MAP: CUmemOperationType_enum = CUmemOperationType_enum(1); -} -impl CUmemOperationType_enum { - pub const CU_MEM_OPERATION_TYPE_UNMAP: CUmemOperationType_enum = CUmemOperationType_enum(2); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemOperationType_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemOperationType_enum as CUmemOperationType; -impl CUmemHandleType_enum { - pub const CU_MEM_HANDLE_TYPE_GENERIC: CUmemHandleType_enum = CUmemHandleType_enum(0); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUmemHandleType_enum(pub ::std::os::raw::c_uint); -pub use self::CUmemHandleType_enum as CUmemHandleType; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUarrayMapInfo_st { - pub resourceType: CUresourcetype, - pub resource: CUarrayMapInfo_st__bindgen_ty_1, - pub subresourceType: CUarraySparseSubresourceType, - pub subresource: CUarrayMapInfo_st__bindgen_ty_2, - pub memOperationType: CUmemOperationType, - pub memHandleType: CUmemHandleType, - pub memHandle: CUarrayMapInfo_st__bindgen_ty_3, - pub offset: ::std::os::raw::c_ulonglong, - pub deviceBitMask: ::std::os::raw::c_uint, - pub flags: ::std::os::raw::c_uint, - pub reserved: [::std::os::raw::c_uint; 2usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUarrayMapInfo_st__bindgen_ty_1 { - pub mipmap: CUmipmappedArray, - pub array: CUarray, - _bindgen_union_align: u64, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUarrayMapInfo_st__bindgen_ty_2 { - pub sparseLevel: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1, - pub miptail: CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2, - _bindgen_union_align: [u64; 4usize], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_1 { - pub level: ::std::os::raw::c_uint, - pub layer: ::std::os::raw::c_uint, - pub offsetX: ::std::os::raw::c_uint, - pub offsetY: ::std::os::raw::c_uint, - pub offsetZ: ::std::os::raw::c_uint, - pub extentWidth: ::std::os::raw::c_uint, - pub extentHeight: ::std::os::raw::c_uint, - pub extentDepth: ::std::os::raw::c_uint, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUarrayMapInfo_st__bindgen_ty_2__bindgen_ty_2 { - pub layer: ::std::os::raw::c_uint, - pub offset: ::std::os::raw::c_ulonglong, - pub size: ::std::os::raw::c_ulonglong, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub union CUarrayMapInfo_st__bindgen_ty_3 { - pub memHandle: CUmemGenericAllocationHandle, - _bindgen_union_align: u64, -} -pub type CUarrayMapInfo = CUarrayMapInfo_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmemLocation_st { - pub type_: CUmemLocationType, - pub id: ::std::os::raw::c_int, -} -pub type CUmemLocation = CUmemLocation_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmemAllocationProp_st { - pub type_: CUmemAllocationType, - pub requestedHandleTypes: CUmemAllocationHandleType, - pub location: CUmemLocation, - pub win32HandleMetaData: *mut ::std::os::raw::c_void, - pub allocFlags: CUmemAllocationProp_st__bindgen_ty_1, -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmemAllocationProp_st__bindgen_ty_1 { - pub compressionType: ::std::os::raw::c_uchar, - pub gpuDirectRDMACapable: ::std::os::raw::c_uchar, - pub usage: ::std::os::raw::c_ushort, - pub reserved: [::std::os::raw::c_uchar; 4usize], -} -pub type CUmemAllocationProp = CUmemAllocationProp_st; -#[repr(C)] -#[derive(Copy, Clone)] -pub struct CUmemAccessDesc_st { - pub location: CUmemLocation, - pub flags: CUmemAccess_flags, -} -pub type CUmemAccessDesc = CUmemAccessDesc_st; -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_SUCCESS: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(0); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(1); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(2); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(3); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(4); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(5); -} -impl CUgraphExecUpdateResult_enum { - pub const CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED: CUgraphExecUpdateResult_enum = - CUgraphExecUpdateResult_enum(6); -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUgraphExecUpdateResult_enum(pub ::std::os::raw::c_uint); -pub use self::CUgraphExecUpdateResult_enum as CUgraphExecUpdateResult; -extern_redirect! { - pub fn cuGetErrorString(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult; -} -extern_redirect! { - pub fn cuGetErrorName(error: CUresult, pStr: *mut *const ::std::os::raw::c_char) -> CUresult; -} -extern_redirect! { - pub fn cuInit(Flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuDriverGetVersion(driverVersion: *mut ::std::os::raw::c_int) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGet(device: *mut CUdevice, ordinal: ::std::os::raw::c_int) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetCount(count: *mut ::std::os::raw::c_int) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetName( - name: *mut ::std::os::raw::c_char, - len: ::std::os::raw::c_int, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetUuid(uuid: *mut CUuuid, dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetLuid( - luid: *mut ::std::os::raw::c_char, - deviceNodeMask: *mut ::std::os::raw::c_uint, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceTotalMem(bytes: *mut usize, dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceTotalMem_v2(bytes: *mut usize, dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetTexture1DLinearMaxWidth( - maxWidthInElements: *mut usize, - format: CUarray_format, - numChannels: ::std::os::raw::c_uint, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect_with_post! { - pub fn cuDeviceGetAttribute( - pi: *mut ::std::os::raw::c_int, - attrib: CUdevice_attribute, - dev: CUdevice, - ) -> CUresult; - super::cuDeviceGetAttribute_Post; -} -extern_redirect! { - pub fn cuDeviceGetNvSciSyncAttributes( - nvSciSyncAttrList: *mut ::std::os::raw::c_void, - dev: CUdevice, - flags: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetProperties(prop: *mut CUdevprop, dev: CUdevice) -> CUresult; -} -extern_redirect_with_post! { - pub fn cuDeviceComputeCapability( - major: *mut ::std::os::raw::c_int, - minor: *mut ::std::os::raw::c_int, - dev: CUdevice, - ) -> CUresult; - super::cuDeviceComputeCapability_Post; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxRetain(pctx: *mut CUcontext, dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxRelease(dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxRelease_v2(dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxSetFlags(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxSetFlags_v2(dev: CUdevice, flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxGetState( - dev: CUdevice, - flags: *mut ::std::os::raw::c_uint, - active: *mut ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxReset(dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuDevicePrimaryCtxReset_v2(dev: CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuCtxCreate( - pctx: *mut CUcontext, - flags: ::std::os::raw::c_uint, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuCtxCreate_v2( - pctx: *mut CUcontext, - flags: ::std::os::raw::c_uint, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuCtxDestroy(ctx: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxDestroy_v2(ctx: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxPushCurrent(ctx: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxPushCurrent_v2(ctx: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxPopCurrent(pctx: *mut CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxPopCurrent_v2(pctx: *mut CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxSetCurrent(ctx: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetCurrent(pctx: *mut CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetDevice(device: *mut CUdevice) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetFlags(flags: *mut ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuCtxSynchronize() -> CUresult; -} -extern_redirect! { - pub fn cuCtxSetLimit(limit: CUlimit, value: usize) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetLimit(pvalue: *mut usize, limit: CUlimit) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetCacheConfig(pconfig: *mut CUfunc_cache) -> CUresult; -} -extern_redirect! { - pub fn cuCtxSetCacheConfig(config: CUfunc_cache) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetSharedMemConfig(pConfig: *mut CUsharedconfig) -> CUresult; -} -extern_redirect! { - pub fn cuCtxSetSharedMemConfig(config: CUsharedconfig) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetApiVersion(ctx: CUcontext, version: *mut ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuCtxGetStreamPriorityRange( - leastPriority: *mut ::std::os::raw::c_int, - greatestPriority: *mut ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuCtxResetPersistingL2Cache() -> CUresult; -} -extern_redirect! { - pub fn cuCtxAttach(pctx: *mut CUcontext, flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuCtxDetach(ctx: CUcontext) -> CUresult; -} -extern_redirect_with_post! { - pub fn cuModuleLoad(module: *mut CUmodule, fname: *const ::std::os::raw::c_char) -> CUresult; - super::cuModuleLoad_Post; -} -extern_redirect_with_post! { - pub fn cuModuleLoadData( - module: *mut CUmodule, - image: *const ::std::os::raw::c_void, - ) -> CUresult; - super::cuModuleLoadData_Post; -} -extern_redirect_with_post! { - pub fn cuModuleLoadDataEx( - module: *mut CUmodule, - image: *const ::std::os::raw::c_void, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; - super::cuModuleLoadDataEx_Post; -} -extern_redirect_with_post! { - pub fn cuModuleLoadFatBinary( - module: *mut CUmodule, - fatCubin: *const ::std::os::raw::c_void, - ) -> CUresult; - super::cuModuleLoadFatBinary_Post; -} -extern_redirect! { - pub fn cuModuleUnload(hmod: CUmodule) -> CUresult; -} -extern_redirect_with_post! { - pub fn cuModuleGetFunction( - hfunc: *mut CUfunction, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - ) -> CUresult; - super::cuModuleGetFunction_Post; -} -extern_redirect! { - pub fn cuModuleGetGlobal( - dptr: *mut CUdeviceptr, - bytes: *mut usize, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - ) -> CUresult; -} -extern_redirect! { - pub fn cuModuleGetGlobal_v2( - dptr: *mut CUdeviceptr, - bytes: *mut usize, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - ) -> CUresult; -} -extern_redirect! { - pub fn cuModuleGetTexRef( - pTexRef: *mut CUtexref, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - ) -> CUresult; -} -extern_redirect! { - pub fn cuModuleGetSurfRef( - pSurfRef: *mut CUsurfref, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkCreate( - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - stateOut: *mut CUlinkState, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkCreate_v2( - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - stateOut: *mut CUlinkState, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkAddData( - state: CUlinkState, - type_: CUjitInputType, - data: *mut ::std::os::raw::c_void, - size: usize, - name: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkAddData_v2( - state: CUlinkState, - type_: CUjitInputType, - data: *mut ::std::os::raw::c_void, - size: usize, - name: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkAddFile( - state: CUlinkState, - type_: CUjitInputType, - path: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkAddFile_v2( - state: CUlinkState, - type_: CUjitInputType, - path: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkComplete( - state: CUlinkState, - cubinOut: *mut *mut ::std::os::raw::c_void, - sizeOut: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLinkDestroy(state: CUlinkState) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetInfo(free: *mut usize, total: *mut usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetInfo_v2(free: *mut usize, total: *mut usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemAlloc(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemAlloc_v2(dptr: *mut CUdeviceptr, bytesize: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemAllocPitch( - dptr: *mut CUdeviceptr, - pPitch: *mut usize, - WidthInBytes: usize, - Height: usize, - ElementSizeBytes: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemAllocPitch_v2( - dptr: *mut CUdeviceptr, - pPitch: *mut usize, - WidthInBytes: usize, - Height: usize, - ElementSizeBytes: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemFree(dptr: CUdeviceptr) -> CUresult; -} -extern_redirect! { - pub fn cuMemFree_v2(dptr: CUdeviceptr) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetAddressRange( - pbase: *mut CUdeviceptr, - psize: *mut usize, - dptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetAddressRange_v2( - pbase: *mut CUdeviceptr, - psize: *mut usize, - dptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemAllocHost(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemAllocHost_v2(pp: *mut *mut ::std::os::raw::c_void, bytesize: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemFreeHost(p: *mut ::std::os::raw::c_void) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostAlloc( - pp: *mut *mut ::std::os::raw::c_void, - bytesize: usize, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostGetDevicePointer( - pdptr: *mut CUdeviceptr, - p: *mut ::std::os::raw::c_void, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostGetDevicePointer_v2( - pdptr: *mut CUdeviceptr, - p: *mut ::std::os::raw::c_void, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostGetFlags( - pFlags: *mut ::std::os::raw::c_uint, - p: *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemAllocManaged( - dptr: *mut CUdeviceptr, - bytesize: usize, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetByPCIBusId( - dev: *mut CUdevice, - pciBusId: *const ::std::os::raw::c_char, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetPCIBusId( - pciBusId: *mut ::std::os::raw::c_char, - len: ::std::os::raw::c_int, - dev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuIpcGetEventHandle(pHandle: *mut CUipcEventHandle, event: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuIpcOpenEventHandle(phEvent: *mut CUevent, handle: CUipcEventHandle) -> CUresult; -} -extern_redirect! { - pub fn cuIpcGetMemHandle(pHandle: *mut CUipcMemHandle, dptr: CUdeviceptr) -> CUresult; -} -extern_redirect! { - pub fn cuIpcOpenMemHandle( - pdptr: *mut CUdeviceptr, - handle: CUipcMemHandle, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuIpcOpenMemHandle_v2( - pdptr: *mut CUdeviceptr, - handle: CUipcMemHandle, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuIpcCloseMemHandle(dptr: CUdeviceptr) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostRegister( - p: *mut ::std::os::raw::c_void, - bytesize: usize, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostRegister_v2( - p: *mut ::std::os::raw::c_void, - bytesize: usize, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemHostUnregister(p: *mut ::std::os::raw::c_void) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy(dst: CUdeviceptr, src: CUdeviceptr, ByteCount: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyPeer( - dstDevice: CUdeviceptr, - dstContext: CUcontext, - srcDevice: CUdeviceptr, - srcContext: CUcontext, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoD( - dstDevice: CUdeviceptr, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoD_v2( - dstDevice: CUdeviceptr, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoH( - dstHost: *mut ::std::os::raw::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoH_v2( - dstHost: *mut ::std::os::raw::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoD( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoD_v2( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoA( - dstArray: CUarray, - dstOffset: usize, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoA_v2( - dstArray: CUarray, - dstOffset: usize, - srcDevice: CUdeviceptr, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoD( - dstDevice: CUdeviceptr, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoD_v2( - dstDevice: CUdeviceptr, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoA( - dstArray: CUarray, - dstOffset: usize, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoA_v2( - dstArray: CUarray, - dstOffset: usize, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoH( - dstHost: *mut ::std::os::raw::c_void, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoH_v2( - dstHost: *mut ::std::os::raw::c_void, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoA( - dstArray: CUarray, - dstOffset: usize, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoA_v2( - dstArray: CUarray, - dstOffset: usize, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2D(pCopy: *const CUDA_MEMCPY2D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2D_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2DUnaligned(pCopy: *const CUDA_MEMCPY2D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2DUnaligned_v2(pCopy: *const CUDA_MEMCPY2D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3D(pCopy: *const CUDA_MEMCPY3D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3D_v2(pCopy: *const CUDA_MEMCPY3D) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3DPeer(pCopy: *const CUDA_MEMCPY3D_PEER) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAsync( - dst: CUdeviceptr, - src: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyPeerAsync( - dstDevice: CUdeviceptr, - dstContext: CUcontext, - srcDevice: CUdeviceptr, - srcContext: CUcontext, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoDAsync( - dstDevice: CUdeviceptr, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoDAsync_v2( - dstDevice: CUdeviceptr, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoHAsync( - dstHost: *mut ::std::os::raw::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoHAsync_v2( - dstHost: *mut ::std::os::raw::c_void, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoDAsync( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyDtoDAsync_v2( - dstDevice: CUdeviceptr, - srcDevice: CUdeviceptr, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoAAsync( - dstArray: CUarray, - dstOffset: usize, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyHtoAAsync_v2( - dstArray: CUarray, - dstOffset: usize, - srcHost: *const ::std::os::raw::c_void, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoHAsync( - dstHost: *mut ::std::os::raw::c_void, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpyAtoHAsync_v2( - dstHost: *mut ::std::os::raw::c_void, - srcArray: CUarray, - srcOffset: usize, - ByteCount: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2DAsync(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy2DAsync_v2(pCopy: *const CUDA_MEMCPY2D, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3DAsync(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3DAsync_v2(pCopy: *const CUDA_MEMCPY3D, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuMemcpy3DPeerAsync(pCopy: *const CUDA_MEMCPY3D_PEER, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD8(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize) - -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD8_v2(dstDevice: CUdeviceptr, uc: ::std::os::raw::c_uchar, N: usize) - -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD16( - dstDevice: CUdeviceptr, - us: ::std::os::raw::c_ushort, - N: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD16_v2( - dstDevice: CUdeviceptr, - us: ::std::os::raw::c_ushort, - N: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD32(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize) - -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD32_v2(dstDevice: CUdeviceptr, ui: ::std::os::raw::c_uint, N: usize) - -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D8( - dstDevice: CUdeviceptr, - dstPitch: usize, - uc: ::std::os::raw::c_uchar, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D8_v2( - dstDevice: CUdeviceptr, - dstPitch: usize, - uc: ::std::os::raw::c_uchar, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D16( - dstDevice: CUdeviceptr, - dstPitch: usize, - us: ::std::os::raw::c_ushort, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D16_v2( - dstDevice: CUdeviceptr, - dstPitch: usize, - us: ::std::os::raw::c_ushort, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D32( - dstDevice: CUdeviceptr, - dstPitch: usize, - ui: ::std::os::raw::c_uint, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D32_v2( - dstDevice: CUdeviceptr, - dstPitch: usize, - ui: ::std::os::raw::c_uint, - Width: usize, - Height: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD8Async( - dstDevice: CUdeviceptr, - uc: ::std::os::raw::c_uchar, - N: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD16Async( - dstDevice: CUdeviceptr, - us: ::std::os::raw::c_ushort, - N: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD32Async( - dstDevice: CUdeviceptr, - ui: ::std::os::raw::c_uint, - N: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D8Async( - dstDevice: CUdeviceptr, - dstPitch: usize, - uc: ::std::os::raw::c_uchar, - Width: usize, - Height: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D16Async( - dstDevice: CUdeviceptr, - dstPitch: usize, - us: ::std::os::raw::c_ushort, - Width: usize, - Height: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemsetD2D32Async( - dstDevice: CUdeviceptr, - dstPitch: usize, - ui: ::std::os::raw::c_uint, - Width: usize, - Height: usize, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayCreate( - pHandle: *mut CUarray, - pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayCreate_v2( - pHandle: *mut CUarray, - pAllocateArray: *const CUDA_ARRAY_DESCRIPTOR, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayGetDescriptor( - pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR, - hArray: CUarray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayGetDescriptor_v2( - pArrayDescriptor: *mut CUDA_ARRAY_DESCRIPTOR, - hArray: CUarray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayGetSparseProperties( - sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES, - array: CUarray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMipmappedArrayGetSparseProperties( - sparseProperties: *mut CUDA_ARRAY_SPARSE_PROPERTIES, - mipmap: CUmipmappedArray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArrayDestroy(hArray: CUarray) -> CUresult; -} -extern_redirect! { - pub fn cuArray3DCreate( - pHandle: *mut CUarray, - pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArray3DCreate_v2( - pHandle: *mut CUarray, - pAllocateArray: *const CUDA_ARRAY3D_DESCRIPTOR, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArray3DGetDescriptor( - pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR, - hArray: CUarray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuArray3DGetDescriptor_v2( - pArrayDescriptor: *mut CUDA_ARRAY3D_DESCRIPTOR, - hArray: CUarray, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMipmappedArrayCreate( - pHandle: *mut CUmipmappedArray, - pMipmappedArrayDesc: *const CUDA_ARRAY3D_DESCRIPTOR, - numMipmapLevels: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMipmappedArrayGetLevel( - pLevelArray: *mut CUarray, - hMipmappedArray: CUmipmappedArray, - level: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMipmappedArrayDestroy(hMipmappedArray: CUmipmappedArray) -> CUresult; -} -extern_redirect! { - pub fn cuMemAddressReserve( - ptr: *mut CUdeviceptr, - size: usize, - alignment: usize, - addr: CUdeviceptr, - flags: ::std::os::raw::c_ulonglong, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemAddressFree(ptr: CUdeviceptr, size: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemCreate( - handle: *mut CUmemGenericAllocationHandle, - size: usize, - prop: *const CUmemAllocationProp, - flags: ::std::os::raw::c_ulonglong, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemRelease(handle: CUmemGenericAllocationHandle) -> CUresult; -} -extern_redirect! { - pub fn cuMemMap( - ptr: CUdeviceptr, - size: usize, - offset: usize, - handle: CUmemGenericAllocationHandle, - flags: ::std::os::raw::c_ulonglong, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemMapArrayAsync( - mapInfoList: *mut CUarrayMapInfo, - count: ::std::os::raw::c_uint, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemUnmap(ptr: CUdeviceptr, size: usize) -> CUresult; -} -extern_redirect! { - pub fn cuMemSetAccess( - ptr: CUdeviceptr, - size: usize, - desc: *const CUmemAccessDesc, - count: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetAccess( - flags: *mut ::std::os::raw::c_ulonglong, - location: *const CUmemLocation, - ptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemExportToShareableHandle( - shareableHandle: *mut ::std::os::raw::c_void, - handle: CUmemGenericAllocationHandle, - handleType: CUmemAllocationHandleType, - flags: ::std::os::raw::c_ulonglong, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemImportFromShareableHandle( - handle: *mut CUmemGenericAllocationHandle, - osHandle: *mut ::std::os::raw::c_void, - shHandleType: CUmemAllocationHandleType, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetAllocationGranularity( - granularity: *mut usize, - prop: *const CUmemAllocationProp, - option: CUmemAllocationGranularity_flags, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemGetAllocationPropertiesFromHandle( - prop: *mut CUmemAllocationProp, - handle: CUmemGenericAllocationHandle, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemRetainAllocationHandle( - handle: *mut CUmemGenericAllocationHandle, - addr: *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuPointerGetAttribute( - data: *mut ::std::os::raw::c_void, - attribute: CUpointer_attribute, - ptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemPrefetchAsync( - devPtr: CUdeviceptr, - count: usize, - dstDevice: CUdevice, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemAdvise( - devPtr: CUdeviceptr, - count: usize, - advice: CUmem_advise, - device: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemRangeGetAttribute( - data: *mut ::std::os::raw::c_void, - dataSize: usize, - attribute: CUmem_range_attribute, - devPtr: CUdeviceptr, - count: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuMemRangeGetAttributes( - data: *mut *mut ::std::os::raw::c_void, - dataSizes: *mut usize, - attributes: *mut CUmem_range_attribute, - numAttributes: usize, - devPtr: CUdeviceptr, - count: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuPointerSetAttribute( - value: *const ::std::os::raw::c_void, - attribute: CUpointer_attribute, - ptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuPointerGetAttributes( - numAttributes: ::std::os::raw::c_uint, - attributes: *mut CUpointer_attribute, - data: *mut *mut ::std::os::raw::c_void, - ptr: CUdeviceptr, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamCreate(phStream: *mut CUstream, Flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuStreamCreateWithPriority( - phStream: *mut CUstream, - flags: ::std::os::raw::c_uint, - priority: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamGetPriority(hStream: CUstream, priority: *mut ::std::os::raw::c_int) - -> CUresult; -} -extern_redirect! { - pub fn cuStreamGetFlags(hStream: CUstream, flags: *mut ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuStreamGetCtx(hStream: CUstream, pctx: *mut CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuStreamWaitEvent( - hStream: CUstream, - hEvent: CUevent, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamAddCallback( - hStream: CUstream, - callback: CUstreamCallback, - userData: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamBeginCapture(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult; -} -extern_redirect! { - pub fn cuStreamBeginCapture_v2(hStream: CUstream, mode: CUstreamCaptureMode) -> CUresult; -} -extern_redirect! { - pub fn cuThreadExchangeStreamCaptureMode(mode: *mut CUstreamCaptureMode) -> CUresult; -} -extern_redirect! { - pub fn cuStreamEndCapture(hStream: CUstream, phGraph: *mut CUgraph) -> CUresult; -} -extern_redirect! { - pub fn cuStreamIsCapturing( - hStream: CUstream, - captureStatus: *mut CUstreamCaptureStatus, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamGetCaptureInfo( - hStream: CUstream, - captureStatus: *mut CUstreamCaptureStatus, - id: *mut cuuint64_t, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamAttachMemAsync( - hStream: CUstream, - dptr: CUdeviceptr, - length: usize, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamQuery(hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuStreamSynchronize(hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuStreamDestroy(hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuStreamDestroy_v2(hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuStreamCopyAttributes(dst: CUstream, src: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuStreamGetAttribute( - hStream: CUstream, - attr: CUstreamAttrID, - value_out: *mut CUstreamAttrValue, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamSetAttribute( - hStream: CUstream, - attr: CUstreamAttrID, - value: *const CUstreamAttrValue, - ) -> CUresult; -} -extern_redirect! { - pub fn cuEventCreate(phEvent: *mut CUevent, Flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuEventRecord(hEvent: CUevent, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuEventRecordWithFlags( - hEvent: CUevent, - hStream: CUstream, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuEventQuery(hEvent: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuEventSynchronize(hEvent: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuEventDestroy(hEvent: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuEventDestroy_v2(hEvent: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuEventElapsedTime(pMilliseconds: *mut f32, hStart: CUevent, hEnd: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuImportExternalMemory( - extMem_out: *mut CUexternalMemory, - memHandleDesc: *const CUDA_EXTERNAL_MEMORY_HANDLE_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuExternalMemoryGetMappedBuffer( - devPtr: *mut CUdeviceptr, - extMem: CUexternalMemory, - bufferDesc: *const CUDA_EXTERNAL_MEMORY_BUFFER_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuExternalMemoryGetMappedMipmappedArray( - mipmap: *mut CUmipmappedArray, - extMem: CUexternalMemory, - mipmapDesc: *const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDestroyExternalMemory(extMem: CUexternalMemory) -> CUresult; -} -extern_redirect! { - pub fn cuImportExternalSemaphore( - extSem_out: *mut CUexternalSemaphore, - semHandleDesc: *const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuSignalExternalSemaphoresAsync( - extSemArray: *const CUexternalSemaphore, - paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS, - numExtSems: ::std::os::raw::c_uint, - stream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuWaitExternalSemaphoresAsync( - extSemArray: *const CUexternalSemaphore, - paramsArray: *const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS, - numExtSems: ::std::os::raw::c_uint, - stream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDestroyExternalSemaphore(extSem: CUexternalSemaphore) -> CUresult; -} -extern_redirect! { - pub fn cuStreamWaitValue32( - stream: CUstream, - addr: CUdeviceptr, - value: cuuint32_t, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamWaitValue64( - stream: CUstream, - addr: CUdeviceptr, - value: cuuint64_t, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamWriteValue32( - stream: CUstream, - addr: CUdeviceptr, - value: cuuint32_t, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamWriteValue64( - stream: CUstream, - addr: CUdeviceptr, - value: cuuint64_t, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuStreamBatchMemOp( - stream: CUstream, - count: ::std::os::raw::c_uint, - paramArray: *mut CUstreamBatchMemOpParams, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuFuncGetAttribute( - pi: *mut ::std::os::raw::c_int, - attrib: CUfunction_attribute, - hfunc: CUfunction, - ) -> CUresult; -} -extern_redirect! { - pub fn cuFuncSetAttribute( - hfunc: CUfunction, - attrib: CUfunction_attribute, - value: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuFuncSetCacheConfig(hfunc: CUfunction, config: CUfunc_cache) -> CUresult; -} -extern_redirect! { - pub fn cuFuncSetSharedMemConfig(hfunc: CUfunction, config: CUsharedconfig) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchKernel( - f: CUfunction, - gridDimX: ::std::os::raw::c_uint, - gridDimY: ::std::os::raw::c_uint, - gridDimZ: ::std::os::raw::c_uint, - blockDimX: ::std::os::raw::c_uint, - blockDimY: ::std::os::raw::c_uint, - blockDimZ: ::std::os::raw::c_uint, - sharedMemBytes: ::std::os::raw::c_uint, - hStream: CUstream, - kernelParams: *mut *mut ::std::os::raw::c_void, - extra: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchCooperativeKernel( - f: CUfunction, - gridDimX: ::std::os::raw::c_uint, - gridDimY: ::std::os::raw::c_uint, - gridDimZ: ::std::os::raw::c_uint, - blockDimX: ::std::os::raw::c_uint, - blockDimY: ::std::os::raw::c_uint, - blockDimZ: ::std::os::raw::c_uint, - sharedMemBytes: ::std::os::raw::c_uint, - hStream: CUstream, - kernelParams: *mut *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchCooperativeKernelMultiDevice( - launchParamsList: *mut CUDA_LAUNCH_PARAMS, - numDevices: ::std::os::raw::c_uint, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchHostFunc( - hStream: CUstream, - fn_: CUhostFn, - userData: *mut ::std::os::raw::c_void, - ) -> CUresult; -} -extern_redirect! { - pub fn cuFuncSetBlockShape( - hfunc: CUfunction, - x: ::std::os::raw::c_int, - y: ::std::os::raw::c_int, - z: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuFuncSetSharedSize(hfunc: CUfunction, bytes: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuParamSetSize(hfunc: CUfunction, numbytes: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuParamSeti( - hfunc: CUfunction, - offset: ::std::os::raw::c_int, - value: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuParamSetf(hfunc: CUfunction, offset: ::std::os::raw::c_int, value: f32) -> CUresult; -} -extern_redirect! { - pub fn cuParamSetv( - hfunc: CUfunction, - offset: ::std::os::raw::c_int, - ptr: *mut ::std::os::raw::c_void, - numbytes: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLaunch(f: CUfunction) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchGrid( - f: CUfunction, - grid_width: ::std::os::raw::c_int, - grid_height: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuLaunchGridAsync( - f: CUfunction, - grid_width: ::std::os::raw::c_int, - grid_height: ::std::os::raw::c_int, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuParamSetTexRef( - hfunc: CUfunction, - texunit: ::std::os::raw::c_int, - hTexRef: CUtexref, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphCreate(phGraph: *mut CUgraph, flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddKernelNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - nodeParams: *const CUDA_KERNEL_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphKernelNodeGetParams( - hNode: CUgraphNode, - nodeParams: *mut CUDA_KERNEL_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphKernelNodeSetParams( - hNode: CUgraphNode, - nodeParams: *const CUDA_KERNEL_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddMemcpyNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - copyParams: *const CUDA_MEMCPY3D, - ctx: CUcontext, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphMemcpyNodeGetParams( - hNode: CUgraphNode, - nodeParams: *mut CUDA_MEMCPY3D, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphMemcpyNodeSetParams( - hNode: CUgraphNode, - nodeParams: *const CUDA_MEMCPY3D, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddMemsetNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - memsetParams: *const CUDA_MEMSET_NODE_PARAMS, - ctx: CUcontext, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphMemsetNodeGetParams( - hNode: CUgraphNode, - nodeParams: *mut CUDA_MEMSET_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphMemsetNodeSetParams( - hNode: CUgraphNode, - nodeParams: *const CUDA_MEMSET_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddHostNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - nodeParams: *const CUDA_HOST_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphHostNodeGetParams( - hNode: CUgraphNode, - nodeParams: *mut CUDA_HOST_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphHostNodeSetParams( - hNode: CUgraphNode, - nodeParams: *const CUDA_HOST_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddChildGraphNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - childGraph: CUgraph, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphChildGraphNodeGetGraph(hNode: CUgraphNode, phGraph: *mut CUgraph) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddEmptyNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddEventRecordNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - event: CUevent, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphEventRecordNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuGraphEventRecordNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddEventWaitNode( - phGraphNode: *mut CUgraphNode, - hGraph: CUgraph, - dependencies: *const CUgraphNode, - numDependencies: usize, - event: CUevent, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphEventWaitNodeGetEvent(hNode: CUgraphNode, event_out: *mut CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuGraphEventWaitNodeSetEvent(hNode: CUgraphNode, event: CUevent) -> CUresult; -} -extern_redirect! { - pub fn cuGraphClone(phGraphClone: *mut CUgraph, originalGraph: CUgraph) -> CUresult; -} -extern_redirect! { - pub fn cuGraphNodeFindInClone( - phNode: *mut CUgraphNode, - hOriginalNode: CUgraphNode, - hClonedGraph: CUgraph, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphNodeGetType(hNode: CUgraphNode, type_: *mut CUgraphNodeType) -> CUresult; -} -extern_redirect! { - pub fn cuGraphGetNodes( - hGraph: CUgraph, - nodes: *mut CUgraphNode, - numNodes: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphGetRootNodes( - hGraph: CUgraph, - rootNodes: *mut CUgraphNode, - numRootNodes: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphGetEdges( - hGraph: CUgraph, - from: *mut CUgraphNode, - to: *mut CUgraphNode, - numEdges: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphNodeGetDependencies( - hNode: CUgraphNode, - dependencies: *mut CUgraphNode, - numDependencies: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphNodeGetDependentNodes( - hNode: CUgraphNode, - dependentNodes: *mut CUgraphNode, - numDependentNodes: *mut usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphAddDependencies( - hGraph: CUgraph, - from: *const CUgraphNode, - to: *const CUgraphNode, - numDependencies: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphRemoveDependencies( - hGraph: CUgraph, - from: *const CUgraphNode, - to: *const CUgraphNode, - numDependencies: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphDestroyNode(hNode: CUgraphNode) -> CUresult; -} -extern_redirect! { - pub fn cuGraphInstantiate( - phGraphExec: *mut CUgraphExec, - hGraph: CUgraph, - phErrorNode: *mut CUgraphNode, - logBuffer: *mut ::std::os::raw::c_char, - bufferSize: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphInstantiate_v2( - phGraphExec: *mut CUgraphExec, - hGraph: CUgraph, - phErrorNode: *mut CUgraphNode, - logBuffer: *mut ::std::os::raw::c_char, - bufferSize: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecKernelNodeSetParams( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - nodeParams: *const CUDA_KERNEL_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecMemcpyNodeSetParams( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - copyParams: *const CUDA_MEMCPY3D, - ctx: CUcontext, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecMemsetNodeSetParams( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - memsetParams: *const CUDA_MEMSET_NODE_PARAMS, - ctx: CUcontext, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecHostNodeSetParams( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - nodeParams: *const CUDA_HOST_NODE_PARAMS, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecChildGraphNodeSetParams( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - childGraph: CUgraph, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecEventRecordNodeSetEvent( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - event: CUevent, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecEventWaitNodeSetEvent( - hGraphExec: CUgraphExec, - hNode: CUgraphNode, - event: CUevent, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphUpload(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuGraphLaunch(hGraphExec: CUgraphExec, hStream: CUstream) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecDestroy(hGraphExec: CUgraphExec) -> CUresult; -} -extern_redirect! { - pub fn cuGraphDestroy(hGraph: CUgraph) -> CUresult; -} -extern_redirect! { - pub fn cuGraphExecUpdate( - hGraphExec: CUgraphExec, - hGraph: CUgraph, - hErrorNode_out: *mut CUgraphNode, - updateResult_out: *mut CUgraphExecUpdateResult, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphKernelNodeCopyAttributes(dst: CUgraphNode, src: CUgraphNode) -> CUresult; -} -extern_redirect! { - pub fn cuGraphKernelNodeGetAttribute( - hNode: CUgraphNode, - attr: CUkernelNodeAttrID, - value_out: *mut CUkernelNodeAttrValue, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphKernelNodeSetAttribute( - hNode: CUgraphNode, - attr: CUkernelNodeAttrID, - value: *const CUkernelNodeAttrValue, - ) -> CUresult; -} -extern_redirect! { - pub fn cuOccupancyMaxActiveBlocksPerMultiprocessor( - numBlocks: *mut ::std::os::raw::c_int, - func: CUfunction, - blockSize: ::std::os::raw::c_int, - dynamicSMemSize: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( - numBlocks: *mut ::std::os::raw::c_int, - func: CUfunction, - blockSize: ::std::os::raw::c_int, - dynamicSMemSize: usize, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuOccupancyMaxPotentialBlockSize( - minGridSize: *mut ::std::os::raw::c_int, - blockSize: *mut ::std::os::raw::c_int, - func: CUfunction, - blockSizeToDynamicSMemSize: CUoccupancyB2DSize, - dynamicSMemSize: usize, - blockSizeLimit: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuOccupancyMaxPotentialBlockSizeWithFlags( - minGridSize: *mut ::std::os::raw::c_int, - blockSize: *mut ::std::os::raw::c_int, - func: CUfunction, - blockSizeToDynamicSMemSize: CUoccupancyB2DSize, - dynamicSMemSize: usize, - blockSizeLimit: ::std::os::raw::c_int, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuOccupancyAvailableDynamicSMemPerBlock( - dynamicSmemSize: *mut usize, - func: CUfunction, - numBlocks: ::std::os::raw::c_int, - blockSize: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetArray( - hTexRef: CUtexref, - hArray: CUarray, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetMipmappedArray( - hTexRef: CUtexref, - hMipmappedArray: CUmipmappedArray, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetAddress( - ByteOffset: *mut usize, - hTexRef: CUtexref, - dptr: CUdeviceptr, - bytes: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetAddress_v2( - ByteOffset: *mut usize, - hTexRef: CUtexref, - dptr: CUdeviceptr, - bytes: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetAddress2D_v3( - hTexRef: CUtexref, - desc: *const CUDA_ARRAY_DESCRIPTOR, - dptr: CUdeviceptr, - Pitch: usize, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetFormat( - hTexRef: CUtexref, - fmt: CUarray_format, - NumPackedComponents: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetAddressMode( - hTexRef: CUtexref, - dim: ::std::os::raw::c_int, - am: CUaddress_mode, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetMipmapFilterMode(hTexRef: CUtexref, fm: CUfilter_mode) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetMipmapLevelBias(hTexRef: CUtexref, bias: f32) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetMipmapLevelClamp( - hTexRef: CUtexref, - minMipmapLevelClamp: f32, - maxMipmapLevelClamp: f32, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetMaxAnisotropy( - hTexRef: CUtexref, - maxAniso: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetBorderColor(hTexRef: CUtexref, pBorderColor: *mut f32) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefSetFlags(hTexRef: CUtexref, Flags: ::std::os::raw::c_uint) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetAddress(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetAddress_v2(pdptr: *mut CUdeviceptr, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetArray(phArray: *mut CUarray, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetMipmappedArray( - phMipmappedArray: *mut CUmipmappedArray, - hTexRef: CUtexref, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetAddressMode( - pam: *mut CUaddress_mode, - hTexRef: CUtexref, - dim: ::std::os::raw::c_int, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetFormat( - pFormat: *mut CUarray_format, - pNumChannels: *mut ::std::os::raw::c_int, - hTexRef: CUtexref, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetMipmapFilterMode(pfm: *mut CUfilter_mode, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetMipmapLevelBias(pbias: *mut f32, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetMipmapLevelClamp( - pminMipmapLevelClamp: *mut f32, - pmaxMipmapLevelClamp: *mut f32, - hTexRef: CUtexref, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetMaxAnisotropy( - pmaxAniso: *mut ::std::os::raw::c_int, - hTexRef: CUtexref, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetBorderColor(pBorderColor: *mut f32, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefGetFlags(pFlags: *mut ::std::os::raw::c_uint, hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefCreate(pTexRef: *mut CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuTexRefDestroy(hTexRef: CUtexref) -> CUresult; -} -extern_redirect! { - pub fn cuSurfRefSetArray( - hSurfRef: CUsurfref, - hArray: CUarray, - Flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuSurfRefGetArray(phArray: *mut CUarray, hSurfRef: CUsurfref) -> CUresult; -} -extern_redirect! { - pub fn cuTexObjectCreate( - pTexObject: *mut CUtexObject, - pResDesc: *const CUDA_RESOURCE_DESC, - pTexDesc: *const CUDA_TEXTURE_DESC, - pResViewDesc: *const CUDA_RESOURCE_VIEW_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexObjectDestroy(texObject: CUtexObject) -> CUresult; -} -extern_redirect! { - pub fn cuTexObjectGetResourceDesc( - pResDesc: *mut CUDA_RESOURCE_DESC, - texObject: CUtexObject, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexObjectGetTextureDesc( - pTexDesc: *mut CUDA_TEXTURE_DESC, - texObject: CUtexObject, - ) -> CUresult; -} -extern_redirect! { - pub fn cuTexObjectGetResourceViewDesc( - pResViewDesc: *mut CUDA_RESOURCE_VIEW_DESC, - texObject: CUtexObject, - ) -> CUresult; -} -extern_redirect! { - pub fn cuSurfObjectCreate( - pSurfObject: *mut CUsurfObject, - pResDesc: *const CUDA_RESOURCE_DESC, - ) -> CUresult; -} -extern_redirect! { - pub fn cuSurfObjectDestroy(surfObject: CUsurfObject) -> CUresult; -} -extern_redirect! { - pub fn cuSurfObjectGetResourceDesc( - pResDesc: *mut CUDA_RESOURCE_DESC, - surfObject: CUsurfObject, - ) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceCanAccessPeer( - canAccessPeer: *mut ::std::os::raw::c_int, - dev: CUdevice, - peerDev: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuCtxEnablePeerAccess(peerContext: CUcontext, Flags: ::std::os::raw::c_uint) - -> CUresult; -} -extern_redirect! { - pub fn cuCtxDisablePeerAccess(peerContext: CUcontext) -> CUresult; -} -extern_redirect! { - pub fn cuDeviceGetP2PAttribute( - value: *mut ::std::os::raw::c_int, - attrib: CUdevice_P2PAttribute, - srcDevice: CUdevice, - dstDevice: CUdevice, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsUnregisterResource(resource: CUgraphicsResource) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsSubResourceGetMappedArray( - pArray: *mut CUarray, - resource: CUgraphicsResource, - arrayIndex: ::std::os::raw::c_uint, - mipLevel: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsResourceGetMappedMipmappedArray( - pMipmappedArray: *mut CUmipmappedArray, - resource: CUgraphicsResource, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsResourceGetMappedPointer( - pDevPtr: *mut CUdeviceptr, - pSize: *mut usize, - resource: CUgraphicsResource, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsResourceGetMappedPointer_v2( - pDevPtr: *mut CUdeviceptr, - pSize: *mut usize, - resource: CUgraphicsResource, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsResourceSetMapFlags( - resource: CUgraphicsResource, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsResourceSetMapFlags_v2( - resource: CUgraphicsResource, - flags: ::std::os::raw::c_uint, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsMapResources( - count: ::std::os::raw::c_uint, - resources: *mut CUgraphicsResource, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect! { - pub fn cuGraphicsUnmapResources( - count: ::std::os::raw::c_uint, - resources: *mut CUgraphicsResource, - hStream: CUstream, - ) -> CUresult; -} -extern_redirect_with_post! { - pub fn cuGetExportTable( - ppExportTable: *mut *const ::std::os::raw::c_void, - pExportTableId: *const CUuuid, - ) -> CUresult; - super::cuGetExportTable_Post; -} -extern_redirect! { - pub fn cuFuncGetModule(hmod: *mut CUmodule, hfunc: CUfunction) -> CUresult; -} -#[repr(transparent)] -#[derive(Copy, Clone, Hash, PartialEq, Eq)] -pub struct CUoutput_mode_enum(pub ::std::os::raw::c_uint); -pub use self::CUoutput_mode_enum as CUoutput_mode; -extern_redirect! { - pub fn cuProfilerInitialize( - configFile: *const ::std::os::raw::c_char, - outputFile: *const ::std::os::raw::c_char, - outputMode: CUoutput_mode, - ) -> CUresult; -} -extern_redirect! { - pub fn cuProfilerStart() -> CUresult; -} -extern_redirect! { - pub fn cuProfilerStop() -> CUresult; -} diff --git a/zluda_dump/src/dark_api.rs b/zluda_dump/src/dark_api.rs index 3ae50ed..50ce088 100644 --- a/zluda_dump/src/dark_api.rs +++ b/zluda_dump/src/dark_api.rs @@ -1,11 +1,9 @@ +use crate::format; +use crate::{log, os, trace::StateTracker}; use crate::{log::UInt, GlobalDelayedState}; +use cuda_types::{CUmodule, CUresult, CUuuid}; use std::borrow::Cow; - -use crate::{ - cuda::{CUmodule, CUresult, CUuuid}, - log, os, - trace::StateTracker, -}; +use std::hash::Hash; use std::{ collections::{hash_map, HashMap}, ffi::c_void, @@ -17,10 +15,19 @@ use std::{ pub(crate) struct DarkApiState { // Key is Box, Vec<*const c_void>>, + overrides: HashMap, Vec<*const c_void>>, original: OriginalExports, } +#[derive(Eq, PartialEq)] +pub(crate) struct CUuuidWrapper(pub CUuuid); + +impl Hash for CUuuidWrapper { + fn hash(&self, state: &mut H) { + self.0.bytes.hash(state); + } +} + pub(crate) struct OriginalExports { original_get_module_from_cubin: Option< unsafe extern "system" fn( @@ -69,11 +76,13 @@ pub(crate) fn override_export_table( ) { let state = &mut state.dark_api; let export_table_mut = unsafe { &mut *pp_export_table }; - let export_id = Box::new(unsafe { *p_export_table_id }); + let export_id = Box::new(CUuuidWrapper(unsafe { *p_export_table_id })); *export_table_mut = match state.overrides.entry(export_id) { hash_map::Entry::Occupied(entry) => entry.get().as_ptr() as *const _, hash_map::Entry::Vacant(entry) => { - let guid_ptr = &**entry.key() as *const _; + let guid_ptr = unsafe { + mem::transmute::<*const CUuuidWrapper, *const CUuuid>(&**entry.key() as *const _) + }; entry .insert(unsafe { create_new_override(*pp_export_table as *const _, guid_ptr, &mut state.original) @@ -123,7 +132,7 @@ unsafe extern "system" fn report_unknown_export_table_call( if let Ok(mut global_state) = crate::GLOBAL_STATE.lock() { let mut logger = global_state .log_factory - .get_logger_dark_api(*export_table, idx); + .get_logger_dark_api(*export_table, idx, None); logger.log(log::LogEntry::UnknownExportTableFn) } } @@ -351,10 +360,21 @@ unsafe extern "system" fn get_module_from_cubin( module: *mut CUmodule, fatbinc_wrapper: *const FatbincWrapper, ) -> CUresult { + let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| { + writer.write_all(b"(")?; + writer.write_all(stringify!(module).as_bytes())?; + writer.write_all(b": ")?; + format::CudaDisplay::write(&module, writer)?; + writer.write_all(b", ")?; + writer.write_all(stringify!(fatbinc_wrapper).as_bytes())?; + write!(writer, ": {:p})", fatbinc_wrapper) + }); let global_state = &mut *super::GLOBAL_STATE.lock().unwrap(); - let mut fn_logger = global_state - .log_factory - .get_logger_dark_api(CUDART_INTERFACE_GUID, 1); + let mut fn_logger = global_state.log_factory.get_logger_dark_api( + CUDART_INTERFACE_GUID, + 1, + Some(arguments_writer), + ); let global_state = &mut *super::GLOBAL_STATE.lock().unwrap(); let delayed_state = global_state.delayed_state.unwrap_mut(); record_submodules_from_wrapped_fatbin( @@ -375,10 +395,27 @@ unsafe extern "system" fn get_module_from_cubin_ext1( ptr2: *mut c_void, _unknown: usize, ) -> CUresult { + let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| { + writer.write_all(b"(")?; + writer.write_all(stringify!(module).as_bytes())?; + writer.write_all(b": ")?; + format::CudaDisplay::write(&module, writer)?; + writer.write_all(b", ")?; + writer.write_all(stringify!(fatbinc_wrapper).as_bytes())?; + write!(writer, ": {:p}, ", fatbinc_wrapper)?; + writer.write_all(stringify!(ptr1).as_bytes())?; + write!(writer, ": {:p}, ", ptr1)?; + writer.write_all(stringify!(ptr2).as_bytes())?; + write!(writer, ": {:p}, ", ptr2)?; + writer.write_all(stringify!(_unknown).as_bytes())?; + write!(writer, ": {})", _unknown) + }); let global_state = &mut *super::GLOBAL_STATE.lock().unwrap(); - let mut fn_logger = global_state - .log_factory - .get_logger_dark_api(CUDART_INTERFACE_GUID, 6); + let mut fn_logger = global_state.log_factory.get_logger_dark_api( + CUDART_INTERFACE_GUID, + 6, + Some(arguments_writer), + ); if ptr1 != ptr::null_mut() { fn_logger.log(log::LogEntry::UnexpectedArgument { arg_name: stringify!(ptr1), @@ -421,10 +458,27 @@ unsafe extern "system" fn get_module_from_cubin_ext2( ptr2: *mut c_void, _unknown: usize, ) -> CUresult { + let arguments_writer = Box::new(move |writer: &mut dyn std::io::Write| { + writer.write_all(b"(")?; + writer.write_all(stringify!(fatbin_header).as_bytes())?; + write!(writer, ": {:p}, ", fatbin_header)?; + writer.write_all(stringify!(module).as_bytes())?; + writer.write_all(b": ")?; + format::CudaDisplay::write(&module, writer)?; + writer.write_all(b", ")?; + writer.write_all(stringify!(ptr1).as_bytes())?; + write!(writer, ": {:p}, ", ptr1)?; + writer.write_all(stringify!(ptr2).as_bytes())?; + write!(writer, ": {:p}, ", ptr2)?; + writer.write_all(stringify!(_unknown).as_bytes())?; + write!(writer, ": {})", _unknown) + }); let global_state = &mut *super::GLOBAL_STATE.lock().unwrap(); - let mut fn_logger = global_state - .log_factory - .get_logger_dark_api(CUDART_INTERFACE_GUID, 8); + let mut fn_logger = global_state.log_factory.get_logger_dark_api( + CUDART_INTERFACE_GUID, + 8, + Some(arguments_writer), + ); if ptr1 != ptr::null_mut() { fn_logger.log(log::LogEntry::UnexpectedArgument { arg_name: stringify!(ptr1), diff --git a/zluda_dump/src/format.rs b/zluda_dump/src/format.rs index bee8d4c..5577b30 100644 --- a/zluda_dump/src/format.rs +++ b/zluda_dump/src/format.rs @@ -1,953 +1,577 @@ -use paste::paste; +extern crate cuda_types; use std::{ ffi::{c_void, CStr}, - io::Write, - mem, ptr, + fmt::LowerHex, + mem, ptr, slice, }; -use crate::cuda::*; +use cuda_base::cuda_derive_display_trait; -pub(crate) trait FormatCudaObject { - fn write_post_execution(self, result: CUresult, f: &mut impl Write); +pub(crate) trait CudaDisplay { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()>; } -fn write_post_execution_ptr( - t: *const T, - result: CUresult, - f: &mut impl Write, -) { - if t == ptr::null() { - write!(f, "NULL").ok(); - } else if result != CUresult::CUDA_SUCCESS { - write!(f, "NONE").ok(); - } else { - unsafe { *t }.write_post_execution(result, f) - } -} - -impl FormatCudaObject for *mut T { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write_post_execution_ptr(self, result, f) - } -} - -impl FormatCudaObject for *const T { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write_post_execution_ptr(self, result, f) +impl CudaDisplay for cuda_types::CUuuid { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + let guid = self.bytes; + write!(writer, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]) } } -impl FormatCudaObject for CUmodule { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUdevice { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", self.0) } } -impl FormatCudaObject for CUfunction { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUdeviceptr { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", self.0) } } -impl FormatCudaObject for *mut c_void { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUdeviceptr_v1 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", self.0 as usize as *const ()) } } -impl FormatCudaObject for *const c_void { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for u8 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUstream { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for u16 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUgraphicsResource { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for i32 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUdeviceptr { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self.0 as *const ()).ok(); +impl CudaDisplay for u32 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUtexref { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self as *const ()).ok(); +impl CudaDisplay for u64 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUmipmappedArray { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for usize { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUarray { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for f32 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{}", *self) } } -impl FormatCudaObject for CUcontext { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +pub fn write_handle( + this: &[T; 64], + writer: &mut (impl std::io::Write + ?Sized), +) -> std::io::Result<()> { + writer.write_all(b"0x")?; + for i in (0..64).rev() { + write!(writer, "{:02x}", this[i])?; } + Ok(()) } -impl FormatCudaObject for CUsurfref { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUipcMemHandle { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write_handle(&self.reserved, writer) } } -impl FormatCudaObject for CUgraphNode { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUipcEventHandle { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write_handle(&self.reserved, writer) } } -impl FormatCudaObject for CUgraphExec { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for cuda_types::CUmemPoolPtrExportData_v1 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write_handle(&self.reserved, writer) } } -impl FormatCudaObject for CUevent { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for *mut c_void { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", *self) } } -impl FormatCudaObject for CUgraph { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for *const c_void { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!(writer, "{:p}", *self) } } -impl FormatCudaObject for CUexternalSemaphore { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for *const i8 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!( + writer, + "\"{}\"", + unsafe { CStr::from_ptr(*self as _) }.to_string_lossy() + ) } } -impl FormatCudaObject for CUexternalMemory { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{:p}", self).ok(); +impl CudaDisplay for *mut i8 { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + write!( + writer, + "\"{}\"", + unsafe { CStr::from_ptr(*self as _) }.to_string_lossy() + ) } } -impl FormatCudaObject for CUhostFn { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) { - Some(x) => write!(f, "{:p}", x), - None => write!(f, "NULL"), +impl CudaDisplay for cuda_types::CUstreamBatchMemOpParams { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + unsafe { + match self.operation { + // The below is not a typo, `WAIT_VALUE` and `WRITE_VALUE` are + // distinct operations with nominally distinct union variants, but + // in reality they are structurally different, so we take a little + // shortcut here + cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_32 + | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_32 => { + write_wait_value(&self.waitValue, writer, false) + } + cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WAIT_VALUE_64 + | cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_WRITE_VALUE_64 => { + write_wait_value(&self.waitValue, writer, true) + } + cuda_types::CUstreamBatchMemOpType::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES => { + CudaDisplay::write(&self.flushRemoteWrites, writer) + } + _ => { + writer.write_all(b"{ operation: ")?; + CudaDisplay::write(&self.operation, writer)?; + writer.write_all(b", ... }") + } + } } - .ok(); } } -impl FormatCudaObject for CUoccupancyB2DSize { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match self.map(|x| unsafe { mem::transmute::<_, *const ()>(x) }) { - Some(x) => write!(f, "{:p}", x), - None => write!(f, "NULL"), - } - .ok(); +pub fn write_wait_value( + this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st, + writer: &mut (impl std::io::Write + ?Sized), + is_64_bit: bool, +) -> std::io::Result<()> { + writer.write_all(b"{ operation: ")?; + CudaDisplay::write(&this.operation, writer)?; + writer.write_all(b", address: ")?; + CudaDisplay::write(&this.address, writer)?; + write_wait_value_32_or_64(&this.__bindgen_anon_1, writer, is_64_bit)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&this.flags, writer)?; + writer.write_all(b", alias: ")?; + CudaDisplay::write(&this.alias, writer)?; + writer.write_all(b" }") +} + +pub fn write_wait_value_32_or_64( + this: &cuda_types::CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st__bindgen_ty_1, + writer: &mut (impl std::io::Write + ?Sized), + is_64_bit: bool, +) -> std::io::Result<()> { + if is_64_bit { + writer.write_all(b", value64: ")?; + CudaDisplay::write(unsafe { &this.value64 }, writer) + } else { + writer.write_all(b", value: ")?; + CudaDisplay::write(unsafe { &this.value }, writer) } } -impl FormatCudaObject for CUDA_RESOURCE_DESC { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { +impl CudaDisplay for cuda_types::CUDA_RESOURCE_DESC_st { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"{ resType: ")?; + CudaDisplay::write(&self.resType, writer)?; match self.resType { - CU_RESOURCE_TYPE_ARRAY => { - write!( - f, - "{{resType: CU_RESOURCE_TYPE_ARRAY, hArray: {:p}, flags: {}}}", - self.res.array.hArray, self.flags - ) + cuda_types::CUresourcetype::CU_RESOURCE_TYPE_ARRAY => { + writer.write_all(b", res: ")?; + CudaDisplay::write(unsafe { &self.res.array }, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") } - CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => { - write!( - f, - "{{resType: CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, hMipmappedArray: {:p}, flags: {}}}", - self.res.mipmap.hMipmappedArray, self.flags - ) + cuda_types::CUresourcetype::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY => { + writer.write_all(b", res: ")?; + CudaDisplay::write(unsafe { &self.res.mipmap }, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") } - CU_RESOURCE_TYPE_LINEAR => { - write!( - f, - "{{resType: CU_RESOURCE_TYPE_LINEAR, devPtr: {:p}, format:", - self.res.linear.devPtr.0 as *const () - ).ok(); - self.res.linear.format.write_post_execution(result, f); - write!( - f, - ", numChannels: {}, sizeInBytes: {}}}", - self.res.linear.numChannels, self.res.linear.sizeInBytes, - ) + cuda_types::CUresourcetype::CU_RESOURCE_TYPE_LINEAR => { + writer.write_all(b", res: ")?; + CudaDisplay::write(unsafe { &self.res.linear }, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") } - CU_RESOURCE_TYPE_PITCH2D => { - write!( - f, - "{{resType: CU_RESOURCE_TYPE_PITCH2D, devPtr: {:p}, format:", - self.res.pitch2D.devPtr.0 as *const () - ).ok(); - self.res.pitch2D.format.write_post_execution(result, f); - write!( - f, - ", numChannels: {}, width: {}, height: {}, pitchInBytes: {}}}", - self.res.pitch2D.numChannels, self.res.pitch2D.width, self.res.pitch2D.height, self.res.pitch2D.pitchInBytes - ) + cuda_types::CUresourcetype::CU_RESOURCE_TYPE_PITCH2D => { + writer.write_all(b", res: ")?; + CudaDisplay::write(unsafe { &self.res.pitch2D }, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") } _ => { - write!(f, "{{resType: {}, flags: {}}}", self.resType.0, self.flags) + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b", ... }") } } - .ok(); - } -} - -impl FormatCudaObject for CUDA_RESOURCE_VIEW_DESC { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{{format: ").ok(); - self.format.write_post_execution(result, f); - write!( - f, - ", width: {}, height: {}, depth: {}, firstMipmapLevel: {}, lastMipmapLevel: {}, firstLayer: {}, lastLayer: {}}}", - self.width, - self.height, - self.depth, - self.firstMipmapLevel, - self.lastMipmapLevel, - self.firstLayer, - self.lastLayer - ).ok(); - } -} - -impl FormatCudaObject for CUDA_TEXTURE_DESC { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{{addressMode: [").ok(); - let [addressMode_0, addressMode_1, addressMode_2] = self.addressMode; - addressMode_0.write_post_execution(result, f); - write!(f, ", ").ok(); - addressMode_1.write_post_execution(result, f); - write!(f, ", ").ok(); - addressMode_2.write_post_execution(result, f); - write!( - f, - "], flags: {}, maxAnisotropy: {}, mipmapFilterMode: ", - self.flags, self.maxAnisotropy - ); - self.mipmapFilterMode.write_post_execution(result, f); - write!( - f, - ", mipmapLevelBias: {}, minMipmapLevelClamp: {}, maxMipmapLevelClamp: {}, borderColor: [{}, {}, {}, {}]}}", - self.mipmapLevelBias, - self.minMipmapLevelClamp, - self.maxMipmapLevelClamp, - self.borderColor[0], - self.borderColor[1], - self.borderColor[2], - self.borderColor[3] - ).ok(); - } -} - -impl FormatCudaObject for CUDA_ARRAY_DESCRIPTOR { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!( - f, - "{{Width: {}, Height: {}, Format: ", - self.Width, self.Height - ) - .ok(); - self.Format.write_post_execution(result, f); - write!(f, ", NumChannels: {}}}", self.NumChannels).ok(); - } -} - -impl FormatCudaObject for CUDA_MEMCPY3D { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!( - f, - "{{srcXInBytes: {}, srcY: {}, srcZ: {}, srcLOD: {}, srcMemoryType: ", - self.srcXInBytes, self.srcY, self.srcZ, self.srcLOD, - ) - .ok(); - self.srcMemoryType.write_post_execution(result, f); - write!( - f, - ", srcHost: {:p}, srcDevice: {:p}, srcArray: {:p}, srcPitch: {}, srcHeight: {}, dstXInBytes: {}, dstY: {}, dstZ: {}, dstLOD: {}, dstMemoryType: ", - self.srcHost, - self.srcDevice.0 as *const (), - self.srcArray, - self.srcPitch, - self.srcHeight, - self.dstXInBytes, - self.dstY, - self.dstZ, - self.dstLOD, - ).ok(); - self.dstMemoryType.write_post_execution(result, f); - write!( - f, - ", dstHost: {:p}, dstDevice: {:p}, dstArray: {:p}, dstPitch: {}, dstHeight: {}, WidthInBytes: {}, Height: {}, Depth: {}}}", - self.dstHost, - self.dstDevice.0 as *const (), - self.dstArray, - self.dstPitch, - self.dstHeight, - self.WidthInBytes, - self.Height, - self.Depth, - ).ok(); - } -} - -impl FormatCudaObject for CUmemLocation { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{{type: ").ok(); - self.type_.write_post_execution(result, f); - write!(f, ", id: {}}}", self.id).ok(); - } -} - -impl FormatCudaObject for *const i8 { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!( - f, - "\"{}\"", - unsafe { CStr::from_ptr(self) }.to_str().unwrap() - ) - .ok(); - } -} - -impl FormatCudaObject for u32 { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self).ok(); - } -} - -impl FormatCudaObject for u64 { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self).ok(); - } -} - -impl FormatCudaObject for i32 { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self).ok(); } } -impl FormatCudaObject for f32 { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self).ok(); - } -} - -impl FormatCudaObject for CUdevice { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self.0).ok(); - } -} - -impl FormatCudaObject for usize { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self).ok(); - } -} - -// TODO: support it properly -impl FormatCudaObject for CUoutput_mode { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - write!(f, "{}", self.0).ok(); - } -} - -impl FormatCudaObject for CUuuid { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - let guid = self.bytes; - write!(f, "{{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]).ok(); - } -} - -// ENUMS - -/* -impl FormatCudaObject for CUjit_option { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cujit_option(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), +impl CudaDisplay for cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"{ type: ")?; + CudaDisplay::write(&self.type_, writer)?; + match self.type_ { + cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.fd }, writer)?; + } + cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 + | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP + | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE + |cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE => { + write_win32_handle(unsafe { self.handle.win32 }, writer)?; + } + cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT + | cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?; + } + cuda_types::CUexternalMemoryHandleType::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.nvSciBufObject }, writer)?; + } + _ => { + writer.write_all(b", size: ")?; + CudaDisplay::write(&self.size, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + return writer.write_all(b", ... }") + } } - .ok(); - } -} - -impl FormatCudaObject for CUdevice_attribute { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cudevice_attribute(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), + writer.write_all(b", size: ")?; + CudaDisplay::write(&self.size, writer)?; + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") + } +} + +pub fn write_win32_handle( + win32: cuda_types::CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st__bindgen_ty_1__bindgen_ty_1, + writer: &mut (impl std::io::Write + ?Sized), +) -> std::io::Result<()> { + if win32.handle != ptr::null_mut() { + writer.write_all(b", handle: ")?; + CudaDisplay::write(&win32.handle, writer)?; + } + if win32.name != ptr::null_mut() { + let name_ptr = win32.name as *const u16; + let mut strlen = 0usize; + while unsafe { *name_ptr.add(strlen) } != 0 { + strlen += 1; } - .ok(); + let text = String::from_utf16_lossy(unsafe { slice::from_raw_parts(name_ptr, strlen) }); + write!(writer, ", name: \"{}\"", text)?; } + Ok(()) } -impl FormatCudaObject for CUdevice_P2PAttribute { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cudevice_p2pattribute(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), +impl CudaDisplay for cuda_types::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"{ type: ")?; + CudaDisplay::write(&self.type_, writer)?; + match self.type_ { + cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.fd }, writer)?; + } + cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 + | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE + | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE + | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX + | cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT => { + write_win32_handle(unsafe { mem::transmute(self.handle.win32) }, writer)?; + } + cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.win32.handle }, writer)?; + } + cuda_types::CUexternalSemaphoreHandleType::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC => { + writer.write_all(b", handle: ")?; + CudaDisplay::write(unsafe { &self.handle.nvSciSyncObj }, writer)?; + } + _ => { + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + return writer.write_all(b", ... }") + } } - .ok(); + writer.write_all(b", flags: ")?; + CudaDisplay::write(&self.flags, writer)?; + writer.write_all(b" }") } } -impl FormatCudaObject for CUarray_format { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cuarray_format(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), - } - .ok(); +impl CudaDisplay + for cuda_types::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st__bindgen_ty_1__bindgen_ty_2 +{ + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"{ fence: ")?; + CudaDisplay::write(&unsafe { self.fence }, writer)?; + writer.write_all(b" }") } } -impl FormatCudaObject for CUresourceViewFormat { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_curesourceview_format(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), - } - .ok(); +impl CudaDisplay + for cuda_types::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st__bindgen_ty_1__bindgen_ty_2 +{ + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"{ fence: ")?; + CudaDisplay::write(&unsafe { self.fence }, writer)?; + writer.write_all(b" }") } } -impl FormatCudaObject for CUaddress_mode { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cuaddress_mode(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), +impl CudaDisplay for *mut T { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + if *self == ptr::null_mut() { + writer.write_all(b"NULL") + } else { + let this: &T = unsafe { &**self }; + this.write(writer) } - .ok(); } } -impl FormatCudaObject for CUfilter_mode { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cufilter_mode(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), +impl CudaDisplay for *const T { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + if *self == ptr::null() { + writer.write_all(b"NULL") + } else { + let this: &T = unsafe { &**self }; + this.write(writer) } - .ok(); } } -impl FormatCudaObject for CUgraphExecUpdateResult { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cugraph_exec_updateresult(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), +impl CudaDisplay for [T; N] { + fn write(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> { + writer.write_all(b"[")?; + for i in 0..N { + CudaDisplay::write(self, writer)?; + if i != N - 1 { + writer.write_all(b", ")?; + } } - .ok(); - } -} - -impl FormatCudaObject for CUmemorytype { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cumemorytype(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), + writer.write_all(b"]") + } +} + +#[allow(non_snake_case)] +pub fn write_cuStreamBatchMemOp( + writer: &mut (impl std::io::Write + ?Sized), + stream: cuda_types::CUstream, + count: ::std::os::raw::c_uint, + paramArray: *mut cuda_types::CUstreamBatchMemOpParams, + flags: ::std::os::raw::c_uint, +) -> std::io::Result<()> { + writer.write_all(b"(stream: ")?; + CudaDisplay::write(&stream, writer)?; + writer.write_all(b", ")?; + writer.write_all(b"count: ")?; + CudaDisplay::write(&count, writer)?; + writer.write_all(b", paramArray: [")?; + for i in 0..count { + if i != 0 { + writer.write_all(b", ")?; } - .ok(); - } -} - -impl FormatCudaObject for CUmemLocationType { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match stringify_cumemorytype(self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), + CudaDisplay::write(&unsafe { paramArray.add(i as usize) }, writer)?; + } + writer.write_all(b"], flags: ")?; + CudaDisplay::write(&flags, writer)?; + writer.write_all(b") ") +} + +#[allow(non_snake_case)] +pub fn write_cuGraphKernelNodeGetAttribute( + writer: &mut (impl std::io::Write + ?Sized), + hNode: cuda_types::CUgraphNode, + attr: cuda_types::CUkernelNodeAttrID, + value_out: *mut cuda_types::CUkernelNodeAttrValue, +) -> std::io::Result<()> { + writer.write_all(b"(hNode: ")?; + CudaDisplay::write(&hNode, writer)?; + writer.write_all(b", attr: ")?; + CudaDisplay::write(&attr, writer)?; + match attr { + cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW => { + writer.write_all(b", value_out: ")?; + CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?; } - .ok(); - } -} -*/ - -macro_rules! stringify_enum { - ($type_:ident, [ $($variant:ident),+ ]) => { - paste! { - pub(crate) fn [](x: $type_) -> Option<&'static str> { - match x { - $( - $type_::$variant => Some(stringify!($variant)), - )+ - _ => None - } - } - - impl FormatCudaObject for $type_ { - fn write_post_execution(self, result: CUresult, f: &mut impl Write) { - match [](self) { - Some(text) => write!(f, "{}", text), - None => write!(f, "{}", self.0), - } - .ok(); - } - } + cuda_types::CUkernelNodeAttrID::CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE => { + writer.write_all(b", value_out: ")?; + CudaDisplay::write(unsafe { &(*value_out).cooperative }, writer)?; } - } -} - -stringify_enum! { - CUdevice_attribute_enum, - [ - CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, - CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, - CU_DEVICE_ATTRIBUTE_WARP_SIZE, - CU_DEVICE_ATTRIBUTE_MAX_PITCH, - CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_CLOCK_RATE, - CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, - CU_DEVICE_ATTRIBUTE_GPU_OVERLAP, - CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, - CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, - CU_DEVICE_ATTRIBUTE_INTEGRATED, - CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY, - CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES, - CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT, - CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS, - CU_DEVICE_ATTRIBUTE_ECC_ENABLED, - CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, - CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, - CU_DEVICE_ATTRIBUTE_TCC_DRIVER, - CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, - CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, - CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, - CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, - CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT, - CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE, - CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, - CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT, - CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, - CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH, - CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED, - CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED, - CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED, - CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, - CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, - CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY, - CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD, - CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID, - CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED, - CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO, - CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS, - CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, - CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED, - CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, - CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS, - CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS, - CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR, - CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH, - CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH, - CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, - CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES, - CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED, - CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, - CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST, - CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED, - CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED, - CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED, - CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED, - CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, - CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED, - CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE, - CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE, - CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED, - CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, - CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED, - CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED - ] -} - -stringify_enum! { - CUjit_option, - [ - CU_JIT_MAX_REGISTERS, - CU_JIT_THREADS_PER_BLOCK, - CU_JIT_WALL_TIME, - CU_JIT_INFO_LOG_BUFFER, - CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, - CU_JIT_ERROR_LOG_BUFFER, - CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES, - CU_JIT_OPTIMIZATION_LEVEL, - CU_JIT_TARGET_FROM_CUCONTEXT, - CU_JIT_TARGET, - CU_JIT_FALLBACK_STRATEGY, - CU_JIT_GENERATE_DEBUG_INFO, - CU_JIT_LOG_VERBOSE, - CU_JIT_GENERATE_LINE_INFO, - CU_JIT_CACHE_MODE, - CU_JIT_NEW_SM3X_OPT, - CU_JIT_FAST_COMPILE, - CU_JIT_GLOBAL_SYMBOL_NAMES, - CU_JIT_GLOBAL_SYMBOL_ADDRESSES, - CU_JIT_GLOBAL_SYMBOL_COUNT, - CU_JIT_NUM_OPTIONS - ] -} - -stringify_enum! { - CUresult, - [ - CUDA_SUCCESS, - CUDA_ERROR_INVALID_VALUE, - CUDA_ERROR_OUT_OF_MEMORY, - CUDA_ERROR_NOT_INITIALIZED, - CUDA_ERROR_DEINITIALIZED, - CUDA_ERROR_PROFILER_DISABLED, - CUDA_ERROR_PROFILER_NOT_INITIALIZED, - CUDA_ERROR_PROFILER_ALREADY_STARTED, - CUDA_ERROR_PROFILER_ALREADY_STOPPED, - CUDA_ERROR_NO_DEVICE, - CUDA_ERROR_INVALID_DEVICE, - CUDA_ERROR_INVALID_IMAGE, - CUDA_ERROR_INVALID_CONTEXT, - CUDA_ERROR_CONTEXT_ALREADY_CURRENT, - CUDA_ERROR_MAP_FAILED, - CUDA_ERROR_UNMAP_FAILED, - CUDA_ERROR_ARRAY_IS_MAPPED, - CUDA_ERROR_ALREADY_MAPPED, - CUDA_ERROR_NO_BINARY_FOR_GPU, - CUDA_ERROR_ALREADY_ACQUIRED, - CUDA_ERROR_NOT_MAPPED, - CUDA_ERROR_NOT_MAPPED_AS_ARRAY, - CUDA_ERROR_NOT_MAPPED_AS_POINTER, - CUDA_ERROR_ECC_UNCORRECTABLE, - CUDA_ERROR_UNSUPPORTED_LIMIT, - CUDA_ERROR_CONTEXT_ALREADY_IN_USE, - CUDA_ERROR_PEER_ACCESS_UNSUPPORTED, - CUDA_ERROR_INVALID_PTX, - CUDA_ERROR_INVALID_GRAPHICS_CONTEXT, - CUDA_ERROR_NVLINK_UNCORRECTABLE, - CUDA_ERROR_JIT_COMPILER_NOT_FOUND, - CUDA_ERROR_INVALID_SOURCE, - CUDA_ERROR_FILE_NOT_FOUND, - CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, - CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, - CUDA_ERROR_OPERATING_SYSTEM, - CUDA_ERROR_INVALID_HANDLE, - CUDA_ERROR_ILLEGAL_STATE, - CUDA_ERROR_NOT_FOUND, - CUDA_ERROR_NOT_READY, - CUDA_ERROR_ILLEGAL_ADDRESS, - CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, - CUDA_ERROR_LAUNCH_TIMEOUT, - CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, - CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED, - CUDA_ERROR_PEER_ACCESS_NOT_ENABLED, - CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE, - CUDA_ERROR_CONTEXT_IS_DESTROYED, - CUDA_ERROR_ASSERT, - CUDA_ERROR_TOO_MANY_PEERS, - CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED, - CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED, - CUDA_ERROR_HARDWARE_STACK_ERROR, - CUDA_ERROR_ILLEGAL_INSTRUCTION, - CUDA_ERROR_MISALIGNED_ADDRESS, - CUDA_ERROR_INVALID_ADDRESS_SPACE, - CUDA_ERROR_INVALID_PC, - CUDA_ERROR_LAUNCH_FAILED, - CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE, - CUDA_ERROR_NOT_PERMITTED, - CUDA_ERROR_NOT_SUPPORTED, - CUDA_ERROR_SYSTEM_NOT_READY, - CUDA_ERROR_SYSTEM_DRIVER_MISMATCH, - CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE, - CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED, - CUDA_ERROR_STREAM_CAPTURE_INVALIDATED, - CUDA_ERROR_STREAM_CAPTURE_MERGE, - CUDA_ERROR_STREAM_CAPTURE_UNMATCHED, - CUDA_ERROR_STREAM_CAPTURE_UNJOINED, - CUDA_ERROR_STREAM_CAPTURE_ISOLATION, - CUDA_ERROR_STREAM_CAPTURE_IMPLICIT, - CUDA_ERROR_CAPTURED_EVENT, - CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD, - CUDA_ERROR_TIMEOUT, - CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE, - CUDA_ERROR_UNKNOWN - ] -} - -stringify_enum! { - CUdevice_P2PAttribute, - [ - CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK, - CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED, - CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED, - CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED, - CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED - ] -} - -stringify_enum! { - CUarray_format, - [ - CU_AD_FORMAT_UNSIGNED_INT8, - CU_AD_FORMAT_UNSIGNED_INT16, - CU_AD_FORMAT_UNSIGNED_INT32, - CU_AD_FORMAT_SIGNED_INT8, - CU_AD_FORMAT_SIGNED_INT16, - CU_AD_FORMAT_SIGNED_INT32, - CU_AD_FORMAT_HALF, - CU_AD_FORMAT_FLOAT - ] -} - -stringify_enum! { - CUresourceViewFormat, - [ - CU_RES_VIEW_FORMAT_NONE, - CU_RES_VIEW_FORMAT_UINT_1X8, - CU_RES_VIEW_FORMAT_UINT_2X8, - CU_RES_VIEW_FORMAT_UINT_4X8, - CU_RES_VIEW_FORMAT_SINT_1X8, - CU_RES_VIEW_FORMAT_SINT_2X8, - CU_RES_VIEW_FORMAT_SINT_4X8, - CU_RES_VIEW_FORMAT_UINT_1X16, - CU_RES_VIEW_FORMAT_UINT_2X16, - CU_RES_VIEW_FORMAT_UINT_4X16, - CU_RES_VIEW_FORMAT_SINT_1X16, - CU_RES_VIEW_FORMAT_SINT_2X16, - CU_RES_VIEW_FORMAT_SINT_4X16, - CU_RES_VIEW_FORMAT_UINT_1X32, - CU_RES_VIEW_FORMAT_UINT_2X32, - CU_RES_VIEW_FORMAT_UINT_4X32, - CU_RES_VIEW_FORMAT_SINT_1X32, - CU_RES_VIEW_FORMAT_SINT_2X32, - CU_RES_VIEW_FORMAT_SINT_4X32, - CU_RES_VIEW_FORMAT_FLOAT_1X16, - CU_RES_VIEW_FORMAT_FLOAT_2X16, - CU_RES_VIEW_FORMAT_FLOAT_4X16, - CU_RES_VIEW_FORMAT_FLOAT_1X32, - CU_RES_VIEW_FORMAT_FLOAT_2X32, - CU_RES_VIEW_FORMAT_FLOAT_4X32, - CU_RES_VIEW_FORMAT_UNSIGNED_BC1, - CU_RES_VIEW_FORMAT_UNSIGNED_BC2, - CU_RES_VIEW_FORMAT_UNSIGNED_BC3, - CU_RES_VIEW_FORMAT_UNSIGNED_BC4, - CU_RES_VIEW_FORMAT_SIGNED_BC4, - CU_RES_VIEW_FORMAT_UNSIGNED_BC5, - CU_RES_VIEW_FORMAT_SIGNED_BC5, - CU_RES_VIEW_FORMAT_UNSIGNED_BC6H, - CU_RES_VIEW_FORMAT_SIGNED_BC6H, - CU_RES_VIEW_FORMAT_UNSIGNED_BC7 - ] -} - -stringify_enum! { - CUaddress_mode, - [ - CU_TR_ADDRESS_MODE_WRAP, - CU_TR_ADDRESS_MODE_CLAMP, - CU_TR_ADDRESS_MODE_MIRROR, - CU_TR_ADDRESS_MODE_BORDER - ] -} - -stringify_enum! { - CUfilter_mode, - [ - CU_TR_FILTER_MODE_POINT, - CU_TR_FILTER_MODE_LINEAR - ] -} - -stringify_enum! { - CUgraphExecUpdateResult, - [ - CU_GRAPH_EXEC_UPDATE_SUCCESS, - CU_GRAPH_EXEC_UPDATE_ERROR, - CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED, - CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED, - CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED, - CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED, - CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED - ] -} - -stringify_enum! { - CUmemorytype, - [ - CU_MEMORYTYPE_HOST, - CU_MEMORYTYPE_DEVICE, - CU_MEMORYTYPE_ARRAY, - CU_MEMORYTYPE_UNIFIED - ] -} - -stringify_enum! { - CUmemLocationType, - [ - CU_MEM_LOCATION_TYPE_INVALID, - CU_MEM_LOCATION_TYPE_DEVICE - ] -} - -stringify_enum! { - CUlimit, - [ - CU_LIMIT_STACK_SIZE, - CU_LIMIT_PRINTF_FIFO_SIZE, - CU_LIMIT_MALLOC_HEAP_SIZE, - CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH, - CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT, - CU_LIMIT_MAX_L2_FETCH_GRANULARITY, - CU_LIMIT_PERSISTING_L2_CACHE_SIZE - ] -} - -stringify_enum! { - CUpointer_attribute, - [ - CU_POINTER_ATTRIBUTE_CONTEXT, - CU_POINTER_ATTRIBUTE_MEMORY_TYPE, - CU_POINTER_ATTRIBUTE_DEVICE_POINTER, - CU_POINTER_ATTRIBUTE_HOST_POINTER, - CU_POINTER_ATTRIBUTE_P2P_TOKENS, - CU_POINTER_ATTRIBUTE_SYNC_MEMOPS, - CU_POINTER_ATTRIBUTE_BUFFER_ID, - CU_POINTER_ATTRIBUTE_IS_MANAGED, - CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL, - CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE, - CU_POINTER_ATTRIBUTE_RANGE_START_ADDR, - CU_POINTER_ATTRIBUTE_RANGE_SIZE, - CU_POINTER_ATTRIBUTE_MAPPED, - CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES, - CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE, - CU_POINTER_ATTRIBUTE_ACCESS_FLAGS - ] -} - -stringify_enum! { - CUfunction_attribute, - [ - CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, - CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, - CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES, - CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, - CU_FUNC_ATTRIBUTE_NUM_REGS, - CU_FUNC_ATTRIBUTE_PTX_VERSION, - CU_FUNC_ATTRIBUTE_BINARY_VERSION, - CU_FUNC_ATTRIBUTE_CACHE_MODE_CA, - CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, - CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT - ] -} - -stringify_enum! { - CUmem_range_attribute, - [ - CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, - CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION, - CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY, - CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION - ] -} - -stringify_enum! { - CUfunc_cache, - [ - CU_FUNC_CACHE_PREFER_NONE, - CU_FUNC_CACHE_PREFER_SHARED, - CU_FUNC_CACHE_PREFER_L1, - CU_FUNC_CACHE_PREFER_EQUAL - ] -} - -stringify_enum! { - CUstreamCaptureMode, + _ => return writer.write_all(b", ...) "), + } + writer.write_all(b") ") +} + +#[allow(non_snake_case)] +pub fn write_cuGraphKernelNodeSetAttribute( + writer: &mut (impl std::io::Write + ?Sized), + hNode: cuda_types::CUgraphNode, + attr: cuda_types::CUkernelNodeAttrID, + value_out: *const cuda_types::CUkernelNodeAttrValue, +) -> std::io::Result<()> { + write_cuGraphKernelNodeGetAttribute(writer, hNode, attr, value_out as *mut _) +} + +#[allow(non_snake_case)] +pub fn write_cuStreamGetAttribute( + writer: &mut (impl std::io::Write + ?Sized), + hStream: cuda_types::CUstream, + attr: cuda_types::CUstreamAttrID, + value_out: *mut cuda_types::CUstreamAttrValue, +) -> std::io::Result<()> { + writer.write_all(b"(hStream: ")?; + CudaDisplay::write(&hStream, writer)?; + writer.write_all(b", attr: ")?; + CudaDisplay::write(&attr, writer)?; + match attr { + cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW => { + writer.write_all(b", value_out: ")?; + CudaDisplay::write(unsafe { &(*value_out).accessPolicyWindow }, writer)?; + } + cuda_types::CUstreamAttrID::CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY => { + writer.write_all(b", value_out: ")?; + CudaDisplay::write(unsafe { &(*value_out).syncPolicy }, writer)?; + } + _ => return writer.write_all(b", ...) "), + } + writer.write_all(b") ") +} + +#[allow(non_snake_case)] +pub fn write_cuStreamGetAttribute_ptsz( + writer: &mut (impl std::io::Write + ?Sized), + hStream: cuda_types::CUstream, + attr: cuda_types::CUstreamAttrID, + value_out: *mut cuda_types::CUstreamAttrValue, +) -> std::io::Result<()> { + write_cuStreamGetAttribute(writer, hStream, attr, value_out) +} + +#[allow(non_snake_case)] +pub fn write_cuStreamSetAttribute( + writer: &mut (impl std::io::Write + ?Sized), + hStream: cuda_types::CUstream, + attr: cuda_types::CUstreamAttrID, + value_out: *const cuda_types::CUstreamAttrValue, +) -> std::io::Result<()> { + write_cuStreamGetAttribute(writer, hStream, attr, value_out as *mut _) +} + +#[allow(non_snake_case)] +pub fn write_cuStreamSetAttribute_ptsz( + writer: &mut (impl std::io::Write + ?Sized), + hStream: cuda_types::CUstream, + attr: cuda_types::CUstreamAttrID, + value_out: *const cuda_types::CUstreamAttrValue, +) -> std::io::Result<()> { + write_cuStreamSetAttribute(writer, hStream, attr, value_out) +} + +#[allow(non_snake_case)] +pub fn write_cuCtxCreate_v3( + _writer: &mut (impl std::io::Write + ?Sized), + _pctx: *mut cuda_types::CUcontext, + _paramsArray: *mut cuda_types::CUexecAffinityParam, + _numParams: ::std::os::raw::c_int, + _flags: ::std::os::raw::c_uint, + _dev: cuda_types::CUdevice, +) -> std::io::Result<()> { + todo!() +} + +#[allow(non_snake_case)] +pub fn write_cuCtxGetExecAffinity( + _writer: &mut (impl std::io::Write + ?Sized), + _pExecAffinity: *mut cuda_types::CUexecAffinityParam, + _type_: cuda_types::CUexecAffinityType, +) -> std::io::Result<()> { + todo!() +} + +#[allow(non_snake_case)] +pub fn write_cuMemMapArrayAsync( + _writer: &mut (impl std::io::Write + ?Sized), + _mapInfoList: *mut cuda_types::CUarrayMapInfo, + _count: ::std::os::raw::c_uint, + _hStream: cuda_types::CUstream, +) -> std::io::Result<()> { + todo!() +} + +#[allow(non_snake_case)] +pub fn write_cuMemMapArrayAsync_ptsz( + writer: &mut (impl std::io::Write + ?Sized), + mapInfoList: *mut cuda_types::CUarrayMapInfo, + count: ::std::os::raw::c_uint, + hStream: cuda_types::CUstream, +) -> std::io::Result<()> { + write_cuMemMapArrayAsync(writer, mapInfoList, count, hStream) +} + +cuda_derive_display_trait!( + cuda_types, + CudaDisplay, [ - CU_STREAM_CAPTURE_MODE_GLOBAL, - CU_STREAM_CAPTURE_MODE_THREAD_LOCAL, - CU_STREAM_CAPTURE_MODE_RELAXED - ] -} - -stringify_enum! { - CUmem_advise, + CUarrayMapInfo_st, + CUDA_RESOURCE_DESC_st, + CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st, + CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st, + CUexecAffinityParam_st, + CUstreamBatchMemOpParams_union_CUstreamMemOpWaitValueParams_st, + CUstreamBatchMemOpParams_union_CUstreamMemOpWriteValueParams_st, + CUuuid_st + ], [ - CU_MEM_ADVISE_SET_READ_MOSTLY, - CU_MEM_ADVISE_UNSET_READ_MOSTLY, - CU_MEM_ADVISE_SET_PREFERRED_LOCATION, - CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION, - CU_MEM_ADVISE_SET_ACCESSED_BY, - CU_MEM_ADVISE_UNSET_ACCESSED_BY + cuCtxCreate_v3, + cuCtxGetExecAffinity, + cuGraphKernelNodeGetAttribute, + cuGraphKernelNodeSetAttribute, + cuMemMapArrayAsync, + cuMemMapArrayAsync_ptsz, + cuStreamBatchMemOp, + cuStreamGetAttribute, + cuStreamGetAttribute_ptsz, + cuStreamSetAttribute, + cuStreamSetAttribute_ptsz ] -} +); diff --git a/zluda_dump/src/lib.rs b/zluda_dump/src/lib.rs index ecfd1ac..d79c391 100644 --- a/zluda_dump/src/lib.rs +++ b/zluda_dump/src/lib.rs @@ -1,107 +1,76 @@ +use cuda_types::{ + CUdevice, CUdevice_attribute, CUfunction, CUjit_option, CUmodule, CUresult, CUuuid, +}; +use paste::paste; +use std::io; use std::{ - collections::{hash_map, BTreeMap, HashMap}, - env, - error::Error, - ffi::{c_void, CStr}, - fs, - io::{self, prelude::*}, - mem, - os::raw::{c_int, c_uint, c_ulong, c_ushort}, - path::PathBuf, - ptr::NonNull, - rc::Rc, - slice, + collections::HashMap, env, error::Error, ffi::c_void, fs, path::PathBuf, ptr::NonNull, rc::Rc, sync::Mutex, }; -use std::{fs::File, ptr}; - -use cuda::{ - CUdevice, CUdevice_attribute, CUdeviceptr, CUfunction, CUjitInputType, CUjit_option, - CUlinkState, CUmodule, CUresult, CUstream, CUuuid, -}; -use ptx::ast; -use regex::Regex; #[macro_use] extern crate lazy_static; -const CU_LAUNCH_PARAM_END: *mut c_void = 0 as *mut _; -const CU_LAUNCH_PARAM_BUFFER_POINTER: *mut c_void = 1 as *mut _; -const CU_LAUNCH_PARAM_BUFFER_SIZE: *mut c_void = 2 as *mut _; - macro_rules! extern_redirect { - (pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ;) => { + ($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:path) => { #[no_mangle] - pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { + pub extern $abi fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { let original_fn = |fn_ptr| { let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) }; typed_fn($( $arg_id ),*) }; - let get_formatted_args = |fn_logger: &mut crate::log::FunctionLogger, result: CUresult| { - let arg_count = (count_tts!($($arg_id),*) + 1) / 2; - fn_logger.begin_writing_arguments(arg_count); - $( - fn_logger.write_single_argument(result, $arg_id); - )* - fn_logger.end_writing_arguments(); - }; + let get_formatted_args = Box::new(move |writer: &mut dyn std::io::Write| { + (paste! { format :: [] }) ( + writer + $(,$arg_id)* + ) + }); crate::handle_cuda_function_call(stringify!($fn_name), original_fn, get_formatted_args) } }; } -macro_rules! count_tts { - () => {0usize}; - ($_head:tt $($tail:tt)*) => {1usize + count_tts!($($tail)*)}; -} - macro_rules! extern_redirect_with_post { - ( - pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ; - $post_fn:path ; - ) => { + ($abi:literal fn $fn_name:ident( $($arg_id:ident : $arg_type:ty),* ) -> $ret_type:path) => { #[no_mangle] pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { let original_fn = |fn_ptr| { let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) }; typed_fn($( $arg_id ),*) }; - let get_formatted_args = |fn_logger: &mut crate::log::FunctionLogger, result: CUresult| { - let arg_count = (count_tts!($($arg_id),*) + 1) / 2; - fn_logger.begin_writing_arguments(arg_count); - $( - fn_logger.write_single_argument(result, $arg_id); - )* - fn_logger.end_writing_arguments(); - }; + let get_formatted_args = Box::new(move |writer: &mut dyn std::io::Write| { + (paste! { format :: [] }) ( + writer + $(,$arg_id)* + ) + }); crate::handle_cuda_function_call_with_probes( stringify!($fn_name), || (), original_fn, get_formatted_args, - move |logger, state, _, cuda_result| $post_fn ( $( $arg_id ),* , logger, state, cuda_result ) + move |logger, state, _, cuda_result| paste! { [<$fn_name _Post>] } ( $( $arg_id ),* , logger, state, cuda_result ) ) } }; } -macro_rules! extern_redirect_with { - ( - pub fn $fn_name:ident ( $($arg_id:ident: $arg_type:ty),* $(,)? ) -> $ret_type:ty ; - $receiver:path ; - ) => { - #[no_mangle] - pub extern "system" fn $fn_name ( $( $arg_id : $arg_type),* ) -> $ret_type { - let original_fn = |fn_ptr| { - let typed_fn = unsafe { std::mem::transmute::<_, extern "system" fn( $( $arg_id : $arg_type),* ) -> $ret_type>(fn_ptr) }; - typed_fn($( $arg_id ),*) - }; - crate::handle_cuda_function_call(stringify!($fn_name), original_fn) - } - }; -} +use cuda_base::cuda_function_declarations; +cuda_function_declarations!( + cuda_types, + extern_redirect, + extern_redirect_with_post, + [ + cuModuleLoad, + cuModuleLoadData, + cuModuleLoadDataEx, + cuGetExportTable, + cuModuleGetFunction, + cuDeviceGetAttribute, + cuDeviceComputeCapability, + cuModuleLoadFatBinary + ] +); -#[allow(warnings)] -mod cuda; mod dark_api; mod format; mod log; @@ -110,20 +79,6 @@ mod log; mod os; mod trace; -pub static mut LIBCUDA_HANDLE: *mut c_void = ptr::null_mut(); -pub static mut PENDING_LINKING: Option>> = None; -pub static mut LINKED_CUBINS: Option> = None; -pub static mut MODULES: Option> = None; -pub static mut MODULE_DUMP_COUNTER: usize = 0; -pub static mut KERNELS: Option> = None; -static mut BUFFERS: Option> = None; -pub static mut LAUNCH_COUNTER: usize = 0; -pub static mut KERNEL_PATTERN: Option = None; -pub static mut OVERRIDE_COMPUTE_CAPABILITY_MAJOR: Option = None; -pub static mut KERNEL_INDEX_MINIMUM: usize = 0; -pub static mut KERNEL_INDEX_MAXIMUM: usize = usize::MAX; -static mut LOG_FACTORY: Option = None; - lazy_static! { static ref GLOBAL_STATE: Mutex = Mutex::new(GlobalState::new()); } @@ -179,9 +134,11 @@ struct GlobalDelayedState { impl GlobalDelayedState { fn new<'a>( func: &'static str, + arguments_writer: Box std::io::Result<()>>, factory: &'a mut log::Factory, ) -> (LateInit, log::FunctionLogger<'a>) { - let (mut fn_logger, settings) = factory.get_first_logger_and_init_settings(func); + let (mut fn_logger, settings) = + factory.get_first_logger_and_init_settings(func, arguments_writer); let maybe_libcuda_handle = unsafe { os::load_cuda_library(&settings.libcuda_path) }; let libcuda_handle = match NonNull::new(maybe_libcuda_handle) { Some(h) => h, @@ -285,16 +242,22 @@ pub struct ModuleDump { fn handle_cuda_function_call( func: &'static str, original_cuda_fn: impl FnOnce(NonNull) -> CUresult, - print_arguments_fn: impl FnOnce(&mut crate::log::FunctionLogger, CUresult), + arguments_writer: Box std::io::Result<()>>, ) -> CUresult { - handle_cuda_function_call_with_probes(func, || (), original_cuda_fn, print_arguments_fn, |_| ()) + handle_cuda_function_call_with_probes( + func, + || (), + original_cuda_fn, + arguments_writer, + |_, _, _, _| (), + ) } fn handle_cuda_function_call_with_probes( func: &'static str, pre_probe: impl FnOnce() -> T, original_cuda_fn: impl FnOnce(NonNull) -> CUresult, - print_arguments_fn: impl FnOnce(&mut crate::log::FunctionLogger, CUresult), + arguments_writer: Box std::io::Result<()>>, post_probe: PostFn, ) -> CUresult where @@ -307,14 +270,15 @@ where // extract any useful trace or logging anyway let mut global_state = &mut *global_state_mutex.lock().unwrap(); let (mut logger, delayed_state) = match global_state.delayed_state { - LateInit::Success(ref mut delayed_state) => { - (global_state.log_factory.get_logger(func), delayed_state) - } + LateInit::Success(ref mut delayed_state) => ( + global_state.log_factory.get_logger(func, arguments_writer), + delayed_state, + ), // There's no libcuda to load, so we might as well panic LateInit::Error => panic!(), LateInit::Unitialized => { let (new_delayed_state, logger) = - GlobalDelayedState::new(func, &mut global_state.log_factory); + GlobalDelayedState::new(func, arguments_writer, &mut global_state.log_factory); global_state.delayed_state = new_delayed_state; (logger, global_state.delayed_state.as_mut().unwrap()) } @@ -326,7 +290,6 @@ where let pre_result = pre_probe(); let cu_result = original_cuda_fn(fn_ptr); logger.result = Some(cu_result); - print_arguments_fn(&mut logger, cu_result); post_probe( &mut logger, &mut delayed_state.cuda_state, @@ -349,72 +312,6 @@ pub struct KernelDump { arguments: Option>, } -// We are doing dlopen here instead of just using LD_PRELOAD, -// it's because CUDA Runtime API does dlopen to open libcuda.so, which ignores LD_PRELOAD -pub unsafe fn init_libcuda_handle(func: &'static str) { - if LIBCUDA_HANDLE == ptr::null_mut() { - let mut log_factory = log::Factory::new(); - let (logger, settings) = log_factory.get_first_logger_and_init_settings(func); - MODULES = Some(HashMap::new()); - KERNELS = Some(HashMap::new()); - BUFFERS = Some(BTreeMap::new()); - let libcuda_handle = ptr::null_mut(); - assert_ne!(libcuda_handle, ptr::null_mut()); - LIBCUDA_HANDLE = libcuda_handle; - match env::var("ZLUDA_DUMP_KERNEL") { - Ok(kernel_filter) => match Regex::new(&kernel_filter) { - Ok(r) => KERNEL_PATTERN = Some(r), - Err(err) => { - os_log!("Error parsing ZLUDA_DUMP_KERNEL: {}", err); - } - }, - Err(_) => (), - } - if let Ok(kernel_min_str) = env::var("ZLUDA_DUMP_MIN_INDEX") { - match kernel_min_str.parse::() { - Ok(kernel_min_value) => KERNEL_INDEX_MINIMUM = kernel_min_value, - Err(err) => { - os_log!("Error parsing ZLUDA_DUMP_MIN_INDEX: {}", err); - } - } - } - if let Ok(kernel_max_str) = env::var("ZLUDA_DUMP_MAX_INDEX") { - match kernel_max_str.parse::() { - Ok(kernel_max_value) => KERNEL_INDEX_MAXIMUM = kernel_max_value, - Err(err) => { - os_log!("Error parsing ZLUDA_DUMP_MAX_INDEX: {}", err); - } - } - } - match env::var("ZLUDA_OVERRIDE_COMPUTE_CAPABILITY_MAJOR") { - Ok(cc_override) => match str::parse::(&cc_override) { - Ok(ver) => OVERRIDE_COMPUTE_CAPABILITY_MAJOR = Some(ver), - Err(err) => { - os_log!( - "Error parsing ZLUDA_OVERRIDE_COMPUTE_CAPABILITY_MAJOR: {}", - err - ); - } - }, - Err(_) => (), - } - drop(logger); - } -} - -#[allow(non_snake_case)] -pub unsafe fn cuModuleLoadData( - module: *mut CUmodule, - raw_image: *const ::std::os::raw::c_void, - cont: impl FnOnce(*mut CUmodule, *const c_void) -> CUresult, -) -> CUresult { - let result = cont(module, raw_image); - if result == CUresult::CUDA_SUCCESS { - record_module_image_raw(*module, raw_image); - } - result -} - #[allow(non_snake_case)] pub(crate) fn cuModuleLoad_Post( module: *mut CUmodule, @@ -457,1013 +354,6 @@ pub(crate) fn cuModuleLoadDataEx_Post( cuModuleLoadData_Post(module, raw_image, fn_logger, state, result) } -unsafe fn record_module_image_raw(module: CUmodule, raw_image: *const ::std::os::raw::c_void) { - if *(raw_image as *const u32) == 0x464c457f { - os_log!("Unsupported ELF module image: {:?}", raw_image); - return; - } - let image = to_str(raw_image); - match image { - None => os_log!("Malformed module image: {:?}", raw_image), - Some(image) => record_module_image_with_module(module, raw_image, image), - }; -} - -unsafe fn record_module_image_with_module( - module: CUmodule, - raw_image: *const ::std::os::raw::c_void, - image: &str, -) { - match record_module_image_impl(raw_image, image) { - Ok(dump) => { - MODULES - .get_or_insert_with(|| HashMap::new()) - .insert(module, dump); - } - Err(e) => { - os_log!("{}", e); - } - } -} - -unsafe fn record_module_image_with_linker( - link_obj: CUlinkState, - raw_image: *const ::std::os::raw::c_void, - image: &str, -) { - match record_module_image_impl(raw_image, image) { - Ok(dump) => { - match PENDING_LINKING - .get_or_insert_with(|| HashMap::new()) - .entry(link_obj) - { - hash_map::Entry::Occupied(mut vec) => { - vec.get_mut().push(dump); - } - hash_map::Entry::Vacant(e) => { - e.insert(vec![dump]); - } - }; - } - Err(e) => { - os_log!("{}", e); - } - } -} - -unsafe fn record_module_image_impl( - raw_image: *const ::std::os::raw::c_void, - image: &str, -) -> Result> { - if !image.contains(&".version") { - return Err(format!( - "Malformed module image (no `.version`): {:?}", - raw_image - ))?; - } - let mut errors = Vec::new(); - let ast = ptx::ModuleParser::new().parse(&mut errors, image); - let kernels_args = match (&*errors, ast) { - (&[], Ok(ast)) => { - let kernels_args = ast - .directives - .iter() - .filter_map(directive_to_kernel) - .collect::>(); - Some(kernels_args) - } - (err_vec, res) => { - // Don't print errors - it's usually too verbose to be useful - os_log!( - "{} errors when parsing module image: {:?}", - err_vec.len() + res.iter().len(), - raw_image - ); - None - } - }; - let dump = ModuleDump { - content: Rc::new(image.to_string()), - kernels_args, - }; - if let Err(e) = try_dump_module_image(image) { - return Err(format!( - "Errors when saving module image: {:?}, {}", - raw_image, e - ))?; - } - Ok(dump) -} - -unsafe fn try_dump_module_image(image: &str) -> Result<(), Box> { - let mut dump_path = get_dump_dir()?; - dump_path.push(format!("module_{:04}.ptx", MODULE_DUMP_COUNTER)); - MODULE_DUMP_COUNTER += 1; - let mut file = File::create(dump_path)?; - file.write_all(image.as_bytes())?; - Ok(()) -} - -unsafe fn to_str(image: *const T) -> Option<&'static str> { - let ptr = image as *const u8; - let mut offset = 0; - loop { - let c = *ptr.add(offset); - if !c.is_ascii() { - return None; - } - if c == 0 { - return Some(std::str::from_utf8_unchecked(slice::from_raw_parts( - ptr, offset, - ))); - } - offset += 1; - } -} - -fn directive_to_kernel(dir: &ast::Directive) -> Option<(String, Vec)> { - match dir { - ast::Directive::Method( - _, - ast::Function { - func_directive: - ast::MethodDeclaration { - name: ast::MethodName::Kernel(name), - input_arguments, - .. - }, - .. - }, - ) => { - let arg_sizes = input_arguments - .iter() - .map(|arg| ast::Type::from(arg.v_type.clone()).size_of()) - .collect(); - Some((name.to_string(), arg_sizes)) - } - _ => None, - } -} - -#[allow(non_snake_case)] -pub unsafe fn cuModuleLoadDataEx( - module: *mut CUmodule, - image: *const c_void, - numOptions: c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut c_void, - cont: impl FnOnce( - *mut CUmodule, - *const c_void, - c_uint, - *mut CUjit_option, - *mut *mut c_void, - ) -> CUresult, -) -> CUresult { - let result = cont(module, image, numOptions, options, optionValues); - if result == CUresult::CUDA_SUCCESS { - record_module_image_raw(*module, image); - } - result -} - -#[allow(non_snake_case)] -unsafe fn cuModuleGetFunction( - hfunc: *mut CUfunction, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - cont: impl FnOnce(*mut CUfunction, CUmodule, *const ::std::os::raw::c_char) -> CUresult, -) -> CUresult { - let result = cont(hfunc, hmod, name); - if result != CUresult::CUDA_SUCCESS { - return result; - } - if let Some(modules) = &MODULES { - if let Some(module_dump) = modules.get(&hmod) { - if let Some(kernel) = to_str(name) { - let kernel_args = if let Some(kernels) = &module_dump.kernels_args { - if let Some(args) = kernels.get(kernel) { - Some(args.clone()) - } else { - None - } - } else { - None - }; - KERNELS.as_mut().unwrap().insert( - *hfunc, - KernelDump { - module_content: module_dump.content.clone(), - name: kernel.to_string(), - arguments: kernel_args, - }, - ); - } else { - os_log!("Malformed name at: {:?}", hfunc); - } - } else { - os_log!("Unknown module: {:?}", hmod); - } - } else { - os_log!("Unknown module: {:?}", hmod); - } - CUresult::CUDA_SUCCESS -} - -#[allow(non_snake_case)] -pub unsafe fn cuMemAlloc( - dptr: *mut CUdeviceptr, - bytesize: usize, - cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult, -) -> CUresult { - cuMemAlloc_impl(false, dptr, bytesize, cont) -} - -#[allow(non_snake_case)] -pub unsafe fn cuMemAlloc_v2( - dptr: *mut CUdeviceptr, - bytesize: usize, - cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult, -) -> CUresult { - cuMemAlloc_impl(true, dptr, bytesize, cont) -} - -#[allow(non_snake_case)] -pub unsafe fn cuMemAlloc_impl( - is_v2: bool, - dptr: *mut CUdeviceptr, - bytesize: usize, - cont: impl FnOnce(*mut CUdeviceptr, usize) -> CUresult, -) -> CUresult { - let result = cont(dptr, bytesize); - assert_eq!(result, CUresult::CUDA_SUCCESS); - let start = (*dptr).0 as usize; - let location = if is_v2 { - AllocLocation::DeviceV2 - } else { - AllocLocation::Device - }; - BUFFERS - .as_mut() - .unwrap() - .insert(start, (bytesize, location)); - CUresult::CUDA_SUCCESS -} - -#[allow(non_snake_case)] -pub unsafe fn cuMemHostAlloc( - pp: *mut *mut c_void, - bytesize: usize, - flags: c_uint, - cont: impl FnOnce(*mut *mut c_void, usize, c_uint) -> CUresult, -) -> CUresult { - let result = cont(pp, bytesize, flags); - assert_eq!(result, CUresult::CUDA_SUCCESS); - let start = (*pp) as usize; - BUFFERS - .as_mut() - .unwrap() - .insert(start, (bytesize, AllocLocation::Host)); - CUresult::CUDA_SUCCESS -} - -#[allow(non_snake_case)] -pub unsafe fn cuLaunchKernel( - f: CUfunction, - gridDimX: ::std::os::raw::c_uint, - gridDimY: ::std::os::raw::c_uint, - gridDimZ: ::std::os::raw::c_uint, - blockDimX: ::std::os::raw::c_uint, - blockDimY: ::std::os::raw::c_uint, - blockDimZ: ::std::os::raw::c_uint, - sharedMemBytes: ::std::os::raw::c_uint, - hStream: CUstream, - kernelParams: *mut *mut ::std::os::raw::c_void, - extra: *mut *mut ::std::os::raw::c_void, - cont: impl FnOnce( - CUfunction, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - ::std::os::raw::c_uint, - CUstream, - *mut *mut ::std::os::raw::c_void, - *mut *mut ::std::os::raw::c_void, - ) -> CUresult, -) -> CUresult { - let mut error; - let dump_env = match create_dump_dir(f, LAUNCH_COUNTER) { - Ok(dump_env) => dump_env, - Err(err) => { - os_log!("Error when creating the dump directory: {}", err); - None - } - }; - if let Some(dump_env) = &dump_env { - dump_pre_data( - gridDimX, - gridDimY, - gridDimZ, - blockDimX, - blockDimY, - blockDimZ, - sharedMemBytes, - kernelParams, - extra, - dump_env, - ) - .unwrap_or_else(|err| os_log!("{}", err)); - }; - error = cont( - f, - gridDimX, - gridDimY, - gridDimZ, - blockDimX, - blockDimY, - blockDimZ, - sharedMemBytes, - hStream, - kernelParams, - extra, - ); - assert_eq!(error, CUresult::CUDA_SUCCESS); - error = cuda::cuStreamSynchronize(hStream); - assert_eq!(error, CUresult::CUDA_SUCCESS); - if let Some((_, kernel_dump)) = &dump_env { - dump_arguments( - kernelParams, - extra, - "post", - &kernel_dump.name, - LAUNCH_COUNTER, - kernel_dump.arguments.as_ref().map(|vec| &vec[..]), - ) - .unwrap_or_else(|err| os_log!("{}", err)); - } - LAUNCH_COUNTER += 1; - CUresult::CUDA_SUCCESS -} - -#[allow(non_snake_case)] -fn dump_launch_arguments( - gridDimX: u32, - gridDimY: u32, - gridDimZ: u32, - blockDimX: u32, - blockDimY: u32, - blockDimZ: u32, - sharedMemBytes: u32, - dump_dir: &PathBuf, -) -> Result<(), Box> { - let mut module_file_path = dump_dir.clone(); - module_file_path.push("launch.txt"); - let mut module_file = File::create(module_file_path)?; - write!(&mut module_file, "{}\n", gridDimX)?; - write!(&mut module_file, "{}\n", gridDimY)?; - write!(&mut module_file, "{}\n", gridDimZ)?; - write!(&mut module_file, "{}\n", blockDimX)?; - write!(&mut module_file, "{}\n", blockDimY)?; - write!(&mut module_file, "{}\n", blockDimZ)?; - write!(&mut module_file, "{}\n", sharedMemBytes)?; - Ok(()) -} - -unsafe fn should_dump_kernel(counter: usize, name: &str) -> bool { - if counter < KERNEL_INDEX_MINIMUM { - return false; - } - if counter > KERNEL_INDEX_MAXIMUM { - return false; - } - match &KERNEL_PATTERN { - Some(pattern) => pattern.is_match(name), - None => true, - } -} - -unsafe fn create_dump_dir( - f: CUfunction, - counter: usize, -) -> Result, Box> { - match KERNELS.as_ref().and_then(|kernels| kernels.get(&f)) { - Some(kernel_dump) => { - if !should_dump_kernel(counter, &kernel_dump.name) { - return Ok(None); - } - let mut dump_dir = get_dump_dir()?; - dump_dir.push(format!("{:04}_{}", counter, kernel_dump.name)); - fs::create_dir_all(&dump_dir)?; - Ok(Some((dump_dir, kernel_dump))) - } - None => Err(format!("Unknown kernel: {:?}", f))?, - } -} - -#[allow(non_snake_case)] -unsafe fn dump_pre_data( - gridDimX: ::std::os::raw::c_uint, - gridDimY: ::std::os::raw::c_uint, - gridDimZ: ::std::os::raw::c_uint, - blockDimX: ::std::os::raw::c_uint, - blockDimY: ::std::os::raw::c_uint, - blockDimZ: ::std::os::raw::c_uint, - sharedMemBytes: ::std::os::raw::c_uint, - kernelParams: *mut *mut ::std::os::raw::c_void, - extra: *mut *mut ::std::os::raw::c_void, - (dump_dir, kernel_dump): &(PathBuf, &'static KernelDump), -) -> Result<(), Box> { - dump_launch_arguments( - gridDimX, - gridDimY, - gridDimZ, - blockDimX, - blockDimY, - blockDimZ, - sharedMemBytes, - dump_dir, - )?; - let mut module_file_path = dump_dir.clone(); - module_file_path.push("module.ptx"); - let mut module_file = File::create(module_file_path)?; - module_file.write_all(kernel_dump.module_content.as_bytes())?; - dump_arguments( - kernelParams, - extra, - "pre", - &kernel_dump.name, - LAUNCH_COUNTER, - kernel_dump.arguments.as_ref().map(|vec| &vec[..]), - )?; - Ok(()) -} - -fn dump_arguments( - kernel_params: *mut *mut ::std::os::raw::c_void, - extra: *mut *mut ::std::os::raw::c_void, - prefix: &str, - kernel_name: &str, - counter: usize, - args: Option<&[usize]>, -) -> Result<(), Box> { - let args = match args { - None => return Ok(()), - Some(a) => a, - }; - let mut dump_dir = get_dump_dir()?; - dump_dir.push(format!("{:04}_{}", counter, kernel_name)); - dump_dir.push(prefix); - if dump_dir.exists() { - fs::remove_dir_all(&dump_dir)?; - } - fs::create_dir_all(&dump_dir)?; - if kernel_params != ptr::null_mut() { - for (i, arg_len) in args.iter().enumerate() { - unsafe { dump_argument_to_file(&dump_dir, i, *arg_len, *kernel_params.add(i))? }; - } - } else { - let mut offset = 0; - let mut buffer_ptr = None; - let mut buffer_size = None; - loop { - match unsafe { *extra.add(offset) } { - CU_LAUNCH_PARAM_END => break, - CU_LAUNCH_PARAM_BUFFER_POINTER => { - buffer_ptr = Some(unsafe { *extra.add(offset + 1) as *mut u8 }); - } - CU_LAUNCH_PARAM_BUFFER_SIZE => { - buffer_size = Some(unsafe { *(*extra.add(offset + 1) as *mut usize) }); - } - _ => return Err("Malformed `extra` parameter to kernel launch")?, - } - offset += 2; - } - match (buffer_size, buffer_ptr) { - (Some(buffer_size), Some(buffer_ptr)) => { - let sum_of_kernel_argument_sizes = args.iter().fold(0, |offset, size_of_arg| { - size_of_arg + round_up_to_multiple(offset, *size_of_arg) - }); - if buffer_size < sum_of_kernel_argument_sizes { - return Err("Malformed `extra` parameter to kernel launch")?; - } - let mut offset = 0; - for (i, arg_size) in args.iter().enumerate() { - let buffer_offset = round_up_to_multiple(offset, *arg_size); - unsafe { - dump_argument_to_file( - &dump_dir, - i, - *arg_size, - buffer_ptr.add(buffer_offset) as *const _, - )? - }; - offset = buffer_offset + *arg_size; - } - } - _ => return Err("Malformed `extra` parameter to kernel launch")?, - } - } - Ok(()) -} - -fn round_up_to_multiple(x: usize, multiple: usize) -> usize { - ((x + multiple - 1) / multiple) * multiple -} - -unsafe fn dump_argument_to_file( - dump_dir: &PathBuf, - i: usize, - arg_len: usize, - ptr: *const c_void, -) -> Result<(), Box> { - // Don't check if arg_len == sizeof(void*), there are libraries - // which for some reason pass 32 pointers (4 bytes) in 8 byte arguments - match get_buffer_length(*(ptr as *mut usize)) { - Some((start, len, location)) => { - let mut output = vec![0u8; len]; - let memcpy_fn = match location { - AllocLocation::Device => |src, dst: usize, len| { - let error = cuda::cuMemcpyDtoH(dst as *mut _, CUdeviceptr(src), len); - assert_eq!(error, CUresult::CUDA_SUCCESS); - }, - AllocLocation::DeviceV2 => |src, dst: usize, len| { - let error = cuda::cuMemcpyDtoH_v2(dst as *mut _, CUdeviceptr(src), len); - assert_eq!(error, CUresult::CUDA_SUCCESS); - }, - AllocLocation::Host => |src, dst: usize, len| { - ptr::copy_nonoverlapping(src as *mut u8, dst as *mut u8, len); - }, - }; - memcpy_fn(start, output.as_mut_ptr() as usize, len); - let mut path = dump_dir.clone(); - path.push(format!("arg_{:03}.buffer", i)); - let mut file = File::create(path)?; - file.write_all(&mut output)?; - } - None => { - let mut path = dump_dir.clone(); - path.push(format!("arg_{:03}", i)); - let mut file = File::create(path)?; - file.write_all(slice::from_raw_parts(ptr as *mut u8, arg_len))?; - } - } - Ok(()) -} - -unsafe fn get_buffer_length(ptr: usize) -> Option<(usize, usize, AllocLocation)> { - BUFFERS - .as_mut() - .unwrap() - .range(..=ptr) - .next_back() - .and_then(|(start, (len, loc))| { - let end = *start + *len; - if ptr < end { - Some((ptr, end - ptr, *loc)) - } else { - None - } - }) -} - -fn get_dump_dir() -> Result> { - let dir = env::var("ZLUDA_DUMP_DIR")?; - let mut main_dir = PathBuf::from(dir); - let current_exe = env::current_exe()?; - main_dir.push(current_exe.file_name().unwrap()); - fs::create_dir_all(&main_dir)?; - Ok(main_dir) -} - -// TODO make this more common with ZLUDA implementation -const CUDART_INTERFACE_GUID: CUuuid = CUuuid { - bytes: [ - 0x6b, 0xd5, 0xfb, 0x6c, 0x5b, 0xf4, 0xe7, 0x4a, 0x89, 0x87, 0xd9, 0x39, 0x12, 0xfd, 0x9d, - 0xf9, - ], -}; - -static mut OVERRIDEN_INTERFACE_VTABLES: Option, Vec<*const c_void>>> = None; - -static mut ORIGINAL_GET_MODULE_FROM_CUBIN: Option< - unsafe extern "system" fn( - result: *mut CUmodule, - fatbinc_wrapper: *const FatbincWrapper, - ) -> CUresult, -> = None; -static mut ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1: Option< - unsafe extern "system" fn( - result: *mut CUmodule, - fatbinc_wrapper: *const FatbincWrapper, - ptr1: *mut c_void, - ptr2: *mut c_void, - _unknown: usize, - ) -> CUresult, -> = None; -static mut ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2: Option< - unsafe extern "system" fn( - fatbinc_wrapper: *const FatbinHeader, - result: *mut CUmodule, - ptr1: *mut c_void, - ptr2: *mut c_void, - _unknown: usize, - ) -> CUresult, -> = None; - -unsafe extern "system" fn report_unknown_export_table_call( - export_table: *const CUuuid, - idx: usize, -) { - let guid = (*export_table).bytes; - os_log!("Call to an unsupported export table function: {{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}::{}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15], idx); -} - -#[allow(non_snake_case)] -pub unsafe fn cuGetExportTable( - ppExportTable: *mut *const ::std::os::raw::c_void, - pExportTableId: *const CUuuid, - cont: impl FnOnce(*mut *const ::std::os::raw::c_void, *const CUuuid) -> CUresult, -) -> CUresult { - if ppExportTable == ptr::null_mut() || pExportTableId == ptr::null() { - return CUresult::CUDA_ERROR_INVALID_VALUE; - } - let guid = (*pExportTableId).bytes; - os_log!("Requested export table id: {{{:02X}{:02X}{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}", guid[0], guid[1], guid[2], guid[3], guid[4], guid[5], guid[6], guid[7], guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]); - override_export_table(ppExportTable, pExportTableId, cont) -} - -unsafe fn override_export_table( - export_table_ptr: *mut *const ::std::os::raw::c_void, - export_table_id: *const CUuuid, - cont: impl FnOnce(*mut *const ::std::os::raw::c_void, *const CUuuid) -> CUresult, -) -> CUresult { - let overrides_map = OVERRIDEN_INTERFACE_VTABLES.get_or_insert_with(|| HashMap::new()); - if let Some(override_table) = overrides_map.get(&*export_table_id) { - *export_table_ptr = override_table.as_ptr() as *const _; - return CUresult::CUDA_SUCCESS; - } - let base_result = cont(export_table_ptr, export_table_id); - if base_result != CUresult::CUDA_SUCCESS { - return base_result; - } - let export_table = (*export_table_ptr) as *mut *const c_void; - let boxed_guid = Box::new(*export_table_id); - let byte_length: usize = *(export_table as *const usize); - let mut override_table = Vec::new(); - if byte_length < 0x10000 { - override_table.push(byte_length as *const _); - let length = byte_length / mem::size_of::(); - for i in 1..length { - let current_fn = export_table.add(i); - if (*current_fn as usize) == usize::max_value() { - override_table.push(usize::max_value() as *const _); - break; - } - override_table.push(get_export_override_fn(*current_fn, &*boxed_guid, i)); - } - } else { - let mut i = 0; - loop { - let current_fn = export_table.add(i); - if (*current_fn as usize) == usize::max_value() { - override_table.push(usize::max_value() as *const _); - break; - } - override_table.push(get_export_override_fn(*current_fn, &*boxed_guid, i)); - i += 1; - } - } - *export_table_ptr = override_table.as_ptr() as *const _; - overrides_map.insert(boxed_guid, override_table); - CUresult::CUDA_SUCCESS -} - -const TOOLS_RUNTIME_CALLBACK_HOOKS_GUID: CUuuid = CUuuid { - bytes: [ - 0xa0, 0x94, 0x79, 0x8c, 0x2e, 0x74, 0x2e, 0x74, 0x93, 0xf2, 0x08, 0x00, 0x20, 0x0c, 0x0a, - 0x66, - ], -}; - -const CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID: CUuuid = CUuuid { - bytes: [ - 0xc6, 0x93, 0x33, 0x6e, 0x11, 0x21, 0xdf, 0x11, 0xa8, 0xc3, 0x68, 0xf3, 0x55, 0xd8, 0x95, - 0x93, - ], -}; - -const CTX_CREATE_BYPASS_GUID: CUuuid = CUuuid { - bytes: [ - 0x0C, 0xA5, 0x0B, 0x8C, 0x10, 0x04, 0x92, 0x9A, 0x89, 0xA7, 0xD0, 0xDF, 0x10, 0xE7, 0x72, - 0x86, - ], -}; - -const HEAP_ACCESS_GUID: CUuuid = CUuuid { - bytes: [ - 0x19, 0x5B, 0xCB, 0xF4, 0xD6, 0x7D, 0x02, 0x4A, 0xAC, 0xC5, 0x1D, 0x29, 0xCE, 0xA6, 0x31, - 0xAE, - ], -}; - -const DEVICE_EXTENDED_RT_GUID: CUuuid = CUuuid { - bytes: [ - 0xB1u8, 0x05, 0x41, 0xE1, 0xF7, 0xC7, 0xC7, 0x4A, 0x9F, 0x64, 0xF2, 0x23, 0xBE, 0x99, 0xF1, - 0xE2, - ], -}; - -unsafe fn get_export_override_fn( - original_fn: *const c_void, - guid: *const CUuuid, - idx: usize, -) -> *const c_void { - match (*guid, idx) { - (TOOLS_RUNTIME_CALLBACK_HOOKS_GUID, 2) - | (TOOLS_RUNTIME_CALLBACK_HOOKS_GUID, 6) - | (CUDART_INTERFACE_GUID, 2) - | (CUDART_INTERFACE_GUID, 7) - | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 0) - | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 1) - | (CONTEXT_LOCAL_STORAGE_INTERFACE_V0301_GUID, 2) - | (CTX_CREATE_BYPASS_GUID, 1) - | (HEAP_ACCESS_GUID, 1) - | (HEAP_ACCESS_GUID, 2) - | (DEVICE_EXTENDED_RT_GUID, 5) - | (DEVICE_EXTENDED_RT_GUID, 13) => original_fn, - (CUDART_INTERFACE_GUID, 1) => { - ORIGINAL_GET_MODULE_FROM_CUBIN = mem::transmute(original_fn); - get_module_from_cubin as *const _ - } - (CUDART_INTERFACE_GUID, 6) => { - ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1 = mem::transmute(original_fn); - get_module_from_cubin_ext1 as *const _ - } - (CUDART_INTERFACE_GUID, 8) => { - ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2 = mem::transmute(original_fn); - get_module_from_cubin_ext2 as *const _ - } - _ => os::get_thunk(original_fn, report_unknown_export_table_call, guid, idx), - } -} - -const FATBINC_MAGIC: c_uint = 0x466243B1; -const FATBINC_VERSION: c_uint = 0x1; - -#[repr(C)] -struct FatbincWrapper { - magic: c_uint, - version: c_uint, - data: *const FatbinHeader, - filename_or_fatbins: *const c_void, -} - -const FATBIN_MAGIC: c_uint = 0xBA55ED50; -const LEGACY_FATBIN_MAGIC: c_uint = 0x1EE55A01; -const FATBIN_VERSION: c_ushort = 0x01; - -#[repr(C, align(8))] -struct FatbinHeader { - magic: c_uint, - version: c_ushort, - header_size: c_ushort, - files_size: c_ulong, // excluding frame header, size of all blocks framed by this frame -} - -const FATBIN_FILE_HEADER_KIND_PTX: c_ushort = 0x01; -const FATBIN_FILE_HEADER_VERSION_CURRENT: c_ushort = 0x101; - -// assembly file header is a bit different, but we don't care -#[repr(C)] -#[derive(Debug)] -struct FatbinFileHeader { - kind: c_ushort, - version: c_ushort, - header_size: c_uint, - padded_payload_size: c_uint, - unknown0: c_uint, // check if it's written into separately - payload_size: c_uint, - unknown1: c_uint, - unknown2: c_uint, - sm_version: c_uint, - bit_width: c_uint, - unknown3: c_uint, - unknown4: c_ulong, - unknown5: c_ulong, - uncompressed_payload: c_ulong, -} - -unsafe fn get_module_from_cubin_impl( - module: *mut CUmodule, - fatbinc_wrapper: *const FatbincWrapper, - get_module_base: impl FnOnce() -> CUresult, -) -> CUresult { - if module == ptr::null_mut() - || (*fatbinc_wrapper).magic != FATBINC_MAGIC - || (*fatbinc_wrapper).version != FATBINC_VERSION - { - return CUresult::CUDA_ERROR_INVALID_VALUE; - } - get_module_from_cubin_unwrapped(module, (*fatbinc_wrapper).data, get_module_base) -} - -unsafe fn get_module_from_cubin_unwrapped( - module: *mut CUmodule, - fatbin_header: *const FatbinHeader, - get_module_base: impl FnOnce() -> CUresult, -) -> CUresult { - if (*fatbin_header).magic != FATBIN_MAGIC || (*fatbin_header).version != FATBIN_VERSION { - return CUresult::CUDA_ERROR_INVALID_VALUE; - } - let file = (fatbin_header as *const u8).add((*fatbin_header).header_size as usize); - let end = file.add((*fatbin_header).files_size as usize); - let mut ptx_files = get_ptx_files(file, end); - ptx_files.sort_unstable_by_key(|f| c_uint::max_value() - (**f).sm_version); - let mut maybe_kernel_text = None; - for file in ptx_files { - match decompress_kernel_module(file) { - None => continue, - Some(vec) => { - maybe_kernel_text = Some(vec); - break; - } - }; - } - let result = get_module_base(); - if result != CUresult::CUDA_SUCCESS { - return result; - } - if let Some(text) = maybe_kernel_text { - match CStr::from_bytes_with_nul(&text) { - Ok(cstr) => match cstr.to_str() { - Ok(utf8_str) => { - record_module_image_with_module(*module, text.as_ptr() as _, utf8_str) - } - Err(_) => {} - }, - Err(_) => {} - } - } else { - os_log!("Unsupported runtime module: {:?}", *module); - } - result -} - -unsafe extern "system" fn get_module_from_cubin( - module: *mut CUmodule, - fatbinc_wrapper: *const FatbincWrapper, -) -> CUresult { - get_module_from_cubin_impl(module, fatbinc_wrapper, || { - ORIGINAL_GET_MODULE_FROM_CUBIN.unwrap()(module, fatbinc_wrapper) - }) -} - -unsafe extern "system" fn get_module_from_cubin_ext1( - module: *mut CUmodule, - fatbinc_wrapper: *const FatbincWrapper, - ptr1: *mut c_void, - ptr2: *mut c_void, - _unknown: usize, -) -> CUresult { - get_module_from_cubin_impl(module, fatbinc_wrapper, || { - ORIGINAL_GET_MODULE_FROM_CUBIN_EXT1.unwrap()(module, fatbinc_wrapper, ptr1, ptr2, _unknown) - }) -} - -unsafe extern "system" fn get_module_from_cubin_ext2( - fatbin_header: *const FatbinHeader, - module: *mut CUmodule, - ptr1: *mut c_void, - ptr2: *mut c_void, - _unknown: usize, -) -> CUresult { - get_module_from_cubin_unwrapped(module, fatbin_header, || { - ORIGINAL_GET_MODULE_FROM_CUBIN_EXT2.unwrap()(fatbin_header, module, ptr1, ptr2, _unknown) - }) -} - -unsafe fn get_ptx_files(file: *const u8, end: *const u8) -> Vec<*const FatbinFileHeader> { - let mut index = file; - let mut result = Vec::new(); - while index < end { - let file = index as *const FatbinFileHeader; - if (*file).kind == FATBIN_FILE_HEADER_KIND_PTX - && (*file).version == FATBIN_FILE_HEADER_VERSION_CURRENT - { - result.push(file) - } - index = index.add((*file).header_size as usize + (*file).padded_payload_size as usize); - } - result -} - -const MAX_PTX_MODULE_DECOMPRESSION_BOUND: usize = 16 * 1024 * 1024; - -unsafe fn decompress_kernel_module(file: *const FatbinFileHeader) -> Option> { - let decompressed_size = usize::max(1024, (*file).uncompressed_payload as usize); - let mut decompressed_vec = vec![0u8; decompressed_size]; - loop { - match lz4_sys::LZ4_decompress_safe( - (file as *const u8).add((*file).header_size as usize) as *const _, - decompressed_vec.as_mut_ptr() as *mut _, - (*file).payload_size as c_int, - decompressed_vec.len() as c_int, - ) { - error if error < 0 => { - let new_size = decompressed_vec.len() * 2; - if new_size > MAX_PTX_MODULE_DECOMPRESSION_BOUND { - return None; - } - decompressed_vec.resize(decompressed_vec.len() * 2, 0); - } - real_decompressed_size => { - decompressed_vec.truncate(real_decompressed_size as usize); - if decompressed_vec.last().copied().unwrap_or(1) != 0 { - decompressed_vec.push(0); - } - return Some(decompressed_vec); - } - } - } -} - -#[allow(non_snake_case)] -pub unsafe fn cuDeviceGetAttribute( - pi: *mut ::std::os::raw::c_int, - attrib: CUdevice_attribute, - dev: CUdevice, - cont: impl FnOnce(*mut ::std::os::raw::c_int, CUdevice_attribute, CUdevice) -> CUresult, -) -> CUresult { - if attrib == CUdevice_attribute::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR { - if let Some(ver) = OVERRIDE_COMPUTE_CAPABILITY_MAJOR { - *pi = ver; - return CUresult::CUDA_SUCCESS; - } - } - cont(pi, attrib, dev) -} - -#[allow(non_snake_case)] -pub unsafe fn cuLinkAddData( - state: CUlinkState, - type_: CUjitInputType, - data: *mut ::std::os::raw::c_void, - size: usize, - name: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - cont: impl FnOnce( - CUlinkState, - CUjitInputType, - *mut ::std::os::raw::c_void, - usize, - *const ::std::os::raw::c_char, - ::std::os::raw::c_uint, - *mut CUjit_option, - *mut *mut ::std::os::raw::c_void, - ) -> CUresult, -) -> CUresult { - if let Some(image) = to_str(data) { - record_module_image_with_linker(state, data, image) - } else { - os_log!("PTX module not a string: {:?}", data); - } - cont( - state, - type_, - data, - size, - name, - numOptions, - options, - optionValues, - ) -} - -#[allow(non_snake_case)] -pub unsafe fn cuLinkAddFile( - state: CUlinkState, - type_: CUjitInputType, - path: *const ::std::os::raw::c_char, - numOptions: ::std::os::raw::c_uint, - options: *mut CUjit_option, - optionValues: *mut *mut ::std::os::raw::c_void, - cont: impl FnOnce( - CUlinkState, - CUjitInputType, - *const ::std::os::raw::c_char, - ::std::os::raw::c_uint, - *mut CUjit_option, - *mut *mut ::std::os::raw::c_void, - ) -> CUresult, -) -> CUresult { - cont(state, type_, path, numOptions, options, optionValues) -} - #[allow(non_snake_case)] pub(crate) fn cuGetExportTable_Post( ppExportTable: *mut *const ::std::os::raw::c_void, @@ -1480,34 +370,34 @@ pub(crate) fn cuGetExportTable_Post( #[allow(non_snake_case)] pub(crate) fn cuModuleGetFunction_Post( - hfunc: *mut CUfunction, - hmod: CUmodule, - name: *const ::std::os::raw::c_char, - fn_logger: &mut log::FunctionLogger, - state: &mut trace::StateTracker, - result: CUresult, + _hfunc: *mut CUfunction, + _hmod: CUmodule, + _name: *const ::std::os::raw::c_char, + _fn_logger: &mut log::FunctionLogger, + _state: &mut trace::StateTracker, + _result: CUresult, ) { } #[allow(non_snake_case)] pub(crate) fn cuDeviceGetAttribute_Post( - pi: *mut ::std::os::raw::c_int, - attrib: CUdevice_attribute, - dev: CUdevice, - fn_logger: &mut log::FunctionLogger, - state: &mut trace::StateTracker, - result: CUresult, + _pi: *mut ::std::os::raw::c_int, + _attrib: CUdevice_attribute, + _dev: CUdevice, + _fn_logger: &mut log::FunctionLogger, + _state: &mut trace::StateTracker, + _result: CUresult, ) { } #[allow(non_snake_case)] pub(crate) fn cuDeviceComputeCapability_Post( major: *mut ::std::os::raw::c_int, - minor: *mut ::std::os::raw::c_int, - dev: CUdevice, - fn_logger: &mut log::FunctionLogger, + _minor: *mut ::std::os::raw::c_int, + _dev: CUdevice, + _fn_logger: &mut log::FunctionLogger, state: &mut trace::StateTracker, - result: CUresult, + _result: CUresult, ) { if let Some(major_ver_override) = state.override_cc_major { unsafe { *major = major_ver_override as i32 }; @@ -1516,10 +406,10 @@ pub(crate) fn cuDeviceComputeCapability_Post( #[allow(non_snake_case)] pub(crate) fn cuModuleLoadFatBinary_Post( - module: *mut CUmodule, - fatCubin: *const ::std::os::raw::c_void, - fn_logger: &mut log::FunctionLogger, - state: &mut trace::StateTracker, + _module: *mut CUmodule, + _fatCubin: *const ::std::os::raw::c_void, + _fn_logger: &mut log::FunctionLogger, + _state: &mut trace::StateTracker, result: CUresult, ) { if result == CUresult::CUDA_SUCCESS { diff --git a/zluda_dump/src/log.rs b/zluda_dump/src/log.rs index 8c226f9..00fe506 100644 --- a/zluda_dump/src/log.rs +++ b/zluda_dump/src/log.rs @@ -1,14 +1,11 @@ -use crate::cuda::CUmodule; -use crate::cuda::CUuuid; use crate::format; -use crate::format::FormatCudaObject; +use cuda_types::CUmodule; +use cuda_types::CUuuid; use super::CUresult; use super::Settings; -use std::borrow::Cow; use std::error::Error; use std::ffi::c_void; -use std::ffi::FromBytesWithNulError; use std::ffi::NulError; use std::fmt::Display; use std::fs::File; @@ -185,8 +182,9 @@ impl Factory { pub(crate) fn get_first_logger_and_init_settings( &mut self, func: &'static str, + arguments_writer: Box std::io::Result<()>>, ) -> (FunctionLogger, Settings) { - let mut first_logger = self.get_logger(func); + let mut first_logger = self.get_logger(func, arguments_writer); let settings = Settings::read_and_init(&mut first_logger); match Self::initalize_fallible_emitter(&settings) { Ok(fallible_emitter) => { @@ -201,7 +199,11 @@ impl Factory { (first_logger, settings) } - pub(crate) fn get_logger(&mut self, func: &'static str) -> FunctionLogger { + pub(crate) fn get_logger( + &mut self, + func: &'static str, + arguments_writer: Box std::io::Result<()>>, + ) -> FunctionLogger { FunctionLogger { result: None, name: CudaFunctionName::Normal(func), @@ -209,12 +211,16 @@ impl Factory { infallible_emitter: &mut self.infallible_emitter, write_buffer: &mut self.write_buffer, log_queue: &mut self.log_queue, - finished_writing_args: false, - args_to_write: 0, + arguments_writer: Some(arguments_writer), } } - pub(crate) fn get_logger_dark_api(&mut self, guid: CUuuid, index: usize) -> FunctionLogger { + pub(crate) fn get_logger_dark_api( + &mut self, + guid: CUuuid, + index: usize, + arguments_writer: Option std::io::Result<()>>>, + ) -> FunctionLogger { FunctionLogger { result: None, name: CudaFunctionName::Dark { guid, index }, @@ -222,8 +228,7 @@ impl Factory { infallible_emitter: &mut self.infallible_emitter, write_buffer: &mut self.write_buffer, log_queue: &mut self.log_queue, - finished_writing_args: false, - args_to_write: 0, + arguments_writer, } } } @@ -243,10 +248,9 @@ pub(crate) struct FunctionLogger<'a> { name: CudaFunctionName, infallible_emitter: &'a mut Box, fallible_emitter: &'a mut Option>, + arguments_writer: Option std::io::Result<()>>>, write_buffer: &'a mut WriteBuffer, log_queue: &'a mut Vec, - args_to_write: usize, - finished_writing_args: bool, } impl<'a> FunctionLogger<'a> { @@ -261,22 +265,31 @@ impl<'a> FunctionLogger<'a> { } fn flush_log_queue_to_write_buffer(&mut self) { - // TODO: remove this once everything has been converted to dtailed logging - if !self.finished_writing_args { - self.begin_writing_arguments(0); - self.write_buffer.write("...) -> "); + self.write_buffer.start_line(); + match self.name { + CudaFunctionName::Normal(fn_name) => self.write_buffer.write(fn_name), + CudaFunctionName::Dark { guid, index } => { + format::CudaDisplay::write(&guid, &mut self.write_buffer).ok(); + write!(&mut self.write_buffer, "::{}", index).ok(); + } } - if let Some(result) = self.result { - match format::stringify_CUresult(result) { - Some(text) => self.write_buffer.write(text), - None => write!(self.write_buffer, "{}", result.0).unwrap(), + match &mut self.arguments_writer { + Some(arg_writer) => { + arg_writer(&mut self.write_buffer).ok(); } + None => { + self.write_buffer.write_all(b"(...)").ok(); + } + } + self.write_buffer.write_all(b" -> ").ok(); + if let Some(result) = self.result { + format::CudaDisplay::write(&result, self.write_buffer).ok(); } else { - self.write_buffer.write("(UNKNOWN)"); + self.write_buffer.write_all(b"UNKNOWN").ok(); }; self.write_buffer.end_line(); for entry in self.log_queue.iter() { - write!(self.write_buffer, " {}", entry).unwrap_or_else(|_| unreachable!()); + write!(self.write_buffer, " {}", entry).ok(); self.write_buffer.end_line(); } self.write_buffer.finish(); @@ -290,35 +303,6 @@ impl<'a> FunctionLogger<'a> { self.write_buffer.end_line(); self.write_buffer.finish(); } - - pub(crate) fn begin_writing_arguments(&mut self, len: usize) { - self.args_to_write = len; - match self.name { - CudaFunctionName::Normal(fn_name) => self.write_buffer.write(fn_name), - CudaFunctionName::Dark { guid, index } => { - guid.write_post_execution(CUresult::CUDA_SUCCESS, &mut self.write_buffer); - write!(&mut self.write_buffer, "::{}", index).ok(); - } - } - self.write_buffer.write("(") - } - - pub(crate) fn write_single_argument<'x>( - &mut self, - result: CUresult, - arg: impl FormatCudaObject, - ) { - self.args_to_write -= 1; - arg.write_post_execution(result, self.write_buffer); - if self.args_to_write != 0 { - self.write_buffer.write(", ") - } - } - - pub(crate) fn end_writing_arguments(&mut self) { - self.write_buffer.write(") -> "); - self.finished_writing_args = true; - } } impl<'a> Drop for FunctionLogger<'a> { @@ -347,18 +331,12 @@ pub(crate) enum LogEntry { raw_image: *const c_void, kind: &'static str, }, - MalformedFunctionName(Utf8Error), - FunctionParameter { - name: &'static str, - value: String, - }, MalformedModulePath(Utf8Error), NonUtf8ModuleText(Utf8Error), NulInsideModuleText(NulError), ModuleParsingError(String), Lz4DecompressionFailure, UnknownExportTableFn, - UnknownModule(CUmodule), UnexpectedArgument { arg_name: &'static str, expected: Vec, @@ -406,7 +384,6 @@ impl Display for LogEntry { LogEntry::NulInsideModuleText(e) => e.fmt(f), LogEntry::Lz4DecompressionFailure => write!(f, "LZ4 decompression failure"), LogEntry::UnknownExportTableFn => write!(f, "Unknown export table function"), - LogEntry::UnknownModule(hmod) => write!(f, "Unknown module {:?}", hmod), LogEntry::UnexpectedBinaryField { field_name, expected, @@ -437,8 +414,6 @@ impl Display for LogEntry { .join(", "), observed ), - LogEntry::MalformedFunctionName(e) => e.fmt(f), - LogEntry::FunctionParameter { name, value } => write!(f, "{}: {}", name, value), } } } diff --git a/zluda_dump/src/os_win.rs b/zluda_dump/src/os_win.rs index d80f6e6..c138cc0 100644 --- a/zluda_dump/src/os_win.rs +++ b/zluda_dump/src/os_win.rs @@ -1,8 +1,6 @@ use std::{ - ffi::{c_void, CStr, CString, OsString}, - mem, - os::raw::c_ushort, - ptr, + ffi::{c_void, CStr}, + mem, ptr, }; use std::os::windows::io::AsRawHandle; @@ -12,7 +10,7 @@ use winapi::{ um::libloaderapi::{GetProcAddress, LoadLibraryW}, }; -use crate::cuda::CUuuid; +use cuda_types::CUuuid; pub(crate) const LIBCUDA_DEFAULT_PATH: &'static str = "C:\\Windows\\System32\\nvcuda.dll"; const LOAD_LIBRARY_NO_REDIRECT: &'static [u8] = b"ZludaLoadLibraryW_NoRedirect\0"; diff --git a/zluda_dump/src/trace.rs b/zluda_dump/src/trace.rs index 2afc1c5..59a0a0f 100644 --- a/zluda_dump/src/trace.rs +++ b/zluda_dump/src/trace.rs @@ -1,7 +1,8 @@ use ptx::{ast::PtxError, Token}; use ptx::{DisplayParseError, ModuleParserExt}; -use crate::{cuda::CUmodule, dark_api, log, Settings}; +use crate::{dark_api, log, Settings}; +use cuda_types::CUmodule; use std::{ collections::HashMap, ffi::{c_void, CStr, CString}, @@ -171,7 +172,7 @@ impl StateTracker { submodule_index: Option, module_text: &str, ) { - let (ast, errors) = ptx::ModuleParser::parse_unchecked(module_text); + let (_ast, errors) = ptx::ModuleParser::parse_unchecked(module_text); if !errors.is_empty() { fn_logger.log(log::LogEntry::ModuleParsingError( DumpWriter::get_file_name(module_index, version, submodule_index, "log"), @@ -185,10 +186,6 @@ impl StateTracker { )); } } - - pub(crate) fn module_exists(&self, hmod: CUmodule) -> bool { - self.modules.contains_key(&hmod) - } } struct ParsedModule { -- cgit v1.2.3