/dvs/p4/build/sw/gpgpu/bin/x86_64_Linux_release/stub/cuda.h
File members: /dvs/p4/build/sw/gpgpu/bin/x86_64_Linux_release/stub/cuda.h
/*
* Copyright 1993-2023 NVIDIA Corporation. All rights reserved.
*
* NOTICE TO LICENSEE:
*
* This source code and/or documentation ("Licensed Deliverables") are
* subject to NVIDIA intellectual property rights under U.S. and
* international Copyright laws.
*
* These Licensed Deliverables contained herein is PROPRIETARY and
* CONFIDENTIAL to NVIDIA and is being provided under the terms and
* conditions of a form of NVIDIA software license agreement by and
* between NVIDIA and Licensee ("License Agreement") or electronically
* accepted by Licensee. Notwithstanding any terms or conditions to
* the contrary in the License Agreement, reproduction or disclosure
* of the Licensed Deliverables to any third party without the express
* written consent of NVIDIA is prohibited.
*
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
* SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. IT IS
* PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
* NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
* DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
* NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
* SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THESE LICENSED DELIVERABLES.
*
* U.S. Government End Users. These Licensed Deliverables are a
* "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
* 1995), consisting of "commercial computer software" and "commercial
* computer software documentation" as such terms are used in 48
* C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
* only as a commercial end item. Consistent with 48 C.F.R.12.212 and
* 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
* U.S. Government End Users acquire the Licensed Deliverables with
* only those rights set forth herein.
*
* Any use of the Licensed Deliverables in individual and commercial
* software must include, in the user documentation and internal
* comments to the code, the above Disclaimer and U.S. Government End
* Users Notice.
*/
#ifndef __cuda_cuda_h__
#define __cuda_cuda_h__
#include <stdlib.h>
#ifdef _MSC_VER
typedef unsigned __int32 cuuint32_t;
typedef unsigned __int64 cuuint64_t;
#else
#include <stdint.h>
typedef uint32_t cuuint32_t;
typedef uint64_t cuuint64_t;
#endif
#if defined(__CUDA_API_VERSION_INTERNAL) || defined(__DOXYGEN_ONLY__) || defined(CUDA_ENABLE_DEPRECATED)
#define __CUDA_DEPRECATED
#elif defined(_MSC_VER)
#define __CUDA_DEPRECATED __declspec(deprecated)
#elif defined(__GNUC__)
#define __CUDA_DEPRECATED __attribute__((deprecated))
#else
#define __CUDA_DEPRECATED
#endif
#if defined(CUDA_FORCE_API_VERSION)
#error "CUDA_FORCE_API_VERSION is no longer supported."
#endif
#if defined(__CUDA_API_VERSION_INTERNAL) || defined(CUDA_API_PER_THREAD_DEFAULT_STREAM)
#define __CUDA_API_PER_THREAD_DEFAULT_STREAM
#define __CUDA_API_PTDS(api) api ## _ptds
#define __CUDA_API_PTSZ(api) api ## _ptsz
#else
#define __CUDA_API_PTDS(api) api
#define __CUDA_API_PTSZ(api) api
#endif
#define cuDeviceTotalMem cuDeviceTotalMem_v2
#define cuCtxCreate cuCtxCreate_v4
#define cuModuleGetGlobal cuModuleGetGlobal_v2
#define cuMemGetInfo cuMemGetInfo_v2
#define cuMemAlloc cuMemAlloc_v2
#define cuMemAllocPitch cuMemAllocPitch_v2
#define cuMemFree cuMemFree_v2
#define cuMemGetAddressRange cuMemGetAddressRange_v2
#define cuMemAllocHost cuMemAllocHost_v2
#define cuMemHostGetDevicePointer cuMemHostGetDevicePointer_v2
#define cuMemAdvise cuMemAdvise_v2
#define cuMemPrefetchAsync __CUDA_API_PTSZ(cuMemPrefetchAsync_v2)
#define cuMemPrefetchBatchAsync __CUDA_API_PTSZ(cuMemPrefetchBatchAsync)
#define cuMemDiscardBatchAsync __CUDA_API_PTSZ(cuMemDiscardBatchAsync)
#define cuMemDiscardAndPrefetchBatchAsync __CUDA_API_PTSZ(cuMemDiscardAndPrefetchBatchAsync)
#define cuMemcpyHtoD __CUDA_API_PTDS(cuMemcpyHtoD_v2)
#define cuMemcpyDtoH __CUDA_API_PTDS(cuMemcpyDtoH_v2)
#define cuMemcpyDtoD __CUDA_API_PTDS(cuMemcpyDtoD_v2)
#define cuMemcpyDtoA __CUDA_API_PTDS(cuMemcpyDtoA_v2)
#define cuMemcpyAtoD __CUDA_API_PTDS(cuMemcpyAtoD_v2)
#define cuMemcpyHtoA __CUDA_API_PTDS(cuMemcpyHtoA_v2)
#define cuMemcpyAtoH __CUDA_API_PTDS(cuMemcpyAtoH_v2)
#define cuMemcpyAtoA __CUDA_API_PTDS(cuMemcpyAtoA_v2)
#define cuMemcpyHtoAAsync __CUDA_API_PTSZ(cuMemcpyHtoAAsync_v2)
#define cuMemcpyAtoHAsync __CUDA_API_PTSZ(cuMemcpyAtoHAsync_v2)
#define cuMemcpy2D __CUDA_API_PTDS(cuMemcpy2D_v2)
#define cuMemcpy2DUnaligned __CUDA_API_PTDS(cuMemcpy2DUnaligned_v2)
#define cuMemcpy3D __CUDA_API_PTDS(cuMemcpy3D_v2)
#define cuMemcpyHtoDAsync __CUDA_API_PTSZ(cuMemcpyHtoDAsync_v2)
#define cuMemcpyDtoHAsync __CUDA_API_PTSZ(cuMemcpyDtoHAsync_v2)
#define cuMemcpyDtoDAsync __CUDA_API_PTSZ(cuMemcpyDtoDAsync_v2)
#define cuMemcpy2DAsync __CUDA_API_PTSZ(cuMemcpy2DAsync_v2)
#define cuMemcpy3DAsync __CUDA_API_PTSZ(cuMemcpy3DAsync_v2)
#define cuMemcpyBatchAsync __CUDA_API_PTSZ(cuMemcpyBatchAsync_v2)
#define cuMemcpy3DBatchAsync __CUDA_API_PTSZ(cuMemcpy3DBatchAsync_v2)
#define cuMemcpyWithAttributesAsync __CUDA_API_PTSZ(cuMemcpyWithAttributesAsync)
#define cuMemcpy3DWithAttributesAsync __CUDA_API_PTSZ(cuMemcpy3DWithAttributesAsync)
#define cuMemsetD8 __CUDA_API_PTDS(cuMemsetD8_v2)
#define cuMemsetD16 __CUDA_API_PTDS(cuMemsetD16_v2)
#define cuMemsetD32 __CUDA_API_PTDS(cuMemsetD32_v2)
#define cuMemsetD2D8 __CUDA_API_PTDS(cuMemsetD2D8_v2)
#define cuMemsetD2D16 __CUDA_API_PTDS(cuMemsetD2D16_v2)
#define cuMemsetD2D32 __CUDA_API_PTDS(cuMemsetD2D32_v2)
#define cuArrayCreate cuArrayCreate_v2
#define cuArrayGetDescriptor cuArrayGetDescriptor_v2
#define cuArray3DCreate cuArray3DCreate_v2
#define cuArray3DGetDescriptor cuArray3DGetDescriptor_v2
#define cuTexRefSetAddress cuTexRefSetAddress_v2
#define cuTexRefGetAddress cuTexRefGetAddress_v2
#define cuGraphicsResourceGetMappedPointer cuGraphicsResourceGetMappedPointer_v2
#define cuCtxDestroy cuCtxDestroy_v2
#define cuCtxPopCurrent cuCtxPopCurrent_v2
#define cuCtxPushCurrent cuCtxPushCurrent_v2
#define cuStreamDestroy cuStreamDestroy_v2
#define cuEventDestroy cuEventDestroy_v2
#define cuTexRefSetAddress2D cuTexRefSetAddress2D_v3
#define cuLinkCreate cuLinkCreate_v2
#define cuLinkAddData cuLinkAddData_v2
#define cuLinkAddFile cuLinkAddFile_v2
#define cuMemHostRegister cuMemHostRegister_v2
#define cuGraphicsResourceSetMapFlags cuGraphicsResourceSetMapFlags_v2
#define cuStreamBeginCapture __CUDA_API_PTSZ(cuStreamBeginCapture_v2)
#define cuDevicePrimaryCtxRelease cuDevicePrimaryCtxRelease_v2
#define cuDevicePrimaryCtxReset cuDevicePrimaryCtxReset_v2
#define cuDevicePrimaryCtxSetFlags cuDevicePrimaryCtxSetFlags_v2
#define cuDeviceGetUuid cuDeviceGetUuid_v2
#define cuIpcOpenMemHandle cuIpcOpenMemHandle_v2
#define cuGraphInstantiate cuGraphInstantiateWithFlags
#define cuGraphExecUpdate cuGraphExecUpdate_v2
#define cuGetProcAddress cuGetProcAddress_v2
#define cuGraphAddKernelNode cuGraphAddKernelNode_v2
#define cuGraphKernelNodeGetParams cuGraphKernelNodeGetParams_v2
#define cuGraphKernelNodeSetParams cuGraphKernelNodeSetParams_v2
#define cuGraphExecKernelNodeSetParams cuGraphExecKernelNodeSetParams_v2
#define cuGraphGetEdges cuGraphGetEdges_v2
#define cuGraphNodeGetDependencies cuGraphNodeGetDependencies_v2
#define cuGraphNodeGetDependentNodes cuGraphNodeGetDependentNodes_v2
#define cuGraphAddDependencies cuGraphAddDependencies_v2
#define cuGraphRemoveDependencies cuGraphRemoveDependencies_v2
#define cuGraphAddNode cuGraphAddNode_v2
#define cuEventElapsedTime cuEventElapsedTime_v2
#define cuStreamWriteValue32 __CUDA_API_PTSZ(cuStreamWriteValue32_v2)
#define cuStreamWaitValue32 __CUDA_API_PTSZ(cuStreamWaitValue32_v2)
#define cuStreamWriteValue64 __CUDA_API_PTSZ(cuStreamWriteValue64_v2)
#define cuStreamWaitValue64 __CUDA_API_PTSZ(cuStreamWaitValue64_v2)
#define cuStreamBatchMemOp __CUDA_API_PTSZ(cuStreamBatchMemOp_v2)
#define cuStreamGetCaptureInfo __CUDA_API_PTSZ(cuStreamGetCaptureInfo_v3)
#define cuStreamUpdateCaptureDependencies __CUDA_API_PTSZ(cuStreamUpdateCaptureDependencies_v2)
#if defined(__CUDA_API_PER_THREAD_DEFAULT_STREAM)
#define cuMemcpy __CUDA_API_PTDS(cuMemcpy)
#define cuMemcpyAsync __CUDA_API_PTSZ(cuMemcpyAsync)
#define cuMemcpyPeer __CUDA_API_PTDS(cuMemcpyPeer)
#define cuMemcpyPeerAsync __CUDA_API_PTSZ(cuMemcpyPeerAsync)
#define cuMemcpy3DPeer __CUDA_API_PTDS(cuMemcpy3DPeer)
#define cuMemcpy3DPeerAsync __CUDA_API_PTSZ(cuMemcpy3DPeerAsync)
#define cuMemsetD8Async __CUDA_API_PTSZ(cuMemsetD8Async)
#define cuMemsetD16Async __CUDA_API_PTSZ(cuMemsetD16Async)
#define cuMemsetD32Async __CUDA_API_PTSZ(cuMemsetD32Async)
#define cuMemsetD2D8Async __CUDA_API_PTSZ(cuMemsetD2D8Async)
#define cuMemsetD2D16Async __CUDA_API_PTSZ(cuMemsetD2D16Async)
#define cuMemsetD2D32Async __CUDA_API_PTSZ(cuMemsetD2D32Async)
#define cuStreamGetPriority __CUDA_API_PTSZ(cuStreamGetPriority)
#define cuStreamGetId __CUDA_API_PTSZ(cuStreamGetId)
#define cuStreamGetFlags __CUDA_API_PTSZ(cuStreamGetFlags)
#define cuStreamGetDevice __CUDA_API_PTSZ(cuStreamGetDevice)
#define cuStreamGetDevResource __CUDA_API_PTSZ(cuStreamGetDevResource)
#define cuStreamGetCtx __CUDA_API_PTSZ(cuStreamGetCtx)
#define cuStreamGetCtx_v2 __CUDA_API_PTSZ(cuStreamGetCtx_v2)
#define cuStreamWaitEvent __CUDA_API_PTSZ(cuStreamWaitEvent)
#define cuStreamEndCapture __CUDA_API_PTSZ(cuStreamEndCapture)
#define cuStreamIsCapturing __CUDA_API_PTSZ(cuStreamIsCapturing)
#define cuStreamAddCallback __CUDA_API_PTSZ(cuStreamAddCallback)
#define cuStreamAttachMemAsync __CUDA_API_PTSZ(cuStreamAttachMemAsync)
#define cuStreamQuery __CUDA_API_PTSZ(cuStreamQuery)
#define cuStreamSynchronize __CUDA_API_PTSZ(cuStreamSynchronize)
#define cuEventRecord __CUDA_API_PTSZ(cuEventRecord)
#define cuEventRecordWithFlags __CUDA_API_PTSZ(cuEventRecordWithFlags)
#define cuLaunchKernel __CUDA_API_PTSZ(cuLaunchKernel)
#define cuLaunchKernelEx __CUDA_API_PTSZ(cuLaunchKernelEx)
#define cuLaunchHostFunc __CUDA_API_PTSZ(cuLaunchHostFunc)
#define cuLaunchHostFunc_v2 __CUDA_API_PTSZ(cuLaunchHostFunc_v2)
#define cuGraphicsMapResources __CUDA_API_PTSZ(cuGraphicsMapResources)
#define cuGraphicsUnmapResources __CUDA_API_PTSZ(cuGraphicsUnmapResources)
#define cuLaunchCooperativeKernel __CUDA_API_PTSZ(cuLaunchCooperativeKernel)
#define cuSignalExternalSemaphoresAsync __CUDA_API_PTSZ(cuSignalExternalSemaphoresAsync)
#define cuWaitExternalSemaphoresAsync __CUDA_API_PTSZ(cuWaitExternalSemaphoresAsync)
#define cuGraphInstantiateWithParams __CUDA_API_PTSZ(cuGraphInstantiateWithParams)
#define cuGraphUpload __CUDA_API_PTSZ(cuGraphUpload)
#define cuGraphLaunch __CUDA_API_PTSZ(cuGraphLaunch)
#define cuStreamCopyAttributes __CUDA_API_PTSZ(cuStreamCopyAttributes)
#define cuStreamGetAttribute __CUDA_API_PTSZ(cuStreamGetAttribute)
#define cuStreamSetAttribute __CUDA_API_PTSZ(cuStreamSetAttribute)
#define cuMemMapArrayAsync __CUDA_API_PTSZ(cuMemMapArrayAsync)
#define cuMemFreeAsync __CUDA_API_PTSZ(cuMemFreeAsync)
#define cuMemAllocAsync __CUDA_API_PTSZ(cuMemAllocAsync)
#define cuMemAllocFromPoolAsync __CUDA_API_PTSZ(cuMemAllocFromPoolAsync)
#define cuStreamBeginCaptureToGraph __CUDA_API_PTSZ(cuStreamBeginCaptureToGraph)
#define cuStreamBeginRecaptureToGraph __CUDA_API_PTSZ(cuStreamBeginRecaptureToGraph)
#endif
#define cuStreamBeginCaptureToCig __CUDA_API_PTSZ(cuStreamBeginCaptureToCig)
#define cuStreamEndCaptureToCig __CUDA_API_PTSZ(cuStreamEndCaptureToCig)
#define cuMemBatchDecompressAsync __CUDA_API_PTSZ(cuMemBatchDecompressAsync)
#define CUDA_VERSION 13050
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN64) || defined(__LP64__)
typedef unsigned long long CUdeviceptr_v2;
#else
typedef unsigned int CUdeviceptr_v2;
#endif
typedef CUdeviceptr_v2 CUdeviceptr;
typedef int CUdevice_v1;
typedef CUdevice_v1 CUdevice;
typedef struct CUctx_st *CUcontext;
typedef struct CUmod_st *CUmodule;
typedef struct CUfunc_st *CUfunction;
typedef struct CUlib_st *CUlibrary;
typedef struct CUkern_st *CUkernel;
typedef struct CUexport_st *CUexport;
typedef struct CUarray_st *CUarray;
typedef struct CUmipmappedArray_st *CUmipmappedArray;
typedef struct CUtexref_st *CUtexref;
typedef struct CUsurfref_st *CUsurfref;
typedef struct CUevent_st *CUevent;
typedef struct CUstream_st *CUstream;
typedef struct CUgraphicsResource_st *CUgraphicsResource;
typedef unsigned long long CUtexObject_v1;
typedef CUtexObject_v1 CUtexObject;
typedef unsigned long long CUsurfObject_v1;
typedef CUsurfObject_v1 CUsurfObject;
typedef struct CUextMemory_st *CUexternalMemory;
typedef struct CUextSemaphore_st *CUexternalSemaphore;
typedef struct CUgraph_st *CUgraph;
typedef struct CUgraphNode_st *CUgraphNode;
typedef struct CUgraphVariable_st *CUgraphVariable;
typedef struct CUgraphExec_st *CUgraphExec;
typedef struct CUmemPoolHandle_st *CUmemoryPool;
typedef struct CUuserObject_st *CUuserObject;
typedef cuuint64_t CUgraphConditionalHandle;
typedef struct CUgraphDeviceUpdatableNode_st *CUgraphDeviceNode;
typedef struct CUasyncCallbackEntry_st *CUasyncCallbackHandle;
typedef struct CUlaunchAttribute_st CUlaunchAttribute;
typedef struct CUgreenCtx_st *CUgreenCtx;
typedef struct CUsubgridSchedule_st *CUsubgridSchedule;
typedef struct CUsubgridWorkerGrid_st *CUsubgridWorkerGrid;
typedef struct CUsubgridWorkset_st *CUsubgridWorkset;
typedef struct CUsubgrid_st *CUsubgrid;
typedef enum CUsubgridDependencyType_enum {
CU_SUBGRID_DEPENDENCY_TYPE_DEFAULT = 1,
CU_SUBGRID_DEPENDENCY_TYPE_LAUNCH_ORDER = 2
} CUsubgridDependencyType;
#ifndef CU_UUID_HAS_BEEN_DEFINED
#define CU_UUID_HAS_BEEN_DEFINED
typedef struct CUuuid_st {
char bytes[16];
} CUuuid;
#endif
#define CU_IPC_HANDLE_SIZE 64
typedef struct CUmemFabricHandle_st {
unsigned char data[CU_IPC_HANDLE_SIZE];
} CUmemFabricHandle_v1;
typedef CUmemFabricHandle_v1 CUmemFabricHandle;
typedef struct CUipcEventHandle_st {
char reserved[CU_IPC_HANDLE_SIZE];
} CUipcEventHandle_v1;
typedef CUipcEventHandle_v1 CUipcEventHandle;
typedef struct CUipcMemHandle_st {
char reserved[CU_IPC_HANDLE_SIZE];
} CUipcMemHandle_v1;
typedef CUipcMemHandle_v1 CUipcMemHandle;
typedef enum CUipcMem_flags_enum {
CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 0x1
} CUipcMem_flags;
typedef enum CUmemAttach_flags_enum {
CU_MEM_ATTACH_GLOBAL = 0x1,
CU_MEM_ATTACH_HOST = 0x2,
CU_MEM_ATTACH_SINGLE = 0x4
} CUmemAttach_flags;
typedef enum CUctx_flags_enum {
CU_CTX_SCHED_AUTO = 0x00,
CU_CTX_SCHED_SPIN = 0x01,
CU_CTX_SCHED_YIELD = 0x02,
CU_CTX_SCHED_BLOCKING_SYNC = 0x04,
CU_CTX_BLOCKING_SYNC = 0x04,
CU_CTX_SCHED_MASK = 0x07,
CU_CTX_MAP_HOST = 0x08,
CU_CTX_LMEM_RESIZE_TO_MAX = 0x10,
CU_CTX_COREDUMP_ENABLE = 0x20,
CU_CTX_USER_COREDUMP_ENABLE= 0x40,
CU_CTX_SYNC_MEMOPS = 0x80,
CU_CTX_FLAGS_MASK = 0xFF
} CUctx_flags;
typedef enum CUevent_sched_flags_enum {
CU_EVENT_SCHED_AUTO = 0x00,
CU_EVENT_SCHED_SPIN = 0x01,
CU_EVENT_SCHED_YIELD = 0x02,
CU_EVENT_SCHED_BLOCKING_SYNC = 0x04,
} CUevent_sched_flags;
typedef enum cl_event_flags_enum {
NVCL_EVENT_SCHED_AUTO = 0x00,
NVCL_EVENT_SCHED_SPIN = 0x01,
NVCL_EVENT_SCHED_YIELD = 0x02,
NVCL_EVENT_SCHED_BLOCKING_SYNC = 0x04,
} cl_event_flags;
typedef enum cl_context_flags_enum {
NVCL_CTX_SCHED_AUTO = 0x00,
NVCL_CTX_SCHED_SPIN = 0x01,
NVCL_CTX_SCHED_YIELD = 0x02,
NVCL_CTX_SCHED_BLOCKING_SYNC = 0x04,
} cl_context_flags;
/*
* Host task synchronization mode
*/
typedef enum CUhostTaskSyncMode_enum {
CU_HOST_TASK_BLOCKING = 0x0,
CU_HOST_TASK_SPINWAIT = 0x1,
} CUhostTaskSyncMode;
typedef enum CUstream_flags_enum {
CU_STREAM_DEFAULT = 0x0,
CU_STREAM_NON_BLOCKING = 0x1
} CUstream_flags;
#define CU_STREAM_LEGACY ((CUstream)0x1)
#define CU_STREAM_PER_THREAD ((CUstream)0x2)
typedef enum CUevent_flags_enum {
CU_EVENT_DEFAULT = 0x0,
CU_EVENT_BLOCKING_SYNC = 0x1,
CU_EVENT_DISABLE_TIMING = 0x2,
CU_EVENT_INTERPROCESS = 0x4
} CUevent_flags;
typedef enum CUevent_record_flags_enum {
CU_EVENT_RECORD_DEFAULT = 0x0,
CU_EVENT_RECORD_EXTERNAL = 0x1
} CUevent_record_flags;
typedef enum CUevent_wait_flags_enum {
CU_EVENT_WAIT_DEFAULT = 0x0,
CU_EVENT_WAIT_EXTERNAL = 0x1
} CUevent_wait_flags;
typedef enum CUatomicOperation_enum {
CU_ATOMIC_OPERATION_INTEGER_ADD = 0,
CU_ATOMIC_OPERATION_INTEGER_MIN = 1,
CU_ATOMIC_OPERATION_INTEGER_MAX = 2,
CU_ATOMIC_OPERATION_INTEGER_INCREMENT = 3,
CU_ATOMIC_OPERATION_INTEGER_DECREMENT = 4,
CU_ATOMIC_OPERATION_AND = 5,
CU_ATOMIC_OPERATION_OR = 6,
CU_ATOMIC_OPERATION_XOR = 7,
CU_ATOMIC_OPERATION_EXCHANGE = 8,
CU_ATOMIC_OPERATION_CAS = 9,
CU_ATOMIC_OPERATION_FLOAT_ADD = 10,
CU_ATOMIC_OPERATION_FLOAT_MIN = 11,
CU_ATOMIC_OPERATION_FLOAT_MAX = 12,
CU_ATOMIC_OPERATION_MAX
} CUatomicOperation;
typedef enum CUatomicOperationCapability_enum {
CU_ATOMIC_CAPABILITY_SIGNED = 1u<<0,
CU_ATOMIC_CAPABILITY_UNSIGNED = 1u<<1,
CU_ATOMIC_CAPABILITY_REDUCTION = 1u<<2,
CU_ATOMIC_CAPABILITY_SCALAR_32 = 1u<<3,
CU_ATOMIC_CAPABILITY_SCALAR_64 = 1u<<4,
CU_ATOMIC_CAPABILITY_SCALAR_128 = 1u<<5,
CU_ATOMIC_CAPABILITY_VECTOR_32x4 = 1u<<6
} CUatomicOperationCapability;
typedef enum CUstreamWaitValue_flags_enum {
CU_STREAM_WAIT_VALUE_GEQ = 0x0,
CU_STREAM_WAIT_VALUE_EQ = 0x1,
CU_STREAM_WAIT_VALUE_AND = 0x2,
CU_STREAM_WAIT_VALUE_NOR = 0x3,
CU_STREAM_WAIT_VALUE_FLUSH = 1<<30
} CUstreamWaitValue_flags;
typedef enum CUstreamWriteValue_flags_enum {
CU_STREAM_WRITE_VALUE_DEFAULT = 0x0,
CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = 0x1
} CUstreamWriteValue_flags;
typedef enum CUstreamBatchMemOpType_enum {
CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1,
CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2,
CU_STREAM_MEM_OP_WAIT_VALUE_64 = 4,
CU_STREAM_MEM_OP_WRITE_VALUE_64 = 5,
CU_STREAM_MEM_OP_BARRIER = 6,
CU_STREAM_MEM_OP_ATOMIC_REDUCTION = 8,
CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3
} CUstreamBatchMemOpType;
typedef enum CUstreamMemoryBarrier_flags_enum {
CU_STREAM_MEMORY_BARRIER_TYPE_SYS = 0x0,
CU_STREAM_MEMORY_BARRIER_TYPE_GPU = 0x1
} CUstreamMemoryBarrier_flags;
typedef enum CUstreamAtomicReductionOpType_enum {
CU_STREAM_ATOMIC_REDUCTION_OP_OR = CU_ATOMIC_OPERATION_OR,
CU_STREAM_ATOMIC_REDUCTION_OP_AND = CU_ATOMIC_OPERATION_AND,
CU_STREAM_ATOMIC_REDUCTION_OP_ADD = CU_ATOMIC_OPERATION_INTEGER_ADD,
} CUstreamAtomicReductionOpType;
typedef enum CUstreamAtomicReductionDataType_enum {
CU_STREAM_ATOMIC_REDUCTION_UNSIGNED_32 = CU_ATOMIC_CAPABILITY_UNSIGNED | CU_ATOMIC_CAPABILITY_SCALAR_32 | CU_ATOMIC_CAPABILITY_REDUCTION,
CU_STREAM_ATOMIC_REDUCTION_UNSIGNED_64 = CU_ATOMIC_CAPABILITY_UNSIGNED | CU_ATOMIC_CAPABILITY_SCALAR_64 | CU_ATOMIC_CAPABILITY_REDUCTION,
} CUstreamAtomicReductionDataType;
typedef union CUstreamBatchMemOpParams_union {
CUstreamBatchMemOpType operation;
struct CUstreamMemOpWaitValueParams_st {
CUstreamBatchMemOpType operation;
CUdeviceptr address;
union {
cuuint32_t value;
cuuint64_t value64;
};
unsigned int flags;
CUdeviceptr alias;
} waitValue;
struct CUstreamMemOpWriteValueParams_st {
CUstreamBatchMemOpType operation;
CUdeviceptr address;
union {
cuuint32_t value;
cuuint64_t value64;
};
unsigned int flags;
CUdeviceptr alias;
} writeValue;
struct CUstreamMemOpFlushRemoteWritesParams_st {
CUstreamBatchMemOpType operation;
unsigned int flags;
} flushRemoteWrites;
struct CUstreamMemOpMemoryBarrierParams_st {
CUstreamBatchMemOpType operation;
unsigned int flags;
} memoryBarrier;
struct CUstreamMemOpAtomicReductionParams_st {
CUstreamBatchMemOpType operation;
unsigned int flags;
CUstreamAtomicReductionOpType reductionOp;
CUstreamAtomicReductionDataType dataType;
CUdeviceptr address;
cuuint64_t value;
CUdeviceptr alias;
} atomicReduction;
cuuint64_t pad[6];
} CUstreamBatchMemOpParams_v1;
typedef CUstreamBatchMemOpParams_v1 CUstreamBatchMemOpParams;
typedef enum {
CU_GRAPH_KERNEL_NODE_RELOC_TARGET_TYPE_ARG = 0
} CUgraphKernelNodeRelocTargetType;
typedef struct CUgraphKernelNodeRelocTarget_v1 {
CUgraphKernelNodeRelocTargetType what;
union { int index; };
} CUgraphKernelNodeRelocTarget;
typedef enum {
CU_GRAPH_MEMCPY_NODE_RELOC_TARGET_TYPE_SRC_PTR = 0,
CU_GRAPH_MEMCPY_NODE_RELOC_TARGET_TYPE_DST_PTR = 1
} CUgraphMemcpyNodeRelocTargetType;
typedef struct CUgraphMemcpyNodeRelocTarget_v1 {
CUgraphMemcpyNodeRelocTargetType what;
} CUgraphMemcpyNodeRelocTarget;
typedef enum {
CU_GRAPH_MEMSET_NODE_RELOC_TARGET_TYPE_DST_PTR = 0,
CU_GRAPH_MEMSET_NODE_RELOC_TARGET_TYPE_VAL = 1,
CU_GRAPH_MEMSET_NODE_RELOC_TARGET_TYPE_WHOLE_MEMSETPARAMS = 2
} CUgraphMemsetNodeRelocTargetType;
typedef struct CUgraphMemsetNodeRelocTarget_v1 {
CUgraphMemsetNodeRelocTargetType what;
} CUgraphMemsetNodeRelocTarget;
typedef struct CUgraphRelocationEntry_v1 {
CUgraphVariable symbol;
union{
CUgraphKernelNodeRelocTarget kernelTarget;
CUgraphMemcpyNodeRelocTarget memcpyTarget;
CUgraphMemsetNodeRelocTarget memsetTarget;
};
} CUgraphRelocationEntry;
typedef struct CUDA_BATCH_MEM_OP_NODE_PARAMS_v1_st {
CUcontext ctx;
unsigned int count;
CUstreamBatchMemOpParams *paramArray;
unsigned int flags;
} CUDA_BATCH_MEM_OP_NODE_PARAMS_v1;
typedef CUDA_BATCH_MEM_OP_NODE_PARAMS_v1 CUDA_BATCH_MEM_OP_NODE_PARAMS;
typedef struct CUDA_BATCH_MEM_OP_NODE_PARAMS_v2_st {
CUcontext ctx;
unsigned int count;
CUstreamBatchMemOpParams *paramArray;
unsigned int flags;
} CUDA_BATCH_MEM_OP_NODE_PARAMS_v2;
typedef enum CUoccupancy_flags_enum {
CU_OCCUPANCY_DEFAULT = 0x0,
CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 0x1
} CUoccupancy_flags;
typedef enum CUstreamUpdateCaptureDependencies_flags_enum {
CU_STREAM_ADD_CAPTURE_DEPENDENCIES = 0x0,
CU_STREAM_SET_CAPTURE_DEPENDENCIES = 0x1
} CUstreamUpdateCaptureDependencies_flags;
typedef enum CUasyncNotificationType_enum {
CU_ASYNC_NOTIFICATION_TYPE_OVER_BUDGET = 0x1
} CUasyncNotificationType;
typedef struct CUasyncNotificationInfo_st {
CUasyncNotificationType type;
union {
struct {
unsigned long long bytesOverBudget;
} overBudget;
} info;
} CUasyncNotificationInfo;
typedef void (*CUasyncCallback)(CUasyncNotificationInfo *info, void *userData, CUasyncCallbackHandle callback);
typedef enum CUarray_format_enum {
CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
CU_AD_FORMAT_SIGNED_INT8 = 0x08,
CU_AD_FORMAT_SIGNED_INT16 = 0x09,
CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
CU_AD_FORMAT_HALF = 0x10,
CU_AD_FORMAT_FLOAT = 0x20,
CU_AD_FORMAT_NV12 = 0xb0,
CU_AD_FORMAT_UNORM_INT8X1 = 0xc0,
CU_AD_FORMAT_UNORM_INT8X2 = 0xc1,
CU_AD_FORMAT_UNORM_INT8X4 = 0xc2,
CU_AD_FORMAT_UNORM_INT16X1 = 0xc3,
CU_AD_FORMAT_UNORM_INT16X2 = 0xc4,
CU_AD_FORMAT_UNORM_INT16X4 = 0xc5,
CU_AD_FORMAT_SNORM_INT8X1 = 0xc6,
CU_AD_FORMAT_SNORM_INT8X2 = 0xc7,
CU_AD_FORMAT_SNORM_INT8X4 = 0xc8,
CU_AD_FORMAT_SNORM_INT16X1 = 0xc9,
CU_AD_FORMAT_SNORM_INT16X2 = 0xca,
CU_AD_FORMAT_SNORM_INT16X4 = 0xcb,
CU_AD_FORMAT_BC1_UNORM = 0x91,
CU_AD_FORMAT_BC1_UNORM_SRGB = 0x92,
CU_AD_FORMAT_BC2_UNORM = 0x93,
CU_AD_FORMAT_BC2_UNORM_SRGB = 0x94,
CU_AD_FORMAT_BC3_UNORM = 0x95,
CU_AD_FORMAT_BC3_UNORM_SRGB = 0x96,
CU_AD_FORMAT_BC4_UNORM = 0x97,
CU_AD_FORMAT_BC4_SNORM = 0x98,
CU_AD_FORMAT_BC5_UNORM = 0x99,
CU_AD_FORMAT_BC5_SNORM = 0x9a,
CU_AD_FORMAT_BC6H_UF16 = 0x9b,
CU_AD_FORMAT_BC6H_SF16 = 0x9c,
CU_AD_FORMAT_BC7_UNORM = 0x9d,
CU_AD_FORMAT_BC7_UNORM_SRGB = 0x9e,
CU_AD_FORMAT_P010 = 0x9f,
CU_AD_FORMAT_P016 = 0xa1,
CU_AD_FORMAT_NV16 = 0xa2,
CU_AD_FORMAT_P210 = 0xa3,
CU_AD_FORMAT_P216 = 0xa4,
CU_AD_FORMAT_YUY2 = 0xa5,
CU_AD_FORMAT_Y210 = 0xa6,
CU_AD_FORMAT_Y216 = 0xa7,
CU_AD_FORMAT_AYUV = 0xa8,
CU_AD_FORMAT_Y410 = 0xa9,
CU_AD_FORMAT_Y416 = 0xb1,
CU_AD_FORMAT_Y444_PLANAR8 = 0xb2,
CU_AD_FORMAT_Y444_PLANAR10 = 0xb3,
CU_AD_FORMAT_YUV444_8bit_SemiPlanar = 0xb4,
CU_AD_FORMAT_YUV444_16bit_SemiPlanar = 0xb5,
CU_AD_FORMAT_UNORM_INT_101010_2 = 0x50,
CU_AD_FORMAT_UINT8_PACKED_422 = 0x51,
CU_AD_FORMAT_UINT8_PACKED_444 = 0x52,
CU_AD_FORMAT_UINT8_SEMIPLANAR_420 = 0x53,
CU_AD_FORMAT_UINT16_SEMIPLANAR_420 = 0x54,
CU_AD_FORMAT_UINT8_SEMIPLANAR_422 = 0x55,
CU_AD_FORMAT_UINT16_SEMIPLANAR_422 = 0x56,
CU_AD_FORMAT_UINT8_SEMIPLANAR_444 = 0x57,
CU_AD_FORMAT_UINT16_SEMIPLANAR_444 = 0x58,
CU_AD_FORMAT_UINT8_PLANAR_420 = 0x59,
CU_AD_FORMAT_UINT16_PLANAR_420 = 0x5a,
CU_AD_FORMAT_UINT8_PLANAR_422 = 0x5b,
CU_AD_FORMAT_UINT16_PLANAR_422 = 0x5c,
CU_AD_FORMAT_UINT8_PLANAR_444 = 0x5d,
CU_AD_FORMAT_UINT16_PLANAR_444 = 0x5e,
CU_AD_FORMAT_MAX = 0x7FFFFFFF
} CUarray_format;
typedef enum CUaddress_mode_enum {
CU_TR_ADDRESS_MODE_WRAP = 0,
CU_TR_ADDRESS_MODE_CLAMP = 1,
CU_TR_ADDRESS_MODE_MIRROR = 2,
CU_TR_ADDRESS_MODE_BORDER = 3
} CUaddress_mode;
typedef enum CUfilter_mode_enum {
CU_TR_FILTER_MODE_POINT = 0,
CU_TR_FILTER_MODE_LINEAR = 1
} CUfilter_mode;
typedef enum CUdevice_attribute_enum {
CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2,
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3,
CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4,
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5,
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6,
CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7,
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8,
CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = 8,
CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9,
CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,
CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11,
CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,
CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = 12,
CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,
CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14,
CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,
CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,
CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17,
CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,
CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,
CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = 27,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = 28,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = 29,
CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30,
CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,
CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32,
CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33,
CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34,
CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35,
CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36,
CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37,
CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38,
CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39,
CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,
CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43,
CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49,
CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50,
CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67,
CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74,
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77,
CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78,
CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79,
CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80,
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81,
CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82,
CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83,
CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84,
CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85,
CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86,
CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87,
CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88,
CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89,
CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90,
CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91,
CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS_V1 = 92,
CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V1 = 93,
CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V1 = 94,
CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = 95,
CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = 96,
CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = 97,
CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = 98,
CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = 99,
CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = 100,
CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = 101,
CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED = 102,
CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = 102,
CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED = 103,
CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED = 104,
CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED = 105,
CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR = 106,
CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED = 107,
CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE = 108,
CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE = 109,
CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED = 110,
CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK = 111,
CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED = 112,
CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED = 113,
CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED = 114,
CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED = 115,
CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED = 116,
CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS = 117,
CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING = 118,
CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES = 119,
CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH = 120,
CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED = 121,
CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = 122,
CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = 123,
CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED = 124,
CU_DEVICE_ATTRIBUTE_IPC_EVENT_SUPPORTED = 125,
CU_DEVICE_ATTRIBUTE_MEM_SYNC_DOMAIN_COUNT = 126,
CU_DEVICE_ATTRIBUTE_TENSOR_MAP_ACCESS_SUPPORTED = 127,
CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_FABRIC_SUPPORTED = 128,
CU_DEVICE_ATTRIBUTE_UNIFIED_FUNCTION_POINTERS = 129,
CU_DEVICE_ATTRIBUTE_NUMA_CONFIG = 130,
CU_DEVICE_ATTRIBUTE_NUMA_ID = 131,
CU_DEVICE_ATTRIBUTE_MULTICAST_SUPPORTED = 132,
CU_DEVICE_ATTRIBUTE_MPS_ENABLED = 133,
CU_DEVICE_ATTRIBUTE_HOST_NUMA_ID = 134,
CU_DEVICE_ATTRIBUTE_D3D12_CIG_SUPPORTED = 135,
CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_ALGORITHM_MASK = 136,
CU_DEVICE_ATTRIBUTE_MEM_DECOMPRESS_MAXIMUM_LENGTH = 137,
CU_DEVICE_ATTRIBUTE_VULKAN_CIG_SUPPORTED = 138,
CU_DEVICE_ATTRIBUTE_GPU_PCI_DEVICE_ID = 139,
CU_DEVICE_ATTRIBUTE_GPU_PCI_SUBSYSTEM_ID = 140,
CU_DEVICE_ATTRIBUTE_HOST_NUMA_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = 141,
CU_DEVICE_ATTRIBUTE_HOST_NUMA_MEMORY_POOLS_SUPPORTED = 142,
CU_DEVICE_ATTRIBUTE_HOST_NUMA_MULTINODE_IPC_SUPPORTED = 143,
CU_DEVICE_ATTRIBUTE_HOST_MEMORY_POOLS_SUPPORTED = 144,
CU_DEVICE_ATTRIBUTE_HOST_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = 145,
CU_DEVICE_ATTRIBUTE_HOST_ALLOC_DMA_BUF_SUPPORTED = 146,
CU_DEVICE_ATTRIBUTE_ONLY_PARTIAL_HOST_NATIVE_ATOMIC_SUPPORTED = 147,
CU_DEVICE_ATTRIBUTE_ATOMIC_REDUCTION_SUPPORTED = 148,
CU_DEVICE_ATTRIBUTE_LOCALITY_DOMAIN_COUNT = 149,
CU_DEVICE_ATTRIBUTE_MAX_OVERSIZED_SHARED_MEMORY_PER_BLOCK = 150,
CU_DEVICE_ATTRIBUTE_D3D12_CIG_STREAMS_SUPPORTED = 151,
CU_DEVICE_ATTRIBUTE_DMA_BUF_MMAP_SUPPORTED = 152,
CU_DEVICE_ATTRIBUTE_LOGICAL_ENDPOINT_UNICAST_SUPPORTED = 153,
CU_DEVICE_ATTRIBUTE_LOGICAL_ENDPOINT_MULTICAST_SUPPORTED = 154,
CU_DEVICE_ATTRIBUTE_LOGICAL_ENDPOINT_COUNTED_OPS_SUPPORTED = 155,
CU_DEVICE_ATTRIBUTE_LOGICAL_ENDPOINT_UNICAST_ACCESS_ON_OWNER_DEVICE_SUPPORTED = 156,
CU_DEVICE_ATTRIBUTE_LOCALITY_DOMAIN_MULTIPROCESSOR_COUNT = 157,
CU_DEVICE_ATTRIBUTE_LOGICAL_ENDPOINT_SUPPORTED_HANDLE_TYPES = 158,
CU_DEVICE_ATTRIBUTE_VULKAN_CIG_STREAMS_SUPPORTED = 159,
CU_DEVICE_ATTRIBUTE_TENSOR_MAP_LARGE_TENSOR_MIN_SIZE = 160,
CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_LOCALIZED_MEMORY_SUPPORTED = 161,
CU_DEVICE_ATTRIBUTE_EXTERNAL_DMA_BUF_SUPPORTED = 162,
CU_DEVICE_ATTRIBUTE_MAX
} CUdevice_attribute;
typedef struct CUdevprop_st {
int maxThreadsPerBlock;
int maxThreadsDim[3];
int maxGridSize[3];
int sharedMemPerBlock;
int totalConstantMemory;
int SIMDWidth;
int memPitch;
int regsPerBlock;
int clockRate;
int textureAlign;
} CUdevprop_v1;
typedef CUdevprop_v1 CUdevprop;
typedef enum CUpointer_attribute_enum {
CU_POINTER_ATTRIBUTE_CONTEXT = 1,
CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2,
CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3,
CU_POINTER_ATTRIBUTE_HOST_POINTER = 4,
CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5,
CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6,
CU_POINTER_ATTRIBUTE_BUFFER_ID = 7,
CU_POINTER_ATTRIBUTE_IS_MANAGED = 8,
CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9,
CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = 10,
CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11,
CU_POINTER_ATTRIBUTE_RANGE_SIZE = 12,
CU_POINTER_ATTRIBUTE_MAPPED = 13,
CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14,
CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15,
CU_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16,
CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17,
CU_POINTER_ATTRIBUTE_MAPPING_SIZE = 18,
CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR = 19,
CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID = 20
, CU_POINTER_ATTRIBUTE_IS_HW_DECOMPRESS_CAPABLE = 21
, CU_POINTER_ATTRIBUTE_LOCALITY_DOMAIN_ORDINAL = 22
} CUpointer_attribute;
typedef enum CUfunction_attribute_enum {
CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,
CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1,
CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2,
CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3,
CU_FUNC_ATTRIBUTE_NUM_REGS = 4,
CU_FUNC_ATTRIBUTE_PTX_VERSION = 5,
CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6,
CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7,
CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8,
CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9,
CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET = 10,
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH = 11,
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT = 12,
CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH = 13,
CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED = 14,
CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = 15,
CU_FUNC_ATTRIBUTE_DEVICE_NODE_UPDATE_SUPPORTED = 16,
CU_FUNC_ATTRIBUTE_SHARED_MEMORY_MODE = 17,
CU_FUNC_ATTRIBUTE_MAX
} CUfunction_attribute;
typedef enum CUfunc_cache_enum {
CU_FUNC_CACHE_PREFER_NONE = 0x00,
CU_FUNC_CACHE_PREFER_SHARED = 0x01,
CU_FUNC_CACHE_PREFER_L1 = 0x02,
CU_FUNC_CACHE_PREFER_EQUAL = 0x03
} CUfunc_cache;
typedef enum CUsharedconfig_enum {
CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = 0x00,
CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = 0x01,
CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = 0x02
} CUsharedconfig;
typedef enum CUshared_carveout_enum {
CU_SHAREDMEM_CARVEOUT_DEFAULT = -1,
CU_SHAREDMEM_CARVEOUT_MAX_SHARED = 100,
CU_SHAREDMEM_CARVEOUT_MAX_L1 = 0
} CUshared_carveout;
typedef enum CUmemorytype_enum {
CU_MEMORYTYPE_HOST = 0x01,
CU_MEMORYTYPE_DEVICE = 0x02,
CU_MEMORYTYPE_ARRAY = 0x03,
CU_MEMORYTYPE_UNIFIED = 0x04
} CUmemorytype;
typedef enum CUcomputemode_enum {
CU_COMPUTEMODE_DEFAULT = 0,
CU_COMPUTEMODE_PROHIBITED = 2,
CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3
} CUcomputemode;
typedef enum CUmem_advise_enum {
CU_MEM_ADVISE_SET_READ_MOSTLY = 1,
CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2,
CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3,
CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4,
CU_MEM_ADVISE_SET_ACCESSED_BY = 5,
CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6
} CUmem_advise;
typedef enum CUmem_range_attribute_enum {
CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1,
CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2,
CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3,
CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4,
CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_TYPE = 5,
CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION_ID = 6,
CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_TYPE = 7,
CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION_ID = 8
} CUmem_range_attribute;
typedef enum CUjit_option_enum
{
CU_JIT_MAX_REGISTERS = 0,
CU_JIT_THREADS_PER_BLOCK = 1,
CU_JIT_WALL_TIME = 2,
CU_JIT_INFO_LOG_BUFFER = 3,
CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,
CU_JIT_ERROR_LOG_BUFFER = 5,
CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,
CU_JIT_OPTIMIZATION_LEVEL = 7,
CU_JIT_TARGET_FROM_CUCONTEXT = 8,
CU_JIT_TARGET = 9,
CU_JIT_FALLBACK_STRATEGY = 10,
CU_JIT_GENERATE_DEBUG_INFO = 11,
CU_JIT_LOG_VERBOSE = 12,
CU_JIT_GENERATE_LINE_INFO = 13,
CU_JIT_CACHE_MODE = 14,
CU_JIT_NEW_SM3X_OPT = 15,
CU_JIT_FAST_COMPILE = 16,
CU_JIT_GLOBAL_SYMBOL_NAMES = 17,
CU_JIT_GLOBAL_SYMBOL_ADDRESSES = 18,
CU_JIT_GLOBAL_SYMBOL_COUNT = 19,
CU_JIT_LTO = 20,
CU_JIT_FTZ = 21,
CU_JIT_PREC_DIV = 22,
CU_JIT_PREC_SQRT = 23,
CU_JIT_FMA = 24,
CU_JIT_REFERENCED_KERNEL_NAMES = 25,
CU_JIT_REFERENCED_KERNEL_COUNT = 26,
CU_JIT_REFERENCED_VARIABLE_NAMES = 27,
CU_JIT_REFERENCED_VARIABLE_COUNT = 28,
CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES = 29,
CU_JIT_POSITION_INDEPENDENT_CODE = 30,
CU_JIT_MIN_CTA_PER_SM = 31,
CU_JIT_MAX_THREADS_PER_BLOCK = 32,
CU_JIT_OVERRIDE_DIRECTIVE_VALUES = 33,
CU_JIT_SPLIT_COMPILE = 34,
CU_JIT_BINARY_LOADER_THREAD_COUNT = 35,
CU_JIT_NUM_OPTIONS
} CUjit_option;
/*
* Indicates that compute device class supports accelerated features.
*/
#define CU_COMPUTE_ACCELERATED_TARGET_BASE 0x10000
/*
* Indicates that compute device class supports family features.
*/
#define CU_COMPUTE_FAMILY_TARGET_BASE 0x20000
typedef enum CUjit_target_enum
{
CU_TARGET_COMPUTE_30 = 30,
CU_TARGET_COMPUTE_32 = 32,
CU_TARGET_COMPUTE_35 = 35,
CU_TARGET_COMPUTE_37 = 37,
CU_TARGET_COMPUTE_50 = 50,
CU_TARGET_COMPUTE_52 = 52,
CU_TARGET_COMPUTE_53 = 53,
CU_TARGET_COMPUTE_60 = 60,
CU_TARGET_COMPUTE_61 = 61,
CU_TARGET_COMPUTE_62 = 62,
CU_TARGET_COMPUTE_70 = 70,
CU_TARGET_COMPUTE_72 = 72,
CU_TARGET_COMPUTE_75 = 75,
CU_TARGET_COMPUTE_80 = 80,
CU_TARGET_COMPUTE_86 = 86,
CU_TARGET_COMPUTE_87 = 87,
CU_TARGET_COMPUTE_89 = 89,
CU_TARGET_COMPUTE_90 = 90,
CU_TARGET_COMPUTE_100 = 100,
CU_TARGET_COMPUTE_110 = 110,
CU_TARGET_COMPUTE_102 = 102,
CU_TARGET_COMPUTE_103 = 103,
CU_TARGET_COMPUTE_105 = 105,
CU_TARGET_COMPUTE_107 = 107,
CU_TARGET_COMPUTE_109 = 109,
CU_TARGET_COMPUTE_120 = 120,
CU_TARGET_COMPUTE_121 = 121,
CU_TARGET_COMPUTE_124 = 124,
CU_TARGET_COMPUTE_140 = 140,
CU_TARGET_COMPUTE_90A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_90,
CU_TARGET_COMPUTE_100A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_100,
CU_TARGET_COMPUTE_110A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_110,
CU_TARGET_COMPUTE_102A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_102,
CU_TARGET_COMPUTE_103A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_103,
CU_TARGET_COMPUTE_105A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_105,
CU_TARGET_COMPUTE_107A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_107,
CU_TARGET_COMPUTE_109A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_109,
CU_TARGET_COMPUTE_120A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_120,
CU_TARGET_COMPUTE_121A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_121,
CU_TARGET_COMPUTE_124A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_124,
CU_TARGET_COMPUTE_140A = CU_COMPUTE_ACCELERATED_TARGET_BASE + CU_TARGET_COMPUTE_140,
CU_TARGET_COMPUTE_100F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_100,
CU_TARGET_COMPUTE_110F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_110,
CU_TARGET_COMPUTE_102F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_102,
CU_TARGET_COMPUTE_103F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_103,
CU_TARGET_COMPUTE_105F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_105,
CU_TARGET_COMPUTE_107F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_107,
CU_TARGET_COMPUTE_109F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_109,
CU_TARGET_COMPUTE_120F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_120,
CU_TARGET_COMPUTE_121F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_121,
CU_TARGET_COMPUTE_124F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_124,
CU_TARGET_COMPUTE_140F = CU_COMPUTE_FAMILY_TARGET_BASE + CU_TARGET_COMPUTE_140,
} CUjit_target;
typedef enum CUjit_fallback_enum
{
CU_PREFER_PTX = 0,
CU_PREFER_BINARY
} CUjit_fallback;
typedef enum CUjit_cacheMode_enum
{
CU_JIT_CACHE_OPTION_NONE = 0,
CU_JIT_CACHE_OPTION_CG,
CU_JIT_CACHE_OPTION_CA
} CUjit_cacheMode;
typedef enum CUjitInputType_enum
{
CU_JIT_INPUT_CUBIN = 0,
CU_JIT_INPUT_PTX = 1,
CU_JIT_INPUT_FATBINARY = 2,
CU_JIT_INPUT_OBJECT = 3,
CU_JIT_INPUT_LIBRARY = 4,
CU_JIT_INPUT_NVVM = 5,
CU_JIT_NUM_INPUT_TYPES = 6
} CUjitInputType;
typedef struct CUlinkState_st *CUlinkState;
typedef enum CUgraphicsRegisterFlags_enum {
CU_GRAPHICS_REGISTER_FLAGS_NONE = 0x00,
CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 0x01,
CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 0x02,
CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 0x04,
CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 0x08
} CUgraphicsRegisterFlags;
typedef enum CUgraphicsMapResourceFlags_enum {
CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0x00,
CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01,
CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02
} CUgraphicsMapResourceFlags;
typedef enum CUarray_cubemap_face_enum {
CU_CUBEMAP_FACE_POSITIVE_X = 0x00,
CU_CUBEMAP_FACE_NEGATIVE_X = 0x01,
CU_CUBEMAP_FACE_POSITIVE_Y = 0x02,
CU_CUBEMAP_FACE_NEGATIVE_Y = 0x03,
CU_CUBEMAP_FACE_POSITIVE_Z = 0x04,
CU_CUBEMAP_FACE_NEGATIVE_Z = 0x05
} CUarray_cubemap_face;
typedef enum CUlimit_enum {
CU_LIMIT_STACK_SIZE = 0x00,
CU_LIMIT_PRINTF_FIFO_SIZE = 0x01,
CU_LIMIT_MALLOC_HEAP_SIZE = 0x02,
CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 0x03,
CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 0x04,
CU_LIMIT_MAX_L2_FETCH_GRANULARITY = 0x05,
CU_LIMIT_PERSISTING_L2_CACHE_SIZE = 0x06,
CU_LIMIT_SHMEM_SIZE = 0x07,
CU_LIMIT_CIG_ENABLED = 0x08,
CU_LIMIT_CIG_SHMEM_FALLBACK_ENABLED = 0x09,
CU_LIMIT_PER_BLOCK_MEMORY_SIZE = 0x0A,
CU_LIMIT_MAX
} CUlimit;
typedef enum CUresourcetype_enum {
CU_RESOURCE_TYPE_ARRAY = 0x00,
CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01,
CU_RESOURCE_TYPE_LINEAR = 0x02,
CU_RESOURCE_TYPE_PITCH2D = 0x03
} CUresourcetype;
#ifdef _WIN32
#define CUDA_CB __stdcall
#else
#define CUDA_CB
#endif
typedef void (CUDA_CB *CUhostFn)(void *userData);
typedef enum CUaccessProperty_enum {
CU_ACCESS_PROPERTY_NORMAL = 0,
CU_ACCESS_PROPERTY_STREAMING = 1,
CU_ACCESS_PROPERTY_PERSISTING = 2
} CUaccessProperty;
typedef struct CUaccessPolicyWindow_st {
void *base_ptr;
size_t num_bytes;
float hitRatio;
CUaccessProperty hitProp;
CUaccessProperty missProp;
} CUaccessPolicyWindow_v1;
typedef CUaccessPolicyWindow_v1 CUaccessPolicyWindow;
typedef struct CUDA_KERNEL_NODE_PARAMS_st {
CUfunction func;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
void **kernelParams;
void **extra;
} CUDA_KERNEL_NODE_PARAMS_v1;
typedef struct CUDA_KERNEL_NODE_PARAMS_v2_st {
CUfunction func;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
void **kernelParams;
void **extra;
CUkernel kern;
CUcontext ctx;
} CUDA_KERNEL_NODE_PARAMS_v2;
typedef CUDA_KERNEL_NODE_PARAMS_v2 CUDA_KERNEL_NODE_PARAMS;
typedef struct CUDA_KERNEL_NODE_PARAMS_v3_st {
CUfunction func;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
void **kernelParams;
void **extra;
CUkernel kern;
CUcontext ctx;
CUlaunchAttribute *attrs;
unsigned int numAttrs;
} CUDA_KERNEL_NODE_PARAMS_v3;
typedef struct CUDA_MEMSET_NODE_PARAMS_st {
CUdeviceptr dst;
size_t pitch;
unsigned int value;
unsigned int elementSize;
size_t width;
size_t height;
} CUDA_MEMSET_NODE_PARAMS_v1;
typedef CUDA_MEMSET_NODE_PARAMS_v1 CUDA_MEMSET_NODE_PARAMS;
typedef struct CUDA_MEMSET_NODE_PARAMS_v2_st {
CUdeviceptr dst;
size_t pitch;
unsigned int value;
unsigned int elementSize;
size_t width;
size_t height;
CUcontext ctx;
} CUDA_MEMSET_NODE_PARAMS_v2;
typedef struct CUDA_HOST_NODE_PARAMS_st {
CUhostFn fn;
void* userData;
} CUDA_HOST_NODE_PARAMS_v1;
typedef CUDA_HOST_NODE_PARAMS_v1 CUDA_HOST_NODE_PARAMS;
typedef struct CUDA_HOST_NODE_PARAMS_v2_st {
CUhostFn fn;
void* userData;
unsigned int syncMode;
// preferred context to use for the host task
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_HOST_NODE_PARAMS_v2;
#define CU_GRAPH_COND_ASSIGN_DEFAULT 0x1
typedef enum CUgraphConditionalNodeType_enum {
CU_GRAPH_COND_TYPE_IF = 0,
CU_GRAPH_COND_TYPE_WHILE = 1,
CU_GRAPH_COND_TYPE_SWITCH = 2,
} CUgraphConditionalNodeType;
typedef struct CUDA_CONDITIONAL_NODE_PARAMS {
CUgraphConditionalHandle handle;
CUgraphConditionalNodeType type;
unsigned int size;
CUgraph *phGraph_out;
CUcontext ctx;
} CUDA_CONDITIONAL_NODE_PARAMS;
typedef enum CUgraphNodeType_enum {
CU_GRAPH_NODE_TYPE_KERNEL = 0,
CU_GRAPH_NODE_TYPE_MEMCPY = 1,
CU_GRAPH_NODE_TYPE_MEMSET = 2,
CU_GRAPH_NODE_TYPE_HOST = 3,
CU_GRAPH_NODE_TYPE_GRAPH = 4,
CU_GRAPH_NODE_TYPE_EMPTY = 5,
CU_GRAPH_NODE_TYPE_WAIT_EVENT = 6,
CU_GRAPH_NODE_TYPE_EVENT_RECORD = 7,
CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL = 8,
CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT = 9,
CU_GRAPH_NODE_TYPE_MEM_ALLOC = 10,
CU_GRAPH_NODE_TYPE_MEM_FREE = 11,
CU_GRAPH_NODE_TYPE_BATCH_MEM_OP = 12,
CU_GRAPH_NODE_TYPE_CONDITIONAL = 13,
CU_GRAPH_NODE_TYPE_MEMCPY_BATCH = 14,
CU_GRAPH_NODE_TYPE_MEMCPY_BATCH3D = 15,
CU_GRAPH_NODE_TYPE_SUBGRID_SCHEDULE = 16,
CU_GRAPH_NODE_TYPE_EXTERNAL_ENGINE = 17,
} CUgraphNodeType;
#define CU_GRAPH_NODE_TYPE_RESERVED_16 CU_GRAPH_NODE_TYPE_SUBGRID_SCHEDULE
typedef enum CUgraphDependencyType_enum {
CU_GRAPH_DEPENDENCY_TYPE_DEFAULT = 0,
CU_GRAPH_DEPENDENCY_TYPE_PROGRAMMATIC = 1
} CUgraphDependencyType;
#define CU_GRAPH_KERNEL_NODE_PORT_DEFAULT 0
#define CU_GRAPH_KERNEL_NODE_PORT_PROGRAMMATIC 1
#define CU_GRAPH_KERNEL_NODE_PORT_LAUNCH_ORDER 2
typedef struct CUgraphEdgeData_st {
unsigned char from_port;
unsigned char to_port;
unsigned char type;
unsigned char reserved[5];
} CUgraphEdgeData;
typedef enum CUgraphInstantiateResult_enum
{
CUDA_GRAPH_INSTANTIATE_SUCCESS = 0,
CUDA_GRAPH_INSTANTIATE_ERROR = 1,
CUDA_GRAPH_INSTANTIATE_INVALID_STRUCTURE = 2,
CUDA_GRAPH_INSTANTIATE_NODE_OPERATION_NOT_SUPPORTED = 3,
CUDA_GRAPH_INSTANTIATE_MULTIPLE_CTXS_NOT_SUPPORTED = 4,
CUDA_GRAPH_INSTANTIATE_CONDITIONAL_HANDLE_UNUSED = 5,
} CUgraphInstantiateResult;
typedef struct CUDA_GRAPH_INSTANTIATE_PARAMS_st
{
cuuint64_t flags;
CUstream hUploadStream;
CUgraphNode hErrNode_out;
CUgraphInstantiateResult result_out;
} CUDA_GRAPH_INSTANTIATE_PARAMS;
typedef enum CUsynchronizationPolicy_enum {
CU_SYNC_POLICY_AUTO = 1,
CU_SYNC_POLICY_SPIN = 2,
CU_SYNC_POLICY_YIELD = 3,
CU_SYNC_POLICY_BLOCKING_SYNC = 4
} CUsynchronizationPolicy;
typedef enum CUclusterSchedulingPolicy_enum {
CU_CLUSTER_SCHEDULING_POLICY_DEFAULT = 0,
CU_CLUSTER_SCHEDULING_POLICY_SPREAD = 1,
CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING = 2
, CU_CLUSTER_SCHEDULING_POLICY_RUBIN_DSMEM_LOCALITY = 3
} CUclusterSchedulingPolicy;
typedef enum CUlaunchMemSyncDomain_enum {
CU_LAUNCH_MEM_SYNC_DOMAIN_DEFAULT = 0,
CU_LAUNCH_MEM_SYNC_DOMAIN_REMOTE = 1
} CUlaunchMemSyncDomain;
typedef struct CUlaunchMemSyncDomainMap_st {
unsigned char default_;
unsigned char remote;
} CUlaunchMemSyncDomainMap;
typedef enum CUlaunchAttributePortableClusterMode_enum {
CU_LAUNCH_PORTABLE_CLUSTER_MODE_DEFAULT = 0,
CU_LAUNCH_PORTABLE_CLUSTER_MODE_REQUIRE_PORTABLE = 1,
CU_LAUNCH_PORTABLE_CLUSTER_MODE_ALLOW_NON_PORTABLE = 2,
} CUlaunchAttributePortableClusterMode;
typedef enum CUsharedMemoryMode_enum {
CU_SHARED_MEMORY_MODE_DEFAULT = 0,
CU_SHARED_MEMORY_MODE_REQUIRE_PORTABLE = 1,
CU_SHARED_MEMORY_MODE_ALLOW_NON_PORTABLE = 2,
CU_SHARED_MEMORY_MODE_ALLOW_OVERSIZED_SHARED_MEMORY = 3,
CU_SHARED_MEMORY_MODE_PREFER_OVERSIZED_SHARED_MEMORY = 4,
} CUsharedMemoryMode;
typedef enum CUcommsStatus_enum {
CUDA_COMMS_STATUS_SUCCESS = 0,
CUDA_COMMS_STATUS_WOULD_BLOCK = -1
} CUcommsStatus;
typedef enum CUcommsReductionOp_enum {
CUDA_COMMS_REDUCTION_OP_MIN = 0,
CUDA_COMMS_REDUCTION_OP_MAX = 1,
CUDA_COMMS_REDUCTION_OP_SUM = 2,
CUDA_COMMS_REDUCTION_OP_AND = 3,
CUDA_COMMS_REDUCTION_OP_OR = 4,
CUDA_COMMS_REDUCTION_OP_XOR = 5
} CUcommsReductionOp;
typedef struct CUhostCommunicationsVtable_st {
int version;
int (CUDA_CB *resize)(void *this_, int size);
int (CUDA_CB *get_comm_id)(void *this_, int comm_index, cuuint64_t *id_out);
int (CUDA_CB *barrier)(void *this_, int comm_index, void **request_out);
int (CUDA_CB *allreduce_uint64)(void *this_, int comm_index, const cuuint64_t *sendbuf,
cuuint64_t *recvbuf, int count, CUcommsReductionOp op, void **request_out
);
int (CUDA_CB *test)(void *this_, void **request, int *flag_out);
int (CUDA_CB *testany)(void *this_, int count, void **requests, int *index_out);
int (CUDA_CB *check_async_error)(void *this_);
void (CUDA_CB *retain)(void *this_);
void (CUDA_CB *release)(void *this_);
} CUhostCommunicationsVtable;
typedef struct CUmultiKernelCooperativeDomain_st *CUmultiKernelCooperativeDomain;
typedef enum CUlaunchAttributeID_enum {
CU_LAUNCH_ATTRIBUTE_IGNORE = 0
, CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = 1
, CU_LAUNCH_ATTRIBUTE_COOPERATIVE = 2
, CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = 3
, CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = 4
, CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = 5
, CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = 6
, CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = 7
, CU_LAUNCH_ATTRIBUTE_PRIORITY = 8
, CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP = 9
, CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN = 10
, CU_LAUNCH_ATTRIBUTE_PREFERRED_CLUSTER_DIMENSION = 11
, CU_LAUNCH_ATTRIBUTE_LAUNCH_COMPLETION_EVENT = 12
, CU_LAUNCH_ATTRIBUTE_DEVICE_UPDATABLE_KERNEL_NODE = 13
, CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 14
, CU_LAUNCH_ATTRIBUTE_MULTI_KERNEL_COOPERATIVE_LAUNCH = 15
, CU_LAUNCH_ATTRIBUTE_NVLINK_UTIL_CENTRIC_SCHEDULING = 16
, CU_LAUNCH_ATTRIBUTE_PORTABLE_CLUSTER_SIZE_MODE = 17
, CU_LAUNCH_ATTRIBUTE_SHARED_MEMORY_MODE = 18
#if defined(__CUDA_API_VERSION_INTERNAL) && !defined(__CUDA_API_VERSION_INTERNAL_ODR)
, CU_LAUNCH_ATTRIBUTE_MAX
#endif
} CUlaunchAttributeID;
typedef union CUlaunchAttributeValue_union {
char pad[64]; /* Pad to 64 bytes */
CUaccessPolicyWindow accessPolicyWindow;
int cooperative;
CUsynchronizationPolicy syncPolicy;
struct {
unsigned int x;
unsigned int y;
unsigned int z;
} clusterDim;
CUclusterSchedulingPolicy clusterSchedulingPolicyPreference;
int programmaticStreamSerializationAllowed;
struct {
CUevent event;
int flags;
int triggerAtBlockStart;
} programmaticEvent;
struct {
CUevent event;
int flags;
} launchCompletionEvent;
int priority;
CUlaunchMemSyncDomainMap memSyncDomainMap;
CUlaunchMemSyncDomain memSyncDomain;
struct {
unsigned int x;
unsigned int y;
unsigned int z;
} preferredClusterDim;
struct {
int deviceUpdatable;
CUgraphDeviceNode devNode;
} deviceUpdatableKernelNode;
unsigned int sharedMemCarveout;
struct {
void *commObj;
CUhostCommunicationsVtable *commVtable;
unsigned int localCount;
void *localId;
CUmultiKernelCooperativeDomain domain;
} multiKernelCooperativeLaunch;
unsigned int nvlinkUtilCentricScheduling;
CUlaunchAttributePortableClusterMode portableClusterSizeMode;
CUsharedMemoryMode sharedMemoryMode;
} CUlaunchAttributeValue;
typedef struct CUlaunchAttribute_st {
CUlaunchAttributeID id;
char pad[8 - sizeof(CUlaunchAttributeID)];
CUlaunchAttributeValue value;
} CUlaunchAttribute;
typedef struct CUlaunchConfig_st {
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
CUstream hStream;
CUlaunchAttribute *attrs;
unsigned int numAttrs;
} CUlaunchConfig;
typedef struct CUsubgridWorkerGridDesc_st {
CUkernel kern;
void **kernelParams;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
CUlaunchAttribute *attrs;
unsigned int numAttrs;
char reserved[72];
} CUsubgridWorkerGridDesc;
typedef CUlaunchAttributeID CUkernelNodeAttrID;
#define CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW
#define CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE CU_LAUNCH_ATTRIBUTE_COOPERATIVE
#define CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION
#define CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
#define CU_KERNEL_NODE_ATTRIBUTE_PRIORITY CU_LAUNCH_ATTRIBUTE_PRIORITY
#define CU_KERNEL_NODE_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP
#define CU_KERNEL_NODE_ATTRIBUTE_MEM_SYNC_DOMAIN CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN
#define CU_KERNEL_NODE_ATTRIBUTE_PREFERRED_CLUSTER_DIMENSION CU_LAUNCH_ATTRIBUTE_PREFERRED_CLUSTER_DIMENSION
#define CU_KERNEL_NODE_ATTRIBUTE_DEVICE_UPDATABLE_KERNEL_NODE CU_LAUNCH_ATTRIBUTE_DEVICE_UPDATABLE_KERNEL_NODE
#define CU_KERNEL_NODE_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT CU_LAUNCH_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT
typedef CUlaunchAttributeValue CUkernelNodeAttrValue_v1;
typedef CUkernelNodeAttrValue_v1 CUkernelNodeAttrValue;
typedef enum CUstreamCaptureStatus_enum {
CU_STREAM_CAPTURE_STATUS_NONE = 0,
CU_STREAM_CAPTURE_STATUS_ACTIVE = 1,
CU_STREAM_CAPTURE_STATUS_INVALIDATED = 2
} CUstreamCaptureStatus;
typedef enum CUstreamCaptureMode_enum {
CU_STREAM_CAPTURE_MODE_GLOBAL = 0,
CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1,
CU_STREAM_CAPTURE_MODE_RELAXED = 2
} CUstreamCaptureMode;
typedef CUlaunchAttributeID CUstreamAttrID;
#define CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW
#define CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY
#define CU_STREAM_ATTRIBUTE_PRIORITY CU_LAUNCH_ATTRIBUTE_PRIORITY
#define CU_STREAM_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN_MAP
#define CU_STREAM_ATTRIBUTE_MEM_SYNC_DOMAIN CU_LAUNCH_ATTRIBUTE_MEM_SYNC_DOMAIN
typedef CUlaunchAttributeValue CUstreamAttrValue_v1;
typedef CUstreamAttrValue_v1 CUstreamAttrValue;
typedef enum CUdriverProcAddress_flags_enum {
CU_GET_PROC_ADDRESS_DEFAULT = 0,
CU_GET_PROC_ADDRESS_LEGACY_STREAM = 1 << 0,
CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = 1 << 1
} CUdriverProcAddress_flags;
typedef enum CUdriverProcAddressQueryResult_enum {
CU_GET_PROC_ADDRESS_SUCCESS = 0,
CU_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,
CU_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2
} CUdriverProcAddressQueryResult;
typedef enum CUexecAffinityType_enum {
CU_EXEC_AFFINITY_TYPE_SM_COUNT = 0,
CU_EXEC_AFFINITY_TYPE_MAX
} CUexecAffinityType;
typedef struct CUexecAffinitySmCount_st {
unsigned int val;
} CUexecAffinitySmCount_v1;
typedef CUexecAffinitySmCount_v1 CUexecAffinitySmCount;
typedef struct CUexecAffinityParam_st {
CUexecAffinityType type;
union {
CUexecAffinitySmCount smCount;
} param;
} CUexecAffinityParam_v1;
typedef CUexecAffinityParam_v1 CUexecAffinityParam;
typedef enum CUcigDataType_enum {
CIG_DATA_TYPE_D3D12_COMMAND_QUEUE = 0x1,
CIG_DATA_TYPE_NV_BLOB = 0x2,
} CUcigDataType;
typedef struct CUctxCigParam_st {
CUcigDataType sharedDataType;
void* sharedData;
} CUctxCigParam;
typedef struct CUctxCreateParams_st {
CUexecAffinityParam *execAffinityParams;
int numExecAffinityParams;
CUctxCigParam *cigParams;
} CUctxCreateParams;
typedef enum CUstreamCigDataType_enum {
STREAM_CIG_DATA_TYPE_D3D12_COMMAND_LIST = 0x1,
STREAM_CIG_DATA_TYPE_VULKAN_COMMAND_BUFFER_HANDLE_NV = 0x2,
} CUstreamCigDataType;
typedef struct CUstreamCigParam_st {
CUstreamCigDataType streamSharedDataType;
void* streamSharedData;
} CUstreamCigParam;
typedef struct CUstreamCigCaptureParams_st {
CUstreamCigParam * streamCigParams;
} CUstreamCigCaptureParams;
typedef enum CUlibraryOption_enum
{
CU_LIBRARY_HOST_UNIVERSAL_FUNCTION_AND_DATA_TABLE = 0,
CU_LIBRARY_BINARY_IS_PRESERVED = 1,
CU_LIBRARY_NUM_OPTIONS
} CUlibraryOption;
typedef struct CUlibraryHostUniversalFunctionAndDataTable_st
{
void *functionTable;
size_t functionWindowSize;
void *dataTable;
size_t dataWindowSize;
} CUlibraryHostUniversalFunctionAndDataTable;
typedef enum cudaError_enum {
CUDA_SUCCESS = 0,
CUDA_ERROR_INVALID_VALUE = 1,
CUDA_ERROR_OUT_OF_MEMORY = 2,
CUDA_ERROR_NOT_INITIALIZED = 3,
CUDA_ERROR_DEINITIALIZED = 4,
CUDA_ERROR_PROFILER_DISABLED = 5,
CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6,
CUDA_ERROR_PROFILER_ALREADY_STARTED = 7,
CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8,
CUDA_ERROR_STUB_LIBRARY = 34,
CUDA_ERROR_CALL_REQUIRES_NEWER_DRIVER = 36,
CUDA_ERROR_DEVICE_UNAVAILABLE = 46,
CUDA_ERROR_MULTICAST_RESOURCE_FULL = 47,
CUDA_ERROR_NO_DEVICE = 100,
CUDA_ERROR_INVALID_DEVICE = 101,
CUDA_ERROR_DEVICE_NOT_LICENSED = 102,
CUDA_ERROR_INVALID_IMAGE = 200,
CUDA_ERROR_INVALID_CONTEXT = 201,
CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202,
CUDA_ERROR_MAP_FAILED = 205,
CUDA_ERROR_UNMAP_FAILED = 206,
CUDA_ERROR_ARRAY_IS_MAPPED = 207,
CUDA_ERROR_ALREADY_MAPPED = 208,
CUDA_ERROR_NO_BINARY_FOR_GPU = 209,
CUDA_ERROR_ALREADY_ACQUIRED = 210,
CUDA_ERROR_NOT_MAPPED = 211,
CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212,
CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213,
CUDA_ERROR_ECC_UNCORRECTABLE = 214,
CUDA_ERROR_UNSUPPORTED_LIMIT = 215,
CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216,
CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217,
CUDA_ERROR_INVALID_PTX = 218,
CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219,
CUDA_ERROR_NVLINK_UNCORRECTABLE = 220,
CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221,
CUDA_ERROR_UNSUPPORTED_PTX_VERSION = 222,
CUDA_ERROR_JIT_COMPILATION_DISABLED = 223,
CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY = 224,
CUDA_ERROR_UNSUPPORTED_DEVSIDE_SYNC = 225,
CUDA_ERROR_CONTAINED = 226,
CUDA_ERROR_INSUFFICIENT_LOADER_VERSION = 227,
CUDA_ERROR_INVALID_SOURCE = 300,
CUDA_ERROR_FILE_NOT_FOUND = 301,
CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302,
CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303,
CUDA_ERROR_OPERATING_SYSTEM = 304,
CUDA_ERROR_INVALID_HANDLE = 400,
CUDA_ERROR_ILLEGAL_STATE = 401,
CUDA_ERROR_LOSSY_QUERY = 402,
CUDA_ERROR_NOT_FOUND = 500,
CUDA_ERROR_NOT_READY = 600,
CUDA_ERROR_ILLEGAL_ADDRESS = 700,
CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701,
CUDA_ERROR_LAUNCH_TIMEOUT = 702,
CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703,
CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704,
CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705,
CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708,
CUDA_ERROR_CONTEXT_IS_DESTROYED = 709,
CUDA_ERROR_ASSERT = 710,
CUDA_ERROR_TOO_MANY_PEERS = 711,
CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712,
CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713,
CUDA_ERROR_HARDWARE_STACK_ERROR = 714,
CUDA_ERROR_ILLEGAL_INSTRUCTION = 715,
CUDA_ERROR_MISALIGNED_ADDRESS = 716,
CUDA_ERROR_INVALID_ADDRESS_SPACE = 717,
CUDA_ERROR_INVALID_PC = 718,
CUDA_ERROR_LAUNCH_FAILED = 719,
CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720,
CUDA_ERROR_TENSOR_MEMORY_LEAK = 721,
CUDA_ERROR_NOT_PERMITTED = 800,
CUDA_ERROR_NOT_SUPPORTED = 801,
CUDA_ERROR_SYSTEM_NOT_READY = 802,
CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803,
CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804,
CUDA_ERROR_MPS_CONNECTION_FAILED = 805,
CUDA_ERROR_MPS_RPC_FAILURE = 806,
CUDA_ERROR_MPS_SERVER_NOT_READY = 807,
CUDA_ERROR_MPS_MAX_CLIENTS_REACHED = 808,
CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED = 809,
CUDA_ERROR_MPS_CLIENT_TERMINATED = 810,
CUDA_ERROR_CDP_NOT_SUPPORTED = 811,
CUDA_ERROR_CDP_VERSION_MISMATCH = 812,
CUDA_ERROR_COMMS_FAILURE = 813,
CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900,
CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901,
CUDA_ERROR_STREAM_CAPTURE_MERGE = 902,
CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903,
CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904,
CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905,
CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906,
CUDA_ERROR_CAPTURED_EVENT = 907,
CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908,
CUDA_ERROR_TIMEOUT = 909,
CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = 910,
CUDA_ERROR_EXTERNAL_DEVICE = 911,
CUDA_ERROR_INVALID_CLUSTER_SIZE = 912,
CUDA_ERROR_FUNCTION_NOT_LOADED = 913,
CUDA_ERROR_INVALID_RESOURCE_TYPE = 914,
CUDA_ERROR_INVALID_RESOURCE_CONFIGURATION = 915,
CUDA_ERROR_KEY_ROTATION = 916,
CUDA_ERROR_STREAM_DETACHED = 917,
CUDA_ERROR_GRAPH_RECAPTURE_FAILURE = 918,
CUDA_ERROR_FABRIC_NOT_READY = 919,
CUDA_ERROR_UNKNOWN = 999
} CUresult;
typedef enum CUdevice_P2PAttribute_enum {
CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 0x01,
CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 0x02,
CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 0x03,
CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = 0x04,
CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED = 0x04
,
CU_DEVICE_P2P_ATTRIBUTE_ONLY_PARTIAL_NATIVE_ATOMIC_SUPPORTED = 0x05
} CUdevice_P2PAttribute;
typedef void (CUDA_CB *CUstreamCallback)(CUstream hStream, CUresult status, void *userData);
typedef size_t (CUDA_CB *CUoccupancyB2DSize)(int blockSize);
#define CU_MEMHOSTALLOC_PORTABLE 0x01
#define CU_MEMHOSTALLOC_DEVICEMAP 0x02
#define CU_MEMHOSTALLOC_WRITECOMBINED 0x04
#define CU_MEMHOSTREGISTER_PORTABLE 0x01
#define CU_MEMHOSTREGISTER_DEVICEMAP 0x02
#define CU_MEMHOSTREGISTER_IOMEMORY 0x04
#define CU_MEMHOSTREGISTER_READ_ONLY 0x08
typedef struct CUDA_MEMCPY2D_st {
size_t srcXInBytes;
size_t srcY;
CUmemorytype srcMemoryType;
const void *srcHost;
CUdeviceptr srcDevice;
CUarray srcArray;
size_t srcPitch;
size_t dstXInBytes;
size_t dstY;
CUmemorytype dstMemoryType;
void *dstHost;
CUdeviceptr dstDevice;
CUarray dstArray;
size_t dstPitch;
size_t WidthInBytes;
size_t Height;
} CUDA_MEMCPY2D_v2;
typedef CUDA_MEMCPY2D_v2 CUDA_MEMCPY2D;
typedef struct CUDA_MEMCPY3D_st {
size_t srcXInBytes;
size_t srcY;
size_t srcZ;
size_t srcLOD;
CUmemorytype srcMemoryType;
const void *srcHost;
CUdeviceptr srcDevice;
CUarray srcArray;
void *reserved0;
size_t srcPitch;
size_t srcHeight;
size_t dstXInBytes;
size_t dstY;
size_t dstZ;
size_t dstLOD;
CUmemorytype dstMemoryType;
void *dstHost;
CUdeviceptr dstDevice;
CUarray dstArray;
void *reserved1;
size_t dstPitch;
size_t dstHeight;
size_t WidthInBytes;
size_t Height;
size_t Depth;
} CUDA_MEMCPY3D_v2;
typedef CUDA_MEMCPY3D_v2 CUDA_MEMCPY3D;
typedef struct CUDA_MEMCPY3D_PEER_st {
size_t srcXInBytes;
size_t srcY;
size_t srcZ;
size_t srcLOD;
CUmemorytype srcMemoryType;
const void *srcHost;
CUdeviceptr srcDevice;
CUarray srcArray;
CUcontext srcContext;
size_t srcPitch;
size_t srcHeight;
size_t dstXInBytes;
size_t dstY;
size_t dstZ;
size_t dstLOD;
CUmemorytype dstMemoryType;
void *dstHost;
CUdeviceptr dstDevice;
CUarray dstArray;
CUcontext dstContext;
size_t dstPitch;
size_t dstHeight;
size_t WidthInBytes;
size_t Height;
size_t Depth;
} CUDA_MEMCPY3D_PEER_v1;
typedef CUDA_MEMCPY3D_PEER_v1 CUDA_MEMCPY3D_PEER;
typedef struct CUDA_MEMCPY_NODE_PARAMS_st {
int flags;
int reserved;
CUcontext copyCtx;
CUDA_MEMCPY3D copyParams;
} CUDA_MEMCPY_NODE_PARAMS;
typedef struct CUDA_ARRAY_DESCRIPTOR_st
{
size_t Width;
size_t Height;
CUarray_format Format;
unsigned int NumChannels;
} CUDA_ARRAY_DESCRIPTOR_v2;
typedef CUDA_ARRAY_DESCRIPTOR_v2 CUDA_ARRAY_DESCRIPTOR;
typedef struct CUDA_ARRAY3D_DESCRIPTOR_st
{
size_t Width;
size_t Height;
size_t Depth;
CUarray_format Format;
unsigned int NumChannels;
unsigned int Flags;
} CUDA_ARRAY3D_DESCRIPTOR_v2;
typedef CUDA_ARRAY3D_DESCRIPTOR_v2 CUDA_ARRAY3D_DESCRIPTOR;
#define CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL 0x1
typedef struct CUDA_ARRAY_SPARSE_PROPERTIES_st {
struct {
unsigned int width;
unsigned int height;
unsigned int depth;
} tileExtent;
unsigned int miptailFirstLevel;
unsigned long long miptailSize;
unsigned int flags;
unsigned int reserved[4];
} CUDA_ARRAY_SPARSE_PROPERTIES_v1;
typedef CUDA_ARRAY_SPARSE_PROPERTIES_v1 CUDA_ARRAY_SPARSE_PROPERTIES;
typedef struct CUDA_ARRAY_MEMORY_REQUIREMENTS_st {
size_t size;
size_t alignment;
unsigned int reserved[4];
} CUDA_ARRAY_MEMORY_REQUIREMENTS_v1;
typedef CUDA_ARRAY_MEMORY_REQUIREMENTS_v1 CUDA_ARRAY_MEMORY_REQUIREMENTS;
typedef struct CUDA_RESOURCE_DESC_st
{
CUresourcetype resType;
union {
struct {
CUarray hArray;
} array;
struct {
CUmipmappedArray hMipmappedArray;
} mipmap;
struct {
CUdeviceptr devPtr;
CUarray_format format;
unsigned int numChannels;
size_t sizeInBytes;
} linear;
struct {
CUdeviceptr devPtr;
CUarray_format format;
unsigned int numChannels;
size_t width;
size_t height;
size_t pitchInBytes;
} pitch2D;
struct {
int reserved[32];
} reserved;
} res;
unsigned int flags;
} CUDA_RESOURCE_DESC_v1;
typedef CUDA_RESOURCE_DESC_v1 CUDA_RESOURCE_DESC;
typedef struct CUDA_TEXTURE_DESC_st {
CUaddress_mode addressMode[3];
CUfilter_mode filterMode;
unsigned int flags;
unsigned int maxAnisotropy;
CUfilter_mode mipmapFilterMode;
float mipmapLevelBias;
float minMipmapLevelClamp;
float maxMipmapLevelClamp;
float borderColor[4];
int reserved[12];
} CUDA_TEXTURE_DESC_v1;
typedef CUDA_TEXTURE_DESC_v1 CUDA_TEXTURE_DESC;
typedef enum CUresourceViewFormat_enum
{
CU_RES_VIEW_FORMAT_NONE = 0x00,
CU_RES_VIEW_FORMAT_UINT_1X8 = 0x01,
CU_RES_VIEW_FORMAT_UINT_2X8 = 0x02,
CU_RES_VIEW_FORMAT_UINT_4X8 = 0x03,
CU_RES_VIEW_FORMAT_SINT_1X8 = 0x04,
CU_RES_VIEW_FORMAT_SINT_2X8 = 0x05,
CU_RES_VIEW_FORMAT_SINT_4X8 = 0x06,
CU_RES_VIEW_FORMAT_UINT_1X16 = 0x07,
CU_RES_VIEW_FORMAT_UINT_2X16 = 0x08,
CU_RES_VIEW_FORMAT_UINT_4X16 = 0x09,
CU_RES_VIEW_FORMAT_SINT_1X16 = 0x0a,
CU_RES_VIEW_FORMAT_SINT_2X16 = 0x0b,
CU_RES_VIEW_FORMAT_SINT_4X16 = 0x0c,
CU_RES_VIEW_FORMAT_UINT_1X32 = 0x0d,
CU_RES_VIEW_FORMAT_UINT_2X32 = 0x0e,
CU_RES_VIEW_FORMAT_UINT_4X32 = 0x0f,
CU_RES_VIEW_FORMAT_SINT_1X32 = 0x10,
CU_RES_VIEW_FORMAT_SINT_2X32 = 0x11,
CU_RES_VIEW_FORMAT_SINT_4X32 = 0x12,
CU_RES_VIEW_FORMAT_FLOAT_1X16 = 0x13,
CU_RES_VIEW_FORMAT_FLOAT_2X16 = 0x14,
CU_RES_VIEW_FORMAT_FLOAT_4X16 = 0x15,
CU_RES_VIEW_FORMAT_FLOAT_1X32 = 0x16,
CU_RES_VIEW_FORMAT_FLOAT_2X32 = 0x17,
CU_RES_VIEW_FORMAT_FLOAT_4X32 = 0x18,
CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 0x19,
CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 0x1a,
CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 0x1b,
CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 0x1c,
CU_RES_VIEW_FORMAT_SIGNED_BC4 = 0x1d,
CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 0x1e,
CU_RES_VIEW_FORMAT_SIGNED_BC5 = 0x1f,
CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 0x20,
CU_RES_VIEW_FORMAT_SIGNED_BC6H = 0x21,
CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 0x22
} CUresourceViewFormat;
typedef struct CUDA_RESOURCE_VIEW_DESC_st
{
CUresourceViewFormat format;
size_t width;
size_t height;
size_t depth;
unsigned int firstMipmapLevel;
unsigned int lastMipmapLevel;
unsigned int firstLayer;
unsigned int lastLayer;
unsigned int reserved[16];
} CUDA_RESOURCE_VIEW_DESC_v1;
typedef CUDA_RESOURCE_VIEW_DESC_v1 CUDA_RESOURCE_VIEW_DESC;
#define CU_TENSOR_MAP_NUM_QWORDS 16
typedef struct CUtensorMap_st {
#if defined(__cplusplus) && (__cplusplus >= 201103L)
alignas(128)
#elif __STDC_VERSION__ >= 201112L
_Alignas(128)
#endif
cuuint64_t opaque[CU_TENSOR_MAP_NUM_QWORDS];
} CUtensorMap;
typedef enum CUtensorMapDataType_enum {
CU_TENSOR_MAP_DATA_TYPE_UINT8 = 0,
CU_TENSOR_MAP_DATA_TYPE_UINT16,
CU_TENSOR_MAP_DATA_TYPE_UINT32,
CU_TENSOR_MAP_DATA_TYPE_INT32,
CU_TENSOR_MAP_DATA_TYPE_UINT64,
CU_TENSOR_MAP_DATA_TYPE_INT64,
CU_TENSOR_MAP_DATA_TYPE_FLOAT16,
CU_TENSOR_MAP_DATA_TYPE_FLOAT32,
CU_TENSOR_MAP_DATA_TYPE_FLOAT64,
CU_TENSOR_MAP_DATA_TYPE_BFLOAT16,
CU_TENSOR_MAP_DATA_TYPE_FLOAT32_FTZ,
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32,
CU_TENSOR_MAP_DATA_TYPE_TFLOAT32_FTZ,
CU_TENSOR_MAP_DATA_TYPE_16U4_ALIGN8B,
CU_TENSOR_MAP_DATA_TYPE_16U4_ALIGN16B,
CU_TENSOR_MAP_DATA_TYPE_16U6_ALIGN16B
} CUtensorMapDataType;
typedef enum CUtensorMapInterleave_enum {
CU_TENSOR_MAP_INTERLEAVE_NONE = 0,
CU_TENSOR_MAP_INTERLEAVE_16B,
CU_TENSOR_MAP_INTERLEAVE_32B
} CUtensorMapInterleave;
typedef enum CUtensorMapSwizzle_enum {
CU_TENSOR_MAP_SWIZZLE_NONE = 0,
CU_TENSOR_MAP_SWIZZLE_32B,
CU_TENSOR_MAP_SWIZZLE_64B,
CU_TENSOR_MAP_SWIZZLE_128B,
CU_TENSOR_MAP_SWIZZLE_128B_ATOM_32B,
CU_TENSOR_MAP_SWIZZLE_128B_ATOM_32B_FLIP_8B,
CU_TENSOR_MAP_SWIZZLE_128B_ATOM_64B,
CU_TENSOR_MAP_SWIZZLE_96B,
} CUtensorMapSwizzle;
typedef enum CUtensorMapL2promotion_enum {
CU_TENSOR_MAP_L2_PROMOTION_NONE = 0,
CU_TENSOR_MAP_L2_PROMOTION_L2_64B,
CU_TENSOR_MAP_L2_PROMOTION_L2_128B,
CU_TENSOR_MAP_L2_PROMOTION_L2_256B
} CUtensorMapL2promotion;
typedef enum CUtensorMapFloatOOBfill_enum {
CU_TENSOR_MAP_FLOAT_OOB_FILL_NONE = 0,
CU_TENSOR_MAP_FLOAT_OOB_FILL_NAN_REQUEST_ZERO_FMA
} CUtensorMapFloatOOBfill;
typedef enum CUtensorMapIm2ColWideMode_enum {
CU_TENSOR_MAP_IM2COL_WIDE_MODE_W = 0,
CU_TENSOR_MAP_IM2COL_WIDE_MODE_W128
} CUtensorMapIm2ColWideMode;
typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st {
unsigned long long p2pToken;
unsigned int vaSpaceToken;
} CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1;
typedef CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1 CUDA_POINTER_ATTRIBUTE_P2P_TOKENS;
typedef enum CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum {
CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE = 0x0,
CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ = 0x1,
CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE = 0x3
} CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS;
typedef struct CUDA_LAUNCH_PARAMS_st {
CUfunction function;
unsigned int gridDimX;
unsigned int gridDimY;
unsigned int gridDimZ;
unsigned int blockDimX;
unsigned int blockDimY;
unsigned int blockDimZ;
unsigned int sharedMemBytes;
CUstream hStream;
void **kernelParams;
} CUDA_LAUNCH_PARAMS_v1;
typedef CUDA_LAUNCH_PARAMS_v1 CUDA_LAUNCH_PARAMS;
typedef enum CUexternalMemoryHandleType_enum {
CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = 1,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = 2,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = 4,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = 5,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE = 6,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = 7,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = 8,
CU_EXTERNAL_MEMORY_HANDLE_TYPE_DMABUF_FD = 9
} CUexternalMemoryHandleType;
#define CUDA_EXTERNAL_MEMORY_DEDICATED 0x1
#define CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC 0x01
#define CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC 0x02
#define CUDA_NVSCISYNC_ATTR_SIGNAL 0x1
#define CUDA_NVSCISYNC_ATTR_WAIT 0x2
typedef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
CUexternalMemoryHandleType type;
union {
int fd;
struct {
void *handle;
const void *name;
} win32;
const void *nvSciBufObject;
} handle;
unsigned long long size;
unsigned int flags;
unsigned int reserved[16];
} CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1;
typedef CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1 CUDA_EXTERNAL_MEMORY_HANDLE_DESC;
typedef struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
unsigned long long offset;
unsigned long long size;
unsigned int flags;
unsigned int reserved[16];
} CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1;
typedef CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1 CUDA_EXTERNAL_MEMORY_BUFFER_DESC;
typedef struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
unsigned long long offset;
CUDA_ARRAY3D_DESCRIPTOR arrayDesc;
unsigned int numLevels;
unsigned int reserved[16];
} CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1;
typedef CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1 CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC;
typedef enum CUexternalSemaphoreHandleType_enum {
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = 4,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE = 5,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC = 6,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX = 7,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = 8,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD = 9,
CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = 10
} CUexternalSemaphoreHandleType;
typedef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
CUexternalSemaphoreHandleType type;
union {
int fd;
struct {
void *handle;
const void *name;
} win32;
const void* nvSciSyncObj;
} handle;
unsigned int flags;
unsigned int reserved[16];
} CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1;
typedef CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC;
typedef struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st {
struct {
struct {
unsigned long long value;
} fence;
union {
void *fence;
unsigned long long reserved;
} nvSciSync;
struct {
unsigned long long key;
} keyedMutex;
unsigned int reserved[12];
} params;
unsigned int flags;
unsigned int reserved[16];
} CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1;
typedef CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS;
typedef struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st {
struct {
struct {
unsigned long long value;
} fence;
union {
void *fence;
unsigned long long reserved;
} nvSciSync;
struct {
unsigned long long key;
unsigned int timeoutMs;
} keyedMutex;
unsigned int reserved[10];
} params;
unsigned int flags;
unsigned int reserved[16];
} CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1;
typedef CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1 CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS;
typedef struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st {
CUexternalSemaphore* extSemArray;
const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* paramsArray;
unsigned int numExtSems;
} CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1;
typedef CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1 CUDA_EXT_SEM_SIGNAL_NODE_PARAMS;
typedef struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2_st {
CUexternalSemaphore* extSemArray;
const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* paramsArray;
unsigned int numExtSems;
// preferred context to use for the semaphore signal task
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2;
typedef struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st {
CUexternalSemaphore* extSemArray;
const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* paramsArray;
unsigned int numExtSems;
} CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1;
typedef CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1 CUDA_EXT_SEM_WAIT_NODE_PARAMS;
typedef struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2_st {
CUexternalSemaphore* extSemArray;
const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* paramsArray;
unsigned int numExtSems;
// preferred context to use for the semaphore wait task
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2;
typedef unsigned long long CUmemGenericAllocationHandle_v1;
typedef CUmemGenericAllocationHandle_v1 CUmemGenericAllocationHandle;
typedef enum CUmemAllocationHandleType_enum {
CU_MEM_HANDLE_TYPE_NONE = 0x0,
CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = 0x1,
CU_MEM_HANDLE_TYPE_WIN32 = 0x2,
CU_MEM_HANDLE_TYPE_WIN32_KMT = 0x4,
CU_MEM_HANDLE_TYPE_FABRIC = 0x8,
CU_MEM_HANDLE_TYPE_MAX = 0x7FFFFFFF
} CUmemAllocationHandleType;
typedef enum CUmemAccess_flags_enum {
CU_MEM_ACCESS_FLAGS_PROT_NONE = 0x0,
CU_MEM_ACCESS_FLAGS_PROT_READ = 0x1,
CU_MEM_ACCESS_FLAGS_PROT_READWRITE = 0x3,
CU_MEM_ACCESS_FLAGS_PROT_MAX = 0x7FFFFFFF
} CUmemAccess_flags;
typedef enum CUmemLocationType_enum {
CU_MEM_LOCATION_TYPE_INVALID = 0x0,
CU_MEM_LOCATION_TYPE_NONE = 0x0,
CU_MEM_LOCATION_TYPE_DEVICE = 0x1,
CU_MEM_LOCATION_TYPE_HOST = 0x2,
CU_MEM_LOCATION_TYPE_HOST_NUMA = 0x3,
CU_MEM_LOCATION_TYPE_HOST_NUMA_CURRENT = 0x4,
CU_MEM_LOCATION_TYPE_INVISIBLE = 0x5,
CU_MEM_LOCATION_TYPE_DEVICE_LOCALITY_DOMAIN = 0x6,
CU_MEM_LOCATION_TYPE_MAX = 0x7FFFFFFF
} CUmemLocationType;
typedef enum CUmemAllocationType_enum {
CU_MEM_ALLOCATION_TYPE_INVALID = 0x0,
CU_MEM_ALLOCATION_TYPE_PINNED = 0x1,
CU_MEM_ALLOCATION_TYPE_MANAGED = 0x2,
CU_MEM_ALLOCATION_TYPE_MAX = 0x7FFFFFFF
} CUmemAllocationType;
typedef enum CUmemAllocationGranularity_flags_enum {
CU_MEM_ALLOC_GRANULARITY_MINIMUM = 0x0,
CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = 0x1
} CUmemAllocationGranularity_flags;
typedef enum CUmemRangeHandleType_enum
{
CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD = 0x1,
CU_MEM_RANGE_HANDLE_TYPE_MAX = 0x7FFFFFFF
} CUmemRangeHandleType;
typedef enum CUmemRangeFlags_enum {
CU_MEM_RANGE_FLAG_DMA_BUF_MAPPING_TYPE_PCIE = 0x1
} CUmemRangeFlags;
typedef enum CUarraySparseSubresourceType_enum {
CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = 0,
CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = 1
} CUarraySparseSubresourceType;
typedef enum CUmemOperationType_enum {
CU_MEM_OPERATION_TYPE_MAP = 1,
CU_MEM_OPERATION_TYPE_UNMAP = 2
} CUmemOperationType;
typedef enum CUmemHandleType_enum {
CU_MEM_HANDLE_TYPE_GENERIC = 0
} CUmemHandleType;
typedef struct CUarrayMapInfo_st {
CUresourcetype resourceType;
union {
CUmipmappedArray mipmap;
CUarray array;
} resource;
CUarraySparseSubresourceType subresourceType;
union {
struct {
unsigned int level;
unsigned int layer;
unsigned int offsetX;
unsigned int offsetY;
unsigned int offsetZ;
unsigned int extentWidth;
unsigned int extentHeight;
unsigned int extentDepth;
} sparseLevel;
struct {
unsigned int layer;
unsigned long long offset;
unsigned long long size;
} miptail;
} subresource;
CUmemOperationType memOperationType;
CUmemHandleType memHandleType;
union {
CUmemGenericAllocationHandle memHandle;
} memHandle;
unsigned long long offset;
unsigned int deviceBitMask;
unsigned int flags;
unsigned int reserved[2];
} CUarrayMapInfo_v1;
typedef CUarrayMapInfo_v1 CUarrayMapInfo;
typedef struct CUmemLocation_st {
CUmemLocationType type;
union {
int id;
struct {
unsigned char deviceId;
unsigned char localityDomainId;
} localized;
};
} CUmemLocation_v1;
typedef CUmemLocation_v1 CUmemLocation;
typedef enum CUmemAllocationCompType_enum {
CU_MEM_ALLOCATION_COMP_NONE = 0x0,
CU_MEM_ALLOCATION_COMP_GENERIC = 0x1
} CUmemAllocationCompType;
#define CU_MEM_CREATE_USAGE_TILE_POOL 0x1
#define CU_MEM_CREATE_USAGE_HW_DECOMPRESS 0x2
#define CU_MEM_CREATE_USAGE_GPU_DIRECT_RDMA_OVER_PCIE 0x4
typedef struct CUmemAllocationProp_st {
CUmemAllocationType type;
CUmemAllocationHandleType requestedHandleTypes;
CUmemLocation location;
void *win32HandleMetaData;
struct {
unsigned char compressionType;
unsigned char gpuDirectRDMACapable;
unsigned short usage;
unsigned char reserved[4];
} allocFlags;
} CUmemAllocationProp_v1;
typedef CUmemAllocationProp_v1 CUmemAllocationProp;
typedef enum CUmulticastGranularity_flags_enum {
CU_MULTICAST_GRANULARITY_MINIMUM = 0x0,
CU_MULTICAST_GRANULARITY_RECOMMENDED = 0x1
} CUmulticastGranularity_flags;
typedef struct CUmulticastObjectProp_st {
unsigned int numDevices;
size_t size;
unsigned long long handleTypes;
unsigned long long flags;
} CUmulticastObjectProp_v1;
typedef CUmulticastObjectProp_v1 CUmulticastObjectProp;
typedef struct CUmemAccessDesc_st {
CUmemLocation location;
CUmemAccess_flags flags;
} CUmemAccessDesc_v1;
typedef CUmemAccessDesc_v1 CUmemAccessDesc;
typedef enum CUgraphExecUpdateResult_enum {
CU_GRAPH_EXEC_UPDATE_SUCCESS = 0x0,
CU_GRAPH_EXEC_UPDATE_ERROR = 0x1,
CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED = 0x2,
CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED = 0x3,
CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED = 0x4,
CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED = 0x5,
CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED = 0x6,
CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE = 0x7,
CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED = 0x8
} CUgraphExecUpdateResult;
typedef struct CUgraphExecUpdateResultInfo_st {
CUgraphExecUpdateResult result;
CUgraphNode errorNode;
CUgraphNode errorFromNode;
} CUgraphExecUpdateResultInfo_v1;
typedef CUgraphExecUpdateResultInfo_v1 CUgraphExecUpdateResultInfo;
typedef enum CUmemPool_attribute_enum {
CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES = 1,
CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,
CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,
CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,
CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,
CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,
CU_MEMPOOL_ATTR_USED_MEM_CURRENT,
CU_MEMPOOL_ATTR_USED_MEM_HIGH,
CU_MEMPOOL_ATTR_ALLOCATION_TYPE,
CU_MEMPOOL_ATTR_EXPORT_HANDLE_TYPES,
CU_MEMPOOL_ATTR_LOCATION_ID,
CU_MEMPOOL_ATTR_LOCATION_TYPE,
CU_MEMPOOL_ATTR_MAX_POOL_SIZE,
CU_MEMPOOL_ATTR_HW_DECOMPRESS_ENABLED,
CU_MEMPOOL_ATTR_LOCALITY_DOMAIN_ID,
} CUmemPool_attribute;
#define CU_MEM_POOL_CREATE_USAGE_HW_DECOMPRESS 0x2
typedef struct CUmemPoolProps_st {
CUmemAllocationType allocType;
CUmemAllocationHandleType handleTypes;
CUmemLocation location;
void *win32SecurityAttributes;
size_t maxSize;
unsigned short usage;
unsigned char gpuDirectRDMACapable;
unsigned char reserved[53];
} CUmemPoolProps_v1;
typedef CUmemPoolProps_v1 CUmemPoolProps;
typedef struct CUmemPoolPtrExportData_st {
unsigned char reserved[64];
} CUmemPoolPtrExportData_v1;
typedef CUmemPoolPtrExportData_v1 CUmemPoolPtrExportData;
typedef enum CUmemcpyFlags_enum {
CU_MEMCPY_FLAG_DEFAULT = 0x0,
CU_MEMCPY_FLAG_PREFER_OVERLAP_WITH_COMPUTE = 0x1
} CUmemcpyFlags;
typedef enum CUmemcpySrcAccessOrder_enum {
CU_MEMCPY_SRC_ACCESS_ORDER_INVALID = 0x0,
CU_MEMCPY_SRC_ACCESS_ORDER_STREAM = 0x1,
CU_MEMCPY_SRC_ACCESS_ORDER_DURING_API_CALL = 0x2,
CU_MEMCPY_SRC_ACCESS_ORDER_ANY = 0x3,
CU_MEMCPY_SRC_ACCESS_ORDER_MAX = 0x7FFFFFFF
} CUmemcpySrcAccessOrder;
typedef struct CUmemcpyAttributes_st {
CUmemcpySrcAccessOrder srcAccessOrder;
CUmemLocation srcLocHint;
CUmemLocation dstLocHint;
unsigned int flags;
} CUmemcpyAttributes_v1;
typedef CUmemcpyAttributes_v1 CUmemcpyAttributes;
typedef enum CUmemcpy3DOperandType_enum {
CU_MEMCPY_OPERAND_TYPE_POINTER = 0x1,
CU_MEMCPY_OPERAND_TYPE_ARRAY = 0x2,
CU_MEMCPY_OPERAND_TYPE_MAX = 0x7FFFFFFF
} CUmemcpy3DOperandType;
typedef struct CUoffset3D_st {
size_t x;
size_t y;
size_t z;
} CUoffset3D_v1;
typedef CUoffset3D_v1 CUoffset3D;
typedef struct CUextent3D_st {
size_t width;
size_t height;
size_t depth;
} CUextent3D_v1;
typedef CUextent3D_v1 CUextent3D;
typedef struct CUmemcpy3DOperand_st {
CUmemcpy3DOperandType type;
union {
struct {
CUdeviceptr ptr;
size_t rowLength;
size_t layerHeight;
CUmemLocation locHint;
} ptr;
struct {
CUarray array;
CUoffset3D offset;
} array;
} op;
} CUmemcpy3DOperand_v1;
typedef CUmemcpy3DOperand_v1 CUmemcpy3DOperand;
typedef struct CUDA_MEMCPY3D_BATCH_OP_st {
CUmemcpy3DOperand src;
CUmemcpy3DOperand dst;
CUextent3D extent;
CUmemcpySrcAccessOrder srcAccessOrder;
unsigned int flags;
} CUDA_MEMCPY3D_BATCH_OP_v1;
typedef CUDA_MEMCPY3D_BATCH_OP_v1 CUDA_MEMCPY3D_BATCH_OP;
typedef struct CUDA_MEM_ALLOC_NODE_PARAMS_v1_st {
CUmemPoolProps poolProps;
const CUmemAccessDesc *accessDescs;
size_t accessDescCount;
size_t bytesize;
CUdeviceptr dptr;
} CUDA_MEM_ALLOC_NODE_PARAMS_v1;
typedef CUDA_MEM_ALLOC_NODE_PARAMS_v1 CUDA_MEM_ALLOC_NODE_PARAMS;
typedef struct CUDA_MEM_ALLOC_NODE_PARAMS_v2_st {
CUmemPoolProps poolProps;
const CUmemAccessDesc *accessDescs;
size_t accessDescCount;
size_t bytesize;
CUdeviceptr dptr;
} CUDA_MEM_ALLOC_NODE_PARAMS_v2;
typedef struct CUDA_MEM_FREE_NODE_PARAMS_st {
CUdeviceptr dptr;
} CUDA_MEM_FREE_NODE_PARAMS;
typedef enum CUgraphMem_attribute_enum {
CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,
CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,
CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,
CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH
} CUgraphMem_attribute;
typedef enum CUgraphChildGraphNodeOwnership_enum {
CU_GRAPH_CHILD_GRAPH_OWNERSHIP_CLONE = 0,
CU_GRAPH_CHILD_GRAPH_OWNERSHIP_MOVE = 1,
CU_GRAPH_CHILD_GRAPH_OWNERSHIP_INVALID = -1,
} CUgraphChildGraphNodeOwnership;
typedef struct CUDA_CHILD_GRAPH_NODE_PARAMS_st {
CUgraph graph;
CUgraphChildGraphNodeOwnership ownership;
} CUDA_CHILD_GRAPH_NODE_PARAMS;
typedef struct CUDA_EVENT_RECORD_NODE_PARAMS_st {
CUevent event;
// preferred context to use for the event record
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_EVENT_RECORD_NODE_PARAMS;
typedef struct CUDA_EVENT_WAIT_NODE_PARAMS_st {
CUevent event;
} CUDA_EVENT_WAIT_NODE_PARAMS;
typedef struct CUDA_MEMCPY_BATCH_NODE_PARAMS_V1_st {
size_t count;
CUdeviceptr *dsts;
CUdeviceptr *srcs;
size_t *sizes;
CUmemcpyAttributes *attrs;
size_t *attrsIdxs;
size_t numAttrs;
// preferred context to use for the copies
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_MEMCPY_BATCH_NODE_PARAMS_V1;
typedef CUDA_MEMCPY_BATCH_NODE_PARAMS_V1 CUDA_MEMCPY_BATCH_NODE_PARAMS;
typedef struct CUDA_MEMCPY_BATCH3D_NODE_PARAMS_V1_st {
unsigned long long flags;
size_t numOps;
CUDA_MEMCPY3D_BATCH_OP *opList;
// preferred context to use for the copies
union {
CUcontext ctx;
CUgreenCtx gCtx;
};
} CUDA_MEMCPY_BATCH3D_NODE_PARAMS_V1;
typedef CUDA_MEMCPY_BATCH3D_NODE_PARAMS_V1 CUDA_MEMCPY_BATCH3D_NODE_PARAMS;
typedef struct CUDA_SUBGRID_SCHEDULE_NODE_PARAMS_V1_st {
/* Scheduling object supporting internal subgrid descriptions.
Must be NULL for node creation, will be filled in by the driver with a freshly allocated empty schedule. */
CUsubgridSchedule schedule;
// context for the schedule to run in.
CUcontext ctx;
} CUDA_SUBGRID_SCHEDULE_NODE_PARAMS_V1;
typedef CUDA_SUBGRID_SCHEDULE_NODE_PARAMS_V1 CUDA_SUBGRID_SCHEDULE_NODE_PARAMS;
typedef struct CUgraphNodeParams_st {
CUgraphNodeType type;
int reserved0[3];
union {
long long reserved1[29];
CUDA_KERNEL_NODE_PARAMS_v3 kernel;
CUDA_MEMCPY_NODE_PARAMS memcpy;
CUDA_MEMSET_NODE_PARAMS_v2 memset;
CUDA_HOST_NODE_PARAMS_v2 host;
CUDA_CHILD_GRAPH_NODE_PARAMS graph;
CUDA_EVENT_WAIT_NODE_PARAMS eventWait;
CUDA_EVENT_RECORD_NODE_PARAMS eventRecord;
CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v2 extSemSignal;
CUDA_EXT_SEM_WAIT_NODE_PARAMS_v2 extSemWait;
CUDA_MEM_ALLOC_NODE_PARAMS_v2 alloc;
CUDA_MEM_FREE_NODE_PARAMS free;
CUDA_BATCH_MEM_OP_NODE_PARAMS_v2 memOp;
CUDA_CONDITIONAL_NODE_PARAMS conditional;
CUDA_MEMCPY_BATCH_NODE_PARAMS_V1 memcpyBatch;
CUDA_MEMCPY_BATCH3D_NODE_PARAMS_V1 memcpyBatch3D;
CUDA_SUBGRID_SCHEDULE_NODE_PARAMS_V1 subgridSchedule;
char asBytes[232];
};
long long reserved2;
} CUgraphNodeParams;
#define CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC 0x01
#define CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC 0x02
#define CUDA_ARRAY3D_LAYERED 0x01
#define CUDA_ARRAY3D_2DARRAY 0x01
#define CUDA_ARRAY3D_SURFACE_LDST 0x02
#define CUDA_ARRAY3D_CUBEMAP 0x04
#define CUDA_ARRAY3D_TEXTURE_GATHER 0x08
#define CUDA_ARRAY3D_DEPTH_TEXTURE 0x10
#define CUDA_ARRAY3D_COLOR_ATTACHMENT 0x20
#define CUDA_ARRAY3D_SPARSE 0x40
#define CUDA_ARRAY3D_DEFERRED_MAPPING 0x80
#define CUDA_ARRAY3D_VIDEO_ENCODE_DECODE 0x100
#define CU_TRSA_OVERRIDE_FORMAT 0x01
#define CU_TRSF_READ_AS_INTEGER 0x01
#define CU_TRSF_NORMALIZED_COORDINATES 0x02
#define CU_TRSF_SRGB 0x10
#define CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION 0x20
#define CU_TRSF_SEAMLESS_CUBEMAP 0x40
#define CU_LAUNCH_KERNEL_REQUIRED_BLOCK_DIM 1
#define CU_LAUNCH_PARAM_END_AS_INT 0x00
#define CU_LAUNCH_PARAM_END ((void*)CU_LAUNCH_PARAM_END_AS_INT)
#define CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT 0x01
#define CU_LAUNCH_PARAM_BUFFER_POINTER ((void*)CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT)
#define CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT 0x02
#define CU_LAUNCH_PARAM_BUFFER_SIZE ((void*)CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT)
#define CU_PARAM_TR_DEFAULT -1
#define CU_DEVICE_CPU ((CUdevice)-1)
#define CU_DEVICE_INVALID ((CUdevice)-2)
typedef enum CUflushGPUDirectRDMAWritesOptions_enum {
CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = 1<<0,
CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = 1<<1
} CUflushGPUDirectRDMAWritesOptions;
typedef enum CUGPUDirectRDMAWritesOrdering_enum {
CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = 0,
CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = 100,
CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = 200
} CUGPUDirectRDMAWritesOrdering;
typedef enum CUflushGPUDirectRDMAWritesScope_enum {
CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = 100,
CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = 200
} CUflushGPUDirectRDMAWritesScope;
typedef enum CUflushGPUDirectRDMAWritesTarget_enum {
CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = 0
} CUflushGPUDirectRDMAWritesTarget;
typedef enum CUgraphDebugDot_flags_enum {
CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = 1<<0,
CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = 1<<1,
CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = 1<<2,
CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = 1<<3,
CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = 1<<4,
CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = 1<<5,
CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = 1<<6,
CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = 1<<7,
CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = 1<<8,
CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = 1<<9,
CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = 1<<10,
CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS = 1<<11,
CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS = 1<<12,
CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS = 1<<13,
CU_GRAPH_DEBUG_DOT_FLAGS_EXTRA_TOPO_INFO = 1<<14,
CU_GRAPH_DEBUG_DOT_FLAGS_CONDITIONAL_NODE_PARAMS = 1<<15
,CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_BATCH_NODE_PARAMS = 1<<16
} CUgraphDebugDot_flags;
typedef enum CUuserObject_flags_enum {
CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = 1
} CUuserObject_flags;
typedef enum CUuserObjectRetain_flags_enum {
CU_GRAPH_USER_OBJECT_MOVE = 1
} CUuserObjectRetain_flags;
typedef enum CUgraphInstantiate_flags_enum {
CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = 1
, CUDA_GRAPH_INSTANTIATE_FLAG_UPLOAD = 2
, CUDA_GRAPH_INSTANTIATE_FLAG_DEVICE_LAUNCH = 4
, CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = 8
} CUgraphInstantiate_flags;
typedef enum CUdeviceNumaConfig_enum {
CU_DEVICE_NUMA_CONFIG_NONE = 0,
CU_DEVICE_NUMA_CONFIG_NUMA_NODE,
} CUdeviceNumaConfig;
typedef enum CUprocessState_enum {
CU_PROCESS_STATE_RUNNING = 0,
CU_PROCESS_STATE_LOCKED,
CU_PROCESS_STATE_CHECKPOINTED,
CU_PROCESS_STATE_FAILED,
CU_PROCESS_STATE_CHECKPOINTING,
CU_PROCESS_STATE_RESTORING,
} CUprocessState;
typedef struct CUcheckpointCustomStoragePerDeviceData_st {
CUdeviceptr devPtr;
size_t size;
CUstream stream;
} CUcheckpointCustomStoragePerDeviceData;
typedef struct CUIcheckpointOperation_st *CUcheckpointOperationHandle;
typedef struct CUcheckpointCustomStorageInfo_st {
CUcheckpointOperationHandle handle;
CUcheckpointCustomStoragePerDeviceData *perDeviceData;
unsigned int deviceCount;
} CUcheckpointCustomStorageInfo;
typedef struct CUcheckpointLockArgs_st {
unsigned int timeoutMs;
unsigned int reserved0;
cuuint64_t reserved1[7];
} CUcheckpointLockArgs;
typedef struct CUcheckpointCheckpointArgs_st {
CUcheckpointCustomStorageInfo **customStorageInfo_out;
char reserved[64 - sizeof(CUcheckpointCustomStorageInfo *)];
} CUcheckpointCheckpointArgs;
typedef struct CUcheckpointGpuPair_st {
CUuuid oldUuid;
CUuuid newUuid;
} CUcheckpointGpuPair;
typedef struct CUcheckpointRestoreArgs_st {
CUcheckpointGpuPair *gpuPairs;
unsigned int gpuPairsCount;
unsigned int padding0;
CUcheckpointCustomStorageInfo **customStorageInfo_out;
char reserved[64 - sizeof(CUcheckpointGpuPair *) - 2 * sizeof(unsigned int) - sizeof(CUcheckpointCustomStorageInfo **)];
} CUcheckpointRestoreArgs;
typedef struct CUcheckpointUnlockArgs_st {
cuuint64_t reserved[8];
} CUcheckpointUnlockArgs;
/* END CUDA_TYPES */
#if defined(__GNUC__)
#if defined(__CUDA_API_PUSH_VISIBILITY_DEFAULT)
#pragma GCC visibility push(default)
#endif
#endif
#ifdef _WIN32
#define CUDAAPI __stdcall
#else
#define CUDAAPI
#endif
CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr);
CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr);
/* END CUDA_ERROR */
CUresult CUDAAPI cuInit(unsigned int Flags);
/* END CUDA_INITIALIZE */
CUresult CUDAAPI cuDriverGetVersion(int *driverVersion);
/* END CUDA_VERSION */
CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal);
CUresult CUDAAPI cuDeviceGetCount(int *count);
CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev);
CUresult CUDAAPI cuDeviceGetUuid(CUuuid *uuid, CUdevice dev);
CUresult CUDAAPI cuDeviceGetLuid(char *luid, unsigned int *deviceNodeMask, CUdevice dev);
CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev);
CUresult CUDAAPI cuDeviceGetTexture1DLinearMaxWidth(size_t *maxWidthInElements, CUarray_format format, unsigned numChannels, CUdevice dev);
CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevice dev);
CUresult CUDAAPI cuDeviceGetHostAtomicCapabilities(unsigned int* capabilities, const CUatomicOperation* operations, unsigned int count, CUdevice dev);
CUresult CUDAAPI cuDeviceGetNvSciSyncAttributes(void *nvSciSyncAttrList, CUdevice dev, int flags);
CUresult CUDAAPI cuDeviceSetMemPool(CUdevice dev, CUmemoryPool pool);
CUresult CUDAAPI cuDeviceGetMemPool(CUmemoryPool *pool, CUdevice dev);
CUresult CUDAAPI cuDeviceGetDefaultMemPool(CUmemoryPool *pool_out, CUdevice dev);
CUresult CUDAAPI cuDeviceGetExecAffinitySupport(int *pi, CUexecAffinityType type, CUdevice dev);
CUresult CUDAAPI cuFlushGPUDirectRDMAWrites(CUflushGPUDirectRDMAWritesTarget target, CUflushGPUDirectRDMAWritesScope scope);
/* END CUDA_DEVICE */
__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev);
__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceComputeCapability(int *major, int *minor, CUdevice dev);
/* END CUDA_DEVICE_DEPRECATED */
CUresult CUDAAPI cuDevicePrimaryCtxRetain(CUcontext *pctx, CUdevice dev);
CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev);
CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags);
CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, int *active);
CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev);
/* END CUDA_PRIMARY_CTX */
CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, CUctxCreateParams *ctxCreateParams, unsigned int flags, CUdevice dev);
CUresult CUDAAPI cuCtxDestroy(CUcontext ctx);
CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx);
CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx);
CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx);
CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx);
CUresult CUDAAPI cuCtxGetDevice(CUdevice *device);
CUresult CUDAAPI cuCtxGetDevice_v2(CUdevice *device, CUcontext ctx);
CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags);
CUresult CUDAAPI cuCtxSetFlags(unsigned int flags);
CUresult CUDAAPI cuCtxGetId(CUcontext ctx, unsigned long long *ctxId);
CUresult CUDAAPI cuCtxSynchronize(void);
CUresult CUDAAPI cuCtxSynchronize_v2(CUcontext ctx);
CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value);
CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit);
CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig);
CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config);
CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version);
CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPriority);
CUresult CUDAAPI cuCtxResetPersistingL2Cache(void);
CUresult CUDAAPI cuCtxGetExecAffinity(CUexecAffinityParam *pExecAffinity, CUexecAffinityType type);
CUresult CUDAAPI cuCtxRecordEvent(CUcontext hCtx, CUevent hEvent);
CUresult CUDAAPI cuCtxWaitEvent(CUcontext hCtx, CUevent hEvent);
/* END CUDA_CTX */
__CUDA_DEPRECATED CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, unsigned int flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuCtxDetach(CUcontext ctx);
__CUDA_DEPRECATED CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig);
__CUDA_DEPRECATED CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config);
/* END CUDA_CTX_DEPRECATED */
CUresult CUDAAPI cuModuleLoad(CUmodule *module, const char *fname);
CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image);
CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, unsigned int numOptions, CUjit_option *options, void **optionValues);
CUresult CUDAAPI cuModuleLoadFatBinary(CUmodule *module, const void *fatCubin);
CUresult CUDAAPI cuModuleUnload(CUmodule hmod);
typedef enum CUmoduleLoadingMode_enum {
CU_MODULE_EAGER_LOADING = 0x1,
CU_MODULE_LAZY_LOADING = 0x2,
} CUmoduleLoadingMode;
CUresult CUDAAPI cuModuleGetLoadingMode(CUmoduleLoadingMode *mode);
CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, const char *name);
CUresult CUDAAPI cuModuleGetFunctionCount(unsigned int *count, CUmodule mod);
CUresult CUDAAPI cuModuleEnumerateFunctions(CUfunction *functions, unsigned int numFunctions, CUmodule mod);
CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char *name);
CUresult CUDAAPI
cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues, CUlinkState *stateOut);
CUresult CUDAAPI
cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, const char *name,
unsigned int numOptions, CUjit_option *options, void **optionValues);
CUresult CUDAAPI
cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path,
unsigned int numOptions, CUjit_option *options, void **optionValues);
CUresult CUDAAPI
cuLinkComplete(CUlinkState state, void **cubinOut, size_t *sizeOut);
CUresult CUDAAPI
cuLinkDestroy(CUlinkState state);
/* END CUDA_MODULE */
__CUDA_DEPRECATED CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, const char *name);
__CUDA_DEPRECATED CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const char *name);
/* END CUDA_MODULE_DEPRECATED */
CUresult CUDAAPI cuLibraryLoadData(CUlibrary *library, const void *code,
CUjit_option *jitOptions, void **jitOptionsValues, unsigned int numJitOptions,
CUlibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions);
CUresult CUDAAPI cuLibraryLoadFromFile(CUlibrary *library, const char *fileName,
CUjit_option *jitOptions, void **jitOptionsValues, unsigned int numJitOptions,
CUlibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions);
CUresult CUDAAPI cuLibraryUnload(CUlibrary library);
CUresult CUDAAPI cuLibraryGetKernel(CUkernel *pKernel, CUlibrary library, const char *name);
CUresult CUDAAPI cuLibraryGetKernelCount(unsigned int *count, CUlibrary lib);
CUresult CUDAAPI cuLibraryEnumerateKernels(CUkernel *kernels, unsigned int numKernels, CUlibrary lib);
CUresult CUDAAPI cuLibraryGetModule(CUmodule *pMod, CUlibrary library);
CUresult CUDAAPI cuKernelGetFunction(CUfunction *pFunc, CUkernel kernel);
CUresult CUDAAPI cuKernelGetLibrary(CUlibrary *pLib, CUkernel kernel);
CUresult CUDAAPI cuLibraryGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUlibrary library, const char *name);
CUresult CUDAAPI cuLibraryGetManaged(CUdeviceptr *dptr, size_t *bytes, CUlibrary library, const char *name);
CUresult CUDAAPI cuLibraryGetUnifiedFunction(void **fptr, CUlibrary library, const char *symbol);
CUresult CUDAAPI cuLibraryGetExport(CUlibrary library, const char *name, CUexport *exportedFunction);
CUresult CUDAAPI cuKernelGetAttribute(int *pi, CUfunction_attribute attrib, CUkernel kernel, CUdevice dev);
CUresult CUDAAPI cuKernelSetAttribute(CUfunction_attribute attrib, int val, CUkernel kernel, CUdevice dev);
CUresult CUDAAPI cuKernelSetCacheConfig(CUkernel kernel, CUfunc_cache config, CUdevice dev);
CUresult CUDAAPI cuKernelGetName(const char **name, CUkernel hfunc);
CUresult CUDAAPI cuKernelGetParamInfo(CUkernel kernel, size_t paramIndex, size_t *paramOffset, size_t *paramSize);
CUresult CUDAAPI cuKernelGetDeviceCodeInfo(CUkernel kernel, CUdeviceptr *address, size_t *bytesize);
CUresult CUDAAPI cuKernelGetParamCount(CUkernel kernel, size_t *paramCount);
/* END CUDA_LIBRARY */
CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total);
CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize);
CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes);
CUresult CUDAAPI cuMemFree(CUdeviceptr dptr);
CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdeviceptr dptr);
CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize);
CUresult CUDAAPI cuMemFreeHost(void *p);
CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags);
CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags);
CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p);
CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned int flags);
CUresult CUDAAPI cuDeviceRegisterAsyncNotification(CUdevice device, CUasyncCallback callbackFunc, void *userData, CUasyncCallbackHandle *callback);
CUresult CUDAAPI cuDeviceUnregisterAsyncNotification(CUdevice device, CUasyncCallbackHandle callback);
CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId);
CUresult CUDAAPI cuDeviceGetPCIBusId(char *pciBusId, int len, CUdevice dev);
CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event);
CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent, CUipcEventHandle handle);
CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr);
CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int Flags);
CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr);
CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags);
CUresult CUDAAPI cuMemHostUnregister(void *p);
CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount);
CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount);
CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy);
CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy);
CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy);
CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy);
CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpyBatchAsync(CUdeviceptr *dsts, CUdeviceptr *srcs, size_t *sizes, size_t count,
CUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DBatchAsync(size_t numOps, CUDA_MEMCPY3D_BATCH_OP *opList, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemcpyWithAttributesAsync(CUdeviceptr dst, CUdeviceptr src, size_t size, CUmemcpyAttributes *attr, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DWithAttributesAsync(CUDA_MEMCPY3D_BATCH_OP *op, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N);
CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N);
CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N);
CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height);
CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height);
CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height);
CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pAllocateArray);
CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray);
CUresult CUDAAPI cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *sparseProperties, CUarray array);
CUresult CUDAAPI cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES *sparseProperties, CUmipmappedArray mipmap);
CUresult CUDAAPI cuArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS *memoryRequirements, CUarray array, CUdevice device);
CUresult CUDAAPI cuMipmappedArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS *memoryRequirements, CUmipmappedArray mipmap, CUdevice device);
CUresult CUDAAPI cuArrayGetPlane(CUarray *pPlaneArray, CUarray hArray, unsigned int planeIdx);
CUresult CUDAAPI cuArrayDestroy(CUarray hArray);
CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray);
CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray);
CUresult CUDAAPI cuMipmappedArrayCreate(CUmipmappedArray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels);
CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level);
CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray);
CUresult CUDAAPI cuMemGetHandleForAddressRange(void *handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags);
typedef enum CUmemDecompressAlgorithm_enum {
CU_MEM_DECOMPRESS_UNSUPPORTED = 0,
CU_MEM_DECOMPRESS_ALGORITHM_DEFLATE = 1<<0,
CU_MEM_DECOMPRESS_ALGORITHM_SNAPPY = 1<<1,
CU_MEM_DECOMPRESS_ALGORITHM_LZ4 = 1<<2
} CUmemDecompressAlgorithm;
typedef struct CUmemDecompressParams_st {
size_t srcNumBytes;
size_t dstNumBytes;
cuuint32_t *dstActBytes;
const void *src;
void *dst;
CUmemDecompressAlgorithm algo;
/* These bytes are unused and must be zeroed. This ensures compatibility if
* additional fields are added in the future. */
unsigned char padding[20];
} CUmemDecompressParams;
CUresult CUDAAPI cuMemBatchDecompressAsync(
CUmemDecompressParams *paramsArray,
size_t count,
unsigned int flags,
size_t *errorIndex,
CUstream stream
);
/* END CUDA_MEM */
CUresult CUDAAPI cuMemAddressReserve(CUdeviceptr *ptr, size_t size, size_t alignment, CUdeviceptr addr, unsigned long long flags);
CUresult CUDAAPI cuMemAddressFree(CUdeviceptr ptr, size_t size);
CUresult CUDAAPI cuMemCreate(CUmemGenericAllocationHandle *handle, size_t size, const CUmemAllocationProp *prop, unsigned long long flags);
CUresult CUDAAPI cuMemRelease(CUmemGenericAllocationHandle handle);
CUresult CUDAAPI cuMemMap(CUdeviceptr ptr, size_t size, size_t offset, CUmemGenericAllocationHandle handle, unsigned long long flags);
CUresult CUDAAPI cuMemMapArrayAsync(CUarrayMapInfo *mapInfoList, unsigned int count, CUstream hStream);
CUresult CUDAAPI cuMemUnmap(CUdeviceptr ptr, size_t size);
CUresult CUDAAPI cuMemSetAccess(CUdeviceptr ptr, size_t size, const CUmemAccessDesc *desc, size_t count);
CUresult CUDAAPI cuMemGetAccess(unsigned long long *flags, const CUmemLocation *location, CUdeviceptr ptr);
CUresult CUDAAPI cuMemExportToShareableHandle(void *shareableHandle, CUmemGenericAllocationHandle handle, CUmemAllocationHandleType handleType, unsigned long long flags);
CUresult CUDAAPI cuMemImportFromShareableHandle(CUmemGenericAllocationHandle *handle, void *osHandle, CUmemAllocationHandleType shHandleType);
CUresult CUDAAPI cuMemGetAllocationGranularity(size_t *granularity, const CUmemAllocationProp *prop, CUmemAllocationGranularity_flags option);
CUresult CUDAAPI cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp *prop, CUmemGenericAllocationHandle handle);
CUresult CUDAAPI cuMemRetainAllocationHandle(CUmemGenericAllocationHandle *handle, void *addr);
/* END CUDA_VA */
CUresult CUDAAPI cuMemFreeAsync(CUdeviceptr dptr, CUstream hStream);
CUresult CUDAAPI cuMemAllocAsync(CUdeviceptr *dptr, size_t bytesize, CUstream hStream);
CUresult CUDAAPI cuMemPoolTrimTo(CUmemoryPool pool, size_t minBytesToKeep);
CUresult CUDAAPI cuMemPoolSetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void *value);
CUresult CUDAAPI cuMemPoolGetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void *value);
CUresult CUDAAPI cuMemPoolSetAccess(CUmemoryPool pool, const CUmemAccessDesc *map, size_t count);
CUresult CUDAAPI cuMemPoolGetAccess(CUmemAccess_flags *flags, CUmemoryPool memPool, CUmemLocation *location);
CUresult CUDAAPI cuMemPoolCreate(CUmemoryPool *pool, const CUmemPoolProps *poolProps);
CUresult CUDAAPI cuMemPoolDestroy(CUmemoryPool pool);
CUresult CUDAAPI cuMemGetDefaultMemPool(CUmemoryPool *pool_out, CUmemLocation *location, CUmemAllocationType type);
CUresult CUDAAPI cuMemGetMemPool(CUmemoryPool *pool, CUmemLocation *location, CUmemAllocationType type);
CUresult CUDAAPI cuMemSetMemPool(CUmemLocation *location, CUmemAllocationType type, CUmemoryPool pool);
CUresult CUDAAPI cuMemAllocFromPoolAsync(CUdeviceptr *dptr, size_t bytesize, CUmemoryPool pool, CUstream hStream);
CUresult CUDAAPI cuMemPoolExportToShareableHandle(void *handle_out, CUmemoryPool pool, CUmemAllocationHandleType handleType, unsigned long long flags);
CUresult CUDAAPI cuMemPoolImportFromShareableHandle(
CUmemoryPool *pool_out,
void *handle,
CUmemAllocationHandleType handleType,
unsigned long long flags);
CUresult CUDAAPI cuMemPoolExportPointer(CUmemPoolPtrExportData *shareData_out, CUdeviceptr ptr);
CUresult CUDAAPI cuMemPoolImportPointer(CUdeviceptr *ptr_out, CUmemoryPool pool, CUmemPoolPtrExportData *shareData);
/* END CUDA_MALLOC_ASYNC */
CUresult CUDAAPI cuMulticastCreate(CUmemGenericAllocationHandle *mcHandle, const CUmulticastObjectProp *prop);
CUresult CUDAAPI cuMulticastAddDevice(CUmemGenericAllocationHandle mcHandle, CUdevice dev);
CUresult CUDAAPI cuMulticastBindMem(CUmemGenericAllocationHandle mcHandle, size_t mcOffset, CUmemGenericAllocationHandle memHandle, size_t memOffset, size_t size, unsigned long long flags);
CUresult CUDAAPI cuMulticastBindMem_v2(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, CUmemGenericAllocationHandle memHandle, size_t memOffset, size_t size, unsigned long long flags);
CUresult CUDAAPI cuMulticastBindAddr(CUmemGenericAllocationHandle mcHandle, size_t mcOffset, CUdeviceptr memptr, size_t size, unsigned long long flags);
CUresult CUDAAPI cuMulticastBindAddr_v2(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, CUdeviceptr memptr, size_t size, unsigned long long flags);
CUresult CUDAAPI cuMulticastUnbind(CUmemGenericAllocationHandle mcHandle, CUdevice dev, size_t mcOffset, size_t size);
CUresult CUDAAPI cuMulticastGetGranularity(size_t *granularity, const CUmulticastObjectProp *prop, CUmulticastGranularity_flags option);
/* END CUDA_MULTICAST */
typedef enum CUcliqueType_enum {
CU_CLIQUE_TYPE_UNICAST_POINTER = 0,
CU_CLIQUE_TYPE_MULTICAST_POINTER = 1,
CU_CLIQUE_TYPE_UNICAST_LOGICAL_ENDPOINT = 2,
CU_CLIQUE_TYPE_MULTICAST_LOGICAL_ENDPOINT = 3,
} CUcliqueType;
typedef struct CUcliqueInfo_st {
CUcliqueType type;
unsigned int id;
} CUcliqueInfo;
CUresult CUDAAPI cuDeviceGetFabricClusterUuid(CUuuid *uuid, CUdevice dev);
CUresult CUDAAPI cuDeviceGetCliqueCount(size_t *count, CUdevice dev);
CUresult CUDAAPI cuDeviceGetCliqueInfo(CUcliqueInfo *cliqueInfo, size_t *count, CUdevice dev);
/* END CUDA_CLIQUE */
typedef cuuint32_t CUlogicalEndpointId;
typedef enum CUlogicalEndpointIpcHandleType_enum {
CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_NONE,
CU_LOGICAL_ENDPOINT_IPC_HANDLE_TYPE_FABRIC
} CUlogicalEndpointIpcHandleType;
typedef struct CUlogicalEndpointFabricHandle_st {
unsigned char data[CU_IPC_HANDLE_SIZE];
} CUlogicalEndpointFabricHandle;
typedef enum CUlogicalEndpointType_enum {
CU_LOGICAL_ENDPOINT_TYPE_INVALID,
CU_LOGICAL_ENDPOINT_TYPE_UNICAST,
CU_LOGICAL_ENDPOINT_TYPE_MULTICAST
} CUlogicalEndpointType;
typedef enum CUlogicalEndpointFlag_enum {
CU_LOGICAL_ENDPOINT_FLAG_NONE = 0x0,
CU_LOGICAL_ENDPOINT_FLAG_COUNTED_OPS = 0x1,
} CUlogicalEndpointFlag;
typedef struct CUlogicalEndpointProp_struct {
CUlogicalEndpointType type;
union {
struct {
CUdevice device;
} unicast;
struct {
unsigned int numDevices;
} multicast;
};
unsigned long long size;
unsigned int ipcHandleTypes;
unsigned int flags;
} CUlogicalEndpointProp;
CUresult CUDAAPI cuLogicalEndpointIdReserve(CUlogicalEndpointId *baseLeId, cuuint32_t count);
CUresult CUDAAPI cuLogicalEndpointIdRelease(CUlogicalEndpointId baseLeId, cuuint32_t count);
CUresult CUDAAPI cuLogicalEndpointCreate(CUlogicalEndpointId leId, const CUlogicalEndpointProp *prop);
CUresult CUDAAPI cuLogicalEndpointAddDevice(CUlogicalEndpointId leId, CUdevice dev);
CUresult CUDAAPI cuLogicalEndpointDestroy(CUlogicalEndpointId leId);
CUresult CUDAAPI cuLogicalEndpointBindAddr(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, void *ptr, cuuint64_t size, unsigned long long flags);
CUresult CUDAAPI cuLogicalEndpointBindMem(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, CUmemGenericAllocationHandle memHandle, cuuint64_t memOffset, cuuint64_t size, unsigned long long flags);
CUresult CUDAAPI cuLogicalEndpointUnbind(CUlogicalEndpointId leId, CUdevice dev, cuuint64_t offset, cuuint64_t size);
CUresult CUDAAPI cuLogicalEndpointExport(void *handle, CUlogicalEndpointId leId, CUlogicalEndpointIpcHandleType handleType);
CUresult CUDAAPI cuLogicalEndpointImport(CUlogicalEndpointId leId, const void *handle, CUlogicalEndpointIpcHandleType handleType);
CUresult CUDAAPI cuLogicalEndpointGetLimits(cuuint64_t *bindAlignment, cuuint64_t *maxSize, const CUlogicalEndpointProp *prop);
CUresult CUDAAPI cuLogicalEndpointQuery(CUlogicalEndpointId leId, cuuint32_t count, int *queryStatus);
/* END CUDA_LOGICAL_ENDPOINT */
CUresult CUDAAPI cuPointerGetAttribute(void *data, CUpointer_attribute attribute, CUdeviceptr ptr);
CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUmemLocation location, unsigned int flags, CUstream hStream);
CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUmemLocation location);
CUresult CUDAAPI cuMemPrefetchBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count,
CUmemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs,
unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemDiscardBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemDiscardAndPrefetchBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count,
CUmemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs,
unsigned long long flags, CUstream hStream);
CUresult CUDAAPI
cuMemGetLocationInfo(CUdeviceptr ptr, size_t size, size_t summaryGranularity, size_t samplingGranularity, CUmemLocation *location_out);
CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, CUmem_range_attribute attribute, CUdeviceptr devPtr, size_t count);
CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, CUmem_range_attribute *attributes, size_t numAttributes, CUdeviceptr devPtr, size_t count);
CUresult CUDAAPI cuPointerSetAttribute(const void *value, CUpointer_attribute attribute, CUdeviceptr ptr);
CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attribute *attributes, void **data, CUdeviceptr ptr);
/* END CUDA_UNIFIED */
CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags);
CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, unsigned int flags, int priority);
CUresult CUDAAPI cuStreamBeginCaptureToCig(CUstream hStream, CUstreamCigCaptureParams* streamCigCaptureParams);
CUresult CUDAAPI cuStreamEndCaptureToCig(CUstream hStream);
CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority);
CUresult CUDAAPI cuStreamGetDevice(CUstream hStream, CUdevice *device);
CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags);
CUresult CUDAAPI cuStreamGetId(CUstream hStream, unsigned long long *streamId);
CUresult CUDAAPI cuStreamGetCtx(CUstream hStream, CUcontext *pctx);
CUresult CUDAAPI cuStreamGetCtx_v2(CUstream hStream, CUcontext *pCtx, CUgreenCtx *pGreenCtx);
CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags);
CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags);
CUresult CUDAAPI cuStreamBeginCapture(CUstream hStream, CUstreamCaptureMode mode);
typedef enum CUgraphRecaptureStatus_enum {
CU_GRAPH_RECAPTURE_ELIGIBLE_FOR_UPDATE = 0,
CU_GRAPH_RECAPTURE_INELIGIBLE_FOR_UPDATE = 1,
CU_GRAPH_RECAPTURE_ERROR = 2,
} CUgraphRecaptureStatus;
typedef CUresult (CUDA_CB *CUgraphRecaptureCallback)(
void *data,
CUgraphNode node,
const CUgraphNodeParams *originalParams,
const CUgraphNodeParams *recaptureParams,
CUgraphRecaptureStatus status);
CUresult CUDAAPI cuStreamBeginRecaptureToGraph(CUstream hStream, CUstreamCaptureMode mode, CUgraph hGraph, CUgraphRecaptureCallback callbackFunc, void *userData);
CUresult CUDAAPI cuStreamBeginCaptureToGraph(CUstream hStream, CUgraph hGraph, const CUgraphNode *dependencies, const CUgraphEdgeData *dependencyData, size_t numDependencies, CUstreamCaptureMode mode);
CUresult CUDAAPI cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *mode);
CUresult CUDAAPI cuStreamEndCapture(CUstream hStream, CUgraph *phGraph);
CUresult CUDAAPI cuStreamIsCapturing(CUstream hStream, CUstreamCaptureStatus *captureStatus);
CUresult CUDAAPI cuStreamGetCaptureInfo(CUstream hStream, CUstreamCaptureStatus *captureStatus_out,
cuuint64_t *id_out, CUgraph *graph_out, const CUgraphNode **dependencies_out,
const CUgraphEdgeData **edgeData_out, size_t *numDependencies_out);
CUresult CUDAAPI cuStreamUpdateCaptureDependencies(CUstream hStream, CUgraphNode *dependencies,
const CUgraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags);
CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags);
CUresult CUDAAPI cuStreamQuery(CUstream hStream);
CUresult CUDAAPI cuStreamSynchronize(CUstream hStream);
CUresult CUDAAPI cuStreamDestroy(CUstream hStream);
CUresult CUDAAPI cuStreamCopyAttributes(CUstream dst, CUstream src);
CUresult CUDAAPI cuStreamGetAttribute(CUstream hStream, CUstreamAttrID attr,
CUstreamAttrValue *value_out);
CUresult CUDAAPI cuStreamSetAttribute(CUstream hStream, CUstreamAttrID attr,
const CUstreamAttrValue *value);
/* END CUDA_STREAM */
CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags);
CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream);
CUresult CUDAAPI cuEventRecordWithFlags(CUevent hEvent, CUstream hStream, unsigned int flags);
CUresult CUDAAPI cuEventQuery(CUevent hEvent);
CUresult CUDAAPI cuEventSynchronize(CUevent hEvent);
CUresult CUDAAPI cuEventDestroy(CUevent hEvent);
CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUevent hEnd);
/* END CUDA_EVENT */
CUresult CUDAAPI cuImportExternalMemory(CUexternalMemory *extMem_out, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *memHandleDesc);
CUresult CUDAAPI cuExternalMemoryGetMappedBuffer(CUdeviceptr *devPtr, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *bufferDesc);
CUresult CUDAAPI cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray *mipmap, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *mipmapDesc);
CUresult CUDAAPI cuDestroyExternalMemory(CUexternalMemory extMem);
CUresult CUDAAPI cuImportExternalSemaphore(CUexternalSemaphore *extSem_out, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *semHandleDesc);
CUresult CUDAAPI cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *extSemArray, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *paramsArray, unsigned int numExtSems, CUstream stream);
CUresult CUDAAPI cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *extSemArray, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *paramsArray, unsigned int numExtSems, CUstream stream);
CUresult CUDAAPI cuDestroyExternalSemaphore(CUexternalSemaphore extSem);
/* END CUDA_EXTRES_INTEROP */
CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags);
/* END CUDA_MEMOP */
CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunction hfunc);
CUresult CUDAAPI cuFuncSetAttribute(CUfunction hfunc, CUfunction_attribute attrib, int value);
CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config);
CUresult CUDAAPI cuFuncGetModule(CUmodule *hmod, CUfunction hfunc);
CUresult CUDAAPI cuFuncGetName(const char **name, CUfunction hfunc);
CUresult CUDAAPI cuFuncGetParamInfo(CUfunction func, size_t paramIndex, size_t *paramOffset, size_t *paramSize);
CUresult CUDAAPI cuFuncGetParamCount(CUfunction func, size_t *paramCount);
typedef enum CUfunctionLoadingState_enum {
CU_FUNCTION_LOADING_STATE_UNLOADED = 0,
CU_FUNCTION_LOADING_STATE_LOADED = 1,
CU_FUNCTION_LOADING_STATE_MAX
} CUfunctionLoadingState;
CUresult CUDAAPI cuFuncIsLoaded(CUfunctionLoadingState *state, CUfunction function);
CUresult CUDAAPI cuFuncLoad(CUfunction function);
/*
* \brief Returns the address and size of the code for a function
*
* Returns in \p address and \p bytesize the address and size in bytes of the code for \p func.
*
* \param func - the function to get the code info for
* \param address - the address of the code
* \param bytesize - the size of the code
*
* \return
* ::CUDA_SUCCESS,
* ::CUDA_ERROR_INVALID_HANDLE,
* ::CUDA_ERROR_INVALID_VALUE
*
* \sa ::cuKernelGetDeviceCodeInfo
*/
CUresult CUDAAPI cuFuncGetDeviceCodeInfo(CUfunction func, CUdeviceptr *address, size_t *bytesize);
CUresult CUDAAPI cuLaunchKernel(CUfunction f,
unsigned int gridDimX,
unsigned int gridDimY,
unsigned int gridDimZ,
unsigned int blockDimX,
unsigned int blockDimY,
unsigned int blockDimZ,
unsigned int sharedMemBytes,
CUstream hStream,
void **kernelParams,
void **extra);
CUresult CUDAAPI cuLaunchKernelEx(const CUlaunchConfig *config,
CUfunction f,
void **kernelParams,
void **extra);
CUresult CUDAAPI cuMultiKernelCooperativeDomainCreate(
CUcontext ctx,
CUmultiKernelCooperativeDomain *domain_out,
CUmultiKernelCooperativeDomain domain,
cuuint64_t tag,
void *commObj,
CUhostCommunicationsVtable *commVtable,
unsigned int localCount,
void *localId
);
CUresult CUDAAPI cuMultiKernelCooperativeDomainDestroy(
CUcontext ctx,
CUmultiKernelCooperativeDomain domain,
void *commObj,
CUhostCommunicationsVtable *commVtable,
unsigned int localCount,
void *localId
);
CUresult CUDAAPI cuLaunchCooperativeKernel(CUfunction f,
unsigned int gridDimX,
unsigned int gridDimY,
unsigned int gridDimZ,
unsigned int blockDimX,
unsigned int blockDimY,
unsigned int blockDimZ,
unsigned int sharedMemBytes,
CUstream hStream,
void **kernelParams);
CUresult CUDAAPI cuLaunchHostFunc(CUstream hStream, CUhostFn fn, void *userData);
CUresult CUDAAPI cuLaunchHostFunc_v2(CUstream hStream, CUhostFn fn, void *userData, unsigned int syncMode);
/* END CUDA_EXEC */
__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z);
__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes);
__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, unsigned int numbytes);
__CUDA_DEPRECATED CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, unsigned int value);
__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, float value);
__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, void *ptr, unsigned int numbytes);
__CUDA_DEPRECATED CUresult CUDAAPI cuLaunch(CUfunction f);
__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height);
__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream);
__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS *launchParamsList, unsigned int numDevices, unsigned int flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config);
/* END CUDA_EXEC_DEPRECATED */
CUresult CUDAAPI cuSubgridWorkerGridCreate(CUsubgridWorkerGrid *workerGrid_out, CUsubgridSchedule hSchedule, const CUsubgridWorkerGridDesc *workerGridDesc);
CUresult CUDAAPI cuSubgridWorksetCreate(CUsubgridWorkset *workset_out, CUsubgridWorkerGrid hWorkerGrid, const void *userData, size_t userDataSize);
CUresult CUDAAPI cuSubgridCreate(CUsubgrid *subgrid_out,
CUsubgridWorkset hWorkset,
const CUsubgrid *hDependencies,
cuuint32_t numDependencies,
CUoffset3D *workItemStart,
CUoffset3D *workItemEnd);
CUresult CUDAAPI cuSubgridCreate_v2(CUsubgrid *subgrid_out,
CUsubgridWorkset hWorkset,
const CUsubgrid *hDependencies,
const CUsubgridDependencyType *dependencyTypes,
cuuint32_t numDependencies,
CUoffset3D *workItemStart,
CUoffset3D *workItemEnd); /* END CUDA_SUBGRID */
CUresult CUDAAPI cuGraphCreate(CUgraph *phGraph, unsigned int flags);
CUresult CUDAAPI cuGraphCreateWithArguments(CUgraph *phGraph, size_t numArguments, size_t* argumentSizes, CUgraphVariable *argVars_out, unsigned int flags);
CUresult CUDAAPI cuGraphAddKernelNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphNodeAddRelocation(CUgraphNode node, CUgraphRelocationEntry *entry);
CUresult CUDAAPI cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphKernelNodeSetParams(CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddMemcpyNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_MEMCPY3D *copyParams, CUcontext ctx);
CUresult CUDAAPI cuGraphMemcpyNodeGetParams(CUgraphNode hNode, CUDA_MEMCPY3D *nodeParams);
CUresult CUDAAPI cuGraphMemcpyNodeSetParams(CUgraphNode hNode, const CUDA_MEMCPY3D *nodeParams);
CUresult CUDAAPI cuGraphAddMemsetNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS *memsetParams, CUcontext ctx);
CUresult CUDAAPI cuGraphMemsetNodeGetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphMemsetNodeSetParams(CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddHostNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_HOST_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphHostNodeGetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphHostNodeSetParams(CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddChildGraphNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUgraph childGraph);
CUresult CUDAAPI cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, CUgraph *phGraph);
CUresult CUDAAPI cuGraphAddEmptyNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies);
CUresult CUDAAPI cuGraphAddEventRecordNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUevent event);
CUresult CUDAAPI cuGraphEventRecordNodeGetEvent(CUgraphNode hNode, CUevent *event_out);
CUresult CUDAAPI cuGraphEventRecordNodeSetEvent(CUgraphNode hNode, CUevent event);
CUresult CUDAAPI cuGraphAddEventWaitNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUevent event);
CUresult CUDAAPI cuGraphEventWaitNodeGetEvent(CUgraphNode hNode, CUevent *event_out);
CUresult CUDAAPI cuGraphEventWaitNodeSetEvent(CUgraphNode hNode, CUevent event);
CUresult CUDAAPI cuGraphAddExternalSemaphoresSignalNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExternalSemaphoresSignalNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *params_out);
CUresult CUDAAPI cuGraphExternalSemaphoresSignalNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddExternalSemaphoresWaitNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExternalSemaphoresWaitNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS *params_out);
CUresult CUDAAPI cuGraphExternalSemaphoresWaitNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddBatchMemOpNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_BATCH_MEM_OP_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphBatchMemOpNodeGetParams(CUgraphNode hNode, CUDA_BATCH_MEM_OP_NODE_PARAMS *nodeParams_out);
CUresult CUDAAPI cuGraphBatchMemOpNodeSetParams(CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExecBatchMemOpNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphAddMemAllocNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUDA_MEM_ALLOC_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphMemAllocNodeGetParams(CUgraphNode hNode, CUDA_MEM_ALLOC_NODE_PARAMS *params_out);
CUresult CUDAAPI cuGraphAddMemFreeNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUdeviceptr dptr);
CUresult CUDAAPI cuGraphMemFreeNodeGetParams(CUgraphNode hNode, CUdeviceptr *dptr_out);
CUresult CUDAAPI cuDeviceGraphMemTrim(CUdevice device);
CUresult CUDAAPI cuDeviceGetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value);
CUresult CUDAAPI cuDeviceSetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value);
CUresult CUDAAPI cuGraphClone(CUgraph *phGraphClone, CUgraph originalGraph);
CUresult CUDAAPI cuGraphNodeFindInClone(CUgraphNode *phNode, CUgraphNode hOriginalNode, CUgraph hClonedGraph);
CUresult CUDAAPI cuGraphNodeGetType(CUgraphNode hNode, CUgraphNodeType *type);
CUresult CUDAAPI cuGraphNodeGetContainingGraph(CUgraphNode hNode, CUgraph *phGraph);
CUresult CUDAAPI cuGraphNodeGetLocalId(CUgraphNode hNode, unsigned int *nodeId);
CUresult CUDAAPI cuGraphNodeGetToolsId(CUgraphNode hNode, unsigned long long *toolsNodeId);
CUresult CUDAAPI cuGraphGetId(CUgraph hGraph, unsigned int *graphId);
CUresult CUDAAPI cuGraphExecGetId(CUgraphExec hGraphExec, unsigned int *graphId);
CUresult CUDAAPI cuGraphGetNodes(CUgraph hGraph, CUgraphNode *nodes, size_t *numNodes);
CUresult CUDAAPI cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode *rootNodes, size_t *numRootNodes);
CUresult CUDAAPI cuGraphGetEdges(CUgraph hGraph, CUgraphNode *from, CUgraphNode *to, CUgraphEdgeData *edgeData, size_t *numEdges);
CUresult CUDAAPI cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode *dependencies, CUgraphEdgeData *edgeData, size_t *numDependencies);
CUresult CUDAAPI cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode *dependentNodes, CUgraphEdgeData *edgeData, size_t *numDependentNodes);
CUresult CUDAAPI cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode *from, const CUgraphNode *to, const CUgraphEdgeData *edgeData, size_t numDependencies);
CUresult CUDAAPI cuGraphRemoveDependencies(CUgraph hGraph, const CUgraphNode *from, const CUgraphNode *to, const CUgraphEdgeData *edgeData, size_t numDependencies);
CUresult CUDAAPI cuGraphDestroyNode(CUgraphNode hNode);
CUresult CUDAAPI cuGraphInstantiate(CUgraphExec *phGraphExec, CUgraph hGraph, unsigned long long flags);
CUresult CUDAAPI cuGraphInstantiateWithParams(CUgraphExec *phGraphExec, CUgraph hGraph, CUDA_GRAPH_INSTANTIATE_PARAMS *instantiateParams);
CUresult CUDAAPI cuGraphExecGetFlags(CUgraphExec hGraphExec, cuuint64_t *flags);
CUresult CUDAAPI cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMCPY3D *copyParams, CUcontext ctx);
CUresult CUDAAPI cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS *memsetParams, CUcontext ctx);
CUresult CUDAAPI cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExecChildGraphNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUgraph childGraph);
CUresult CUDAAPI cuGraphExecEventRecordNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event);
CUresult CUDAAPI cuGraphExecEventWaitNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event);
CUresult CUDAAPI cuGraphExecExternalSemaphoresSignalNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphExecExternalSemaphoresWaitNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS *nodeParams);
CUresult CUDAAPI cuGraphNodeSetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int isEnabled);
CUresult CUDAAPI cuGraphNodeGetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int *isEnabled);
CUresult CUDAAPI cuGraphUpload(CUgraphExec hGraphExec, CUstream hStream);
CUresult CUDAAPI cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream);
CUresult CUDAAPI cuGraphLaunchWithArguments(CUgraphExec hGraphExec, CUstream hStream, void **args);
CUresult CUDAAPI cuGraphExecDestroy(CUgraphExec hGraphExec);
CUresult CUDAAPI cuGraphDestroy(CUgraph hGraph);
CUresult CUDAAPI cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraphExecUpdateResultInfo *resultInfo);
CUresult CUDAAPI cuGraphKernelNodeCopyAttributes(CUgraphNode dst, CUgraphNode src);
CUresult CUDAAPI cuGraphKernelNodeGetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr,
CUkernelNodeAttrValue *value_out);
CUresult CUDAAPI cuGraphKernelNodeSetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr,
const CUkernelNodeAttrValue *value);
CUresult CUDAAPI cuGraphDebugDotPrint(CUgraph hGraph, const char *path, unsigned int flags);
CUresult CUDAAPI cuUserObjectCreate(CUuserObject *object_out, void *ptr, CUhostFn destroy,
unsigned int initialRefcount, unsigned int flags);
CUresult CUDAAPI cuUserObjectRetain(CUuserObject object, unsigned int count);
CUresult CUDAAPI cuUserObjectRelease(CUuserObject object, unsigned int count);
CUresult CUDAAPI cuGraphRetainUserObject(CUgraph graph, CUuserObject object, unsigned int count, unsigned int flags);
CUresult CUDAAPI cuGraphReleaseUserObject(CUgraph graph, CUuserObject object, unsigned int count);
CUresult CUDAAPI cuGraphAddNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, const CUgraphEdgeData *dependencyData, size_t numDependencies, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphAddNode_v3(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, const CUgraphEdgeData *dependencyData, size_t numDependencies, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphNodeSetParams(CUgraphNode hNode, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphNodeSetParams_v2(CUgraphNode hNode, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphNodeGetParams(CUgraphNode hNode, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphExecNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuGraphConditionalHandleCreate(CUgraphConditionalHandle *pHandle_out, CUgraph hGraph, CUcontext ctx, unsigned int defaultLaunchValue, unsigned int flags);
/* END CUDA_GRAPH */
CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize);
CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags);
CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit);
CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags);
CUresult CUDAAPI cuOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, CUfunction func, int numBlocks, int blockSize);
CUresult CUDAAPI cuOccupancyMaxPotentialClusterSize(int *clusterSize, CUfunction func, const CUlaunchConfig *config);
CUresult CUDAAPI cuOccupancyMaxActiveClusters(int *numClusters, CUfunction func, const CUlaunchConfig *config); /* END CUDA_OCCUPANCY */
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, unsigned int Flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t bytes);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, int dim);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefCreate(CUtexref *pTexRef);
__CUDA_DEPRECATED CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef);
/* END CUDA_TEXREF_DEPRECATED */
__CUDA_DEPRECATED CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags);
__CUDA_DEPRECATED CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef);
/* END CUDA_SURFREF_DEPRECATED */
CUresult CUDAAPI cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_DESC *pResDesc, const CUDA_TEXTURE_DESC *pTexDesc, const CUDA_RESOURCE_VIEW_DESC *pResViewDesc);
CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject);
CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUtexObject texObject);
CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, CUtexObject texObject);
CUresult CUDAAPI cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject);
/* END CUDA_TEXOBJECT */
CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, const CUDA_RESOURCE_DESC *pResDesc);
CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject);
CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUsurfObject surfObject);
/* END CUDA_SURFOBJECT */
CUresult CUDAAPI cuTensorMapEncodeTiled(CUtensorMap *tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void *globalAddress, const cuuint64_t *globalDim, const cuuint64_t *globalStrides, const cuuint32_t *boxDim, const cuuint32_t *elementStrides, CUtensorMapInterleave interleave, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill);
CUresult CUDAAPI cuTensorMapEncodeIm2col(CUtensorMap *tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void *globalAddress, const cuuint64_t *globalDim, const cuuint64_t *globalStrides, const int *pixelBoxLowerCorner, const int *pixelBoxUpperCorner, cuuint32_t channelsPerPixel, cuuint32_t pixelsPerColumn, const cuuint32_t *elementStrides, CUtensorMapInterleave interleave, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill);
CUresult CUDAAPI cuTensorMapEncodeIm2colWide(CUtensorMap *tensorMap, CUtensorMapDataType tensorDataType, cuuint32_t tensorRank, void *globalAddress, const cuuint64_t *globalDim, const cuuint64_t *globalStrides, int pixelBoxLowerCornerWidth, int pixelBoxUpperCornerWidth, cuuint32_t channelsPerPixel, cuuint32_t pixelsPerColumn, const cuuint32_t *elementStrides, CUtensorMapInterleave interleave, CUtensorMapIm2ColWideMode mode, CUtensorMapSwizzle swizzle, CUtensorMapL2promotion l2Promotion, CUtensorMapFloatOOBfill oobFill);
CUresult CUDAAPI cuTensorMapReplaceAddress(CUtensorMap *tensorMap, void *globalAddress);
/* END CUDA_TENSOR_MEMORY */
CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev, CUdevice peerDev);
CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags);
CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext);
CUresult CUDAAPI cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib, CUdevice srcDevice, CUdevice dstDevice);
CUresult CUDAAPI cuDeviceGetP2PAtomicCapabilities(unsigned int* capabilities, const CUatomicOperation* operations, unsigned int count, CUdevice srcDevice, CUdevice dstDevice);
/* END CUDA_PEER_ACCESS */
CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource);
CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel);
CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource);
CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource);
CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags);
CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
/* END CUDA_GRAPHICS */
CUresult CUDAAPI cuGetProcAddress(const char *symbol, void **pfn, int cudaVersion, cuuint64_t flags, CUdriverProcAddressQueryResult *symbolStatus);
/* END CUDA_DRIVER_ENTRY_POINT */
typedef enum CUcoredumpSettings_enum {
CU_COREDUMP_ENABLE_ON_EXCEPTION = 1,
CU_COREDUMP_TRIGGER_HOST,
CU_COREDUMP_LIGHTWEIGHT,
CU_COREDUMP_ENABLE_USER_TRIGGER,
CU_COREDUMP_FILE,
CU_COREDUMP_PIPE,
CU_COREDUMP_GENERATION_FLAGS,
CU_COREDUMP_MAX
} CUcoredumpSettings;
typedef enum CUCoredumpGenerationFlags {
CU_COREDUMP_DEFAULT_FLAGS = 0,
CU_COREDUMP_SKIP_NONRELOCATED_ELF_IMAGES = (1 << 0),
CU_COREDUMP_SKIP_GLOBAL_MEMORY = (1 << 1),
CU_COREDUMP_SKIP_SHARED_MEMORY = (1 << 2),
CU_COREDUMP_SKIP_LOCAL_MEMORY = (1 << 3),
CU_COREDUMP_SKIP_ABORT = (1 << 4),
CU_COREDUMP_SKIP_CONSTBANK_MEMORY = (1 << 5),
CU_COREDUMP_GZIP_COMPRESS = (1 << 6),
CU_COREDUMP_FAULTED_CONTEXTS_ONLY = (1 << 7),
CU_COREDUMP_SKIP_TENSOR_MEMORY = (1 << 8),
CU_COREDUMP_NO_ERRBAR_AT_EXIT = (1 << 30),
CU_COREDUMP_LOG_ONLY = (1 << 31),
CU_COREDUMP_LIGHTWEIGHT_FLAGS = CU_COREDUMP_SKIP_NONRELOCATED_ELF_IMAGES
| CU_COREDUMP_SKIP_GLOBAL_MEMORY
| CU_COREDUMP_SKIP_SHARED_MEMORY
| CU_COREDUMP_SKIP_LOCAL_MEMORY
| CU_COREDUMP_SKIP_CONSTBANK_MEMORY
| CU_COREDUMP_SKIP_TENSOR_MEMORY
} CUCoredumpGenerationFlags;
CUresult CUDAAPI cuCoredumpGetAttribute(CUcoredumpSettings attrib, void *value, size_t *size);
CUresult CUDAAPI cuCoredumpGetAttributeGlobal(CUcoredumpSettings attrib, void *value, size_t *size);
CUresult CUDAAPI cuCoredumpSetAttribute(CUcoredumpSettings attrib, void *value, size_t *size);
CUresult CUDAAPI cuCoredumpSetAttributeGlobal(CUcoredumpSettings attrib, void *value, size_t *size);
typedef struct CUcoredumpCallbackEntry_st *CUcoredumpCallbackHandle;
typedef void (CUDA_CB *CUcoredumpStatusCallback)(void *userData, int pid, CUdevice dev);
CUresult CUDAAPI cuCoredumpRegisterStartCallback(CUcoredumpStatusCallback callback, void *userData, CUcoredumpCallbackHandle *callbackOut);
CUresult CUDAAPI cuCoredumpRegisterCompleteCallback(CUcoredumpStatusCallback callback, void *userData, CUcoredumpCallbackHandle *callbackOut);
CUresult CUDAAPI cuCoredumpDeregisterStartCallback(CUcoredumpCallbackHandle callback);
CUresult CUDAAPI cuCoredumpDeregisterCompleteCallback(CUcoredumpCallbackHandle callback);
/* END CUDA_COREDUMP */
CUresult CUDAAPI cuGetExportTable(const void **ppExportTable, const CUuuid *pExportTableId);
/*
** ******************* GREEN CONTEXTS **********************
*/
typedef struct CUdevResourceDesc_st *CUdevResourceDesc;
typedef enum {
CU_GREEN_CTX_NONE = 0x0,
CU_GREEN_CTX_DEFAULT_STREAM = 0x1,
} CUgreenCtxCreate_flags;
typedef enum {
CU_DEV_SM_RESOURCE_GROUP_DEFAULT = 0,
CU_DEV_SM_RESOURCE_GROUP_BACKFILL = 0x1,
CU_DEV_SM_RESOURCE_GROUP_LOCALITY_DOMAIN_ID = 0x1 << 1,
} CUdevSmResourceGroup_flags;
typedef enum {
CU_DEV_SM_RESOURCE_SPLIT_IGNORE_SM_COSCHEDULING = 0x1,
CU_DEV_SM_RESOURCE_SPLIT_MAX_POTENTIAL_CLUSTER_SIZE = 0x2,
} CUdevSmResourceSplitByCount_flags;
#define RESOURCE_ABI_VERSION 1
#define RESOURCE_ABI_BYTES 40
#define _CONCAT_INNER(x, y) x ## y
#define _CONCAT_OUTER(x, y) _CONCAT_INNER(x, y)
typedef enum {
CU_DEV_RESOURCE_TYPE_INVALID = 0,
CU_DEV_RESOURCE_TYPE_SM = 1,
CU_DEV_RESOURCE_TYPE_WORKQUEUE_CONFIG = 1000,
CU_DEV_RESOURCE_TYPE_WORKQUEUE = 10000,
} CUdevResourceType;
typedef struct CUdevSmResource_st {
unsigned int smCount;
unsigned int minSmPartitionSize;
unsigned int smCoscheduledAlignment;
unsigned int flags;
unsigned int localityDomainId;
} CUdevSmResource;
typedef enum {
CU_WORKQUEUE_SCOPE_DEVICE_CTX = 0,
CU_WORKQUEUE_SCOPE_GREEN_CTX_BALANCED = 1,
} CUdevWorkqueueConfigScope;
typedef struct CUdevWorkqueueConfigResource_st {
CUdevice device;
unsigned int wqConcurrencyLimit;
CUdevWorkqueueConfigScope sharingScope;
} CUdevWorkqueueConfigResource;
typedef struct CUdevWorkqueueResource_st {
unsigned char reserved[RESOURCE_ABI_BYTES];
} CUdevWorkqueueResource;
typedef struct CU_DEV_SM_RESOURCE_GROUP_PARAMS_st {
unsigned int smCount;
unsigned int coscheduledSmCount;
unsigned int preferredCoscheduledSmCount;
unsigned int flags;
unsigned int localityDomainId;
unsigned int reserved[11];
} CU_DEV_SM_RESOURCE_GROUP_PARAMS;
typedef struct CUdevResource_st {
CUdevResourceType type;
unsigned char _internal_padding[92];
union {
CUdevSmResource sm;
CUdevWorkqueueConfigResource wqConfig;
CUdevWorkqueueResource wq;
unsigned char _oversize[RESOURCE_ABI_BYTES];
};
struct CUdevResource_st* nextResource;
} _CONCAT_OUTER(CUdevResource_v, RESOURCE_ABI_VERSION);
typedef _CONCAT_OUTER(CUdevResource_v, RESOURCE_ABI_VERSION) CUdevResource;
#undef _CONCAT_INNER
#undef _CONCAT_OUTER
#undef RESOURCE_ABI_BYTES
#undef RESOURCE_ABI_VERSION
CUresult CUDAAPI cuGreenCtxCreate(CUgreenCtx *phCtx, CUdevResourceDesc desc, CUdevice dev, unsigned int flags);
CUresult CUDAAPI cuGreenCtxDestroy(CUgreenCtx hCtx);
CUresult CUDAAPI cuCtxFromGreenCtx(CUcontext *pContext, CUgreenCtx hCtx);
CUresult CUDAAPI cuDeviceGetDevResource(CUdevice device, CUdevResource* resource, CUdevResourceType type);
CUresult CUDAAPI cuCtxGetDevResource(CUcontext hCtx, CUdevResource* resource, CUdevResourceType type);
CUresult CUDAAPI cuGreenCtxGetDevResource(CUgreenCtx hCtx, CUdevResource* resource, CUdevResourceType type);
CUresult CUDAAPI cuDevSmResourceSplitByCount(
CUdevResource* result, unsigned int* nbGroups, const CUdevResource* input, CUdevResource* remainder, unsigned int flags, unsigned int minCount);
CUresult CUDAAPI cuDevSmResourceSplit(
CUdevResource* result, unsigned int nbGroups, const CUdevResource* input, CUdevResource* remainder, unsigned int flags, CU_DEV_SM_RESOURCE_GROUP_PARAMS* groupParams);
CUresult CUDAAPI cuDevResourceGenerateDesc(CUdevResourceDesc *phDesc, CUdevResource *resources, unsigned int nbResources);
CUresult CUDAAPI cuGreenCtxRecordEvent(CUgreenCtx hCtx, CUevent hEvent);
CUresult CUDAAPI cuGreenCtxWaitEvent(CUgreenCtx hCtx, CUevent hEvent);
CUresult CUDAAPI cuStreamGetGreenCtx(CUstream hStream, CUgreenCtx *phCtx);
CUresult CUDAAPI cuGreenCtxStreamCreate(CUstream* phStream, CUgreenCtx greenCtx, unsigned int flags, int priority);
CUresult CUDAAPI cuGreenCtxGetId(CUgreenCtx greenCtx, unsigned long long *greenCtxId);
CUresult CUDAAPI cuStreamGetDevResource(CUstream hStream, CUdevResource *resource, CUdevResourceType type);
/*
** *************** END CUDA_GREEN_CONTEXTS *****************
*/
typedef enum CUlogLevel_enum {
CU_LOG_LEVEL_ERROR = 0,
CU_LOG_LEVEL_WARNING = 1
} CUlogLevel;
typedef struct CUlogsCallbackEntry_st *CUlogsCallbackHandle;
typedef void (CUDA_CB *CUlogsCallback)(void *data, CUlogLevel logLevel, char *message, size_t length);
typedef unsigned int CUlogIterator;
CUresult CUDAAPI cuLogsRegisterCallback(CUlogsCallback callbackFunc, void *userData, CUlogsCallbackHandle *callback_out);
CUresult CUDAAPI cuLogsUnregisterCallback(CUlogsCallbackHandle callback);
CUresult CUDAAPI cuLogsCurrent(CUlogIterator *iterator_out, unsigned int flags);
CUresult CUDAAPI cuLogsDumpToFile(CUlogIterator *iterator, const char *pathToFile, unsigned int flags);
CUresult CUDAAPI cuLogsDumpToMemory(CUlogIterator *iterator, char *buffer, size_t *size, unsigned int flags);
/* END CUDA_LOGS */
typedef struct CUsemaphore_st *CUsemaphore;
typedef enum CUsemaphoreType_enum {
CU_SEMAPHORE_TYPE_BINARY = 1,
CU_SEMAPHORE_TYPE_TIMELINE = 2,
} CUsemaphoreType;
typedef enum CUsemaphoreHandleType_enum {
CU_SEMAPHORE_HANDLE_TYPE_NONE = 0,
CU_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1,
CU_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2,
} CUsemaphoreHandleType;
typedef struct CUDA_SEMAPHORE_CREATE_DESC_st {
CUsemaphoreType semaphoreType;
CUsemaphoreHandleType handleType;
union {
struct {
cuuint64_t initialValue;
} timeline;
struct {
cuuint32_t reserved[8];
} reserved;
} options;
unsigned int flags;
cuuint32_t reserved[3];
} CUDA_SEMAPHORE_CREATE_DESC_v1;
typedef CUDA_SEMAPHORE_CREATE_DESC_v1 CUDA_SEMAPHORE_CREATE_DESC;
typedef struct CUDA_SEMAPHORE_EXPORT_DESC_st {
CUsemaphoreHandleType handleType;
union {
struct {
int fd;
} fd;
struct {
void *securityAttributes;
void *name;
void *handle;
} win32;
struct {
cuuint32_t handle;
} win32Kmt;
struct {
cuuint32_t reserved[8];
} reserved;
} handle;
unsigned int flags;
} CUDA_SEMAPHORE_EXPORT_DESC_v1;
typedef CUDA_SEMAPHORE_EXPORT_DESC_v1 CUDA_SEMAPHORE_EXPORT_DESC;
CUresult CUDAAPI cuSemaphoreCreate(CUsemaphore *semaphore_out, CUDA_SEMAPHORE_CREATE_DESC *createDesc);
CUresult CUDAAPI cuSemaphoreExport(CUsemaphore semaphore, CUDA_SEMAPHORE_EXPORT_DESC *desc);
CUresult CUDAAPI cuSemaphoreDestroy(CUsemaphore semaphore);
#if defined(__CUDA_API_VERSION_INTERNAL)
#undef cuMemHostRegister
#undef cuGraphicsResourceSetMapFlags
#undef cuLinkCreate
#undef cuLinkAddData
#undef cuLinkAddFile
#undef cuDeviceTotalMem
#undef cuCtxCreate
#undef cuModuleGetGlobal
#undef cuMemGetInfo
#undef cuMemAlloc
#undef cuMemAllocPitch
#undef cuMemFree
#undef cuMemGetAddressRange
#undef cuMemAllocHost
#undef cuMemHostGetDevicePointer
#undef cuMemcpyHtoD
#undef cuMemcpyDtoH
#undef cuMemcpyDtoD
#undef cuMemcpyDtoA
#undef cuMemcpyAtoD
#undef cuMemcpyHtoA
#undef cuMemcpyAtoH
#undef cuMemcpyAtoA
#undef cuMemcpyHtoAAsync
#undef cuMemcpyAtoHAsync
#undef cuMemcpy2D
#undef cuMemcpy2DUnaligned
#undef cuMemcpy3D
#undef cuMemcpyHtoDAsync
#undef cuMemcpyDtoHAsync
#undef cuMemcpyDtoDAsync
#undef cuMemcpy2DAsync
#undef cuMemcpy3DAsync
#undef cuMemcpyBatchAsync
#undef cuMemcpy3DBatchAsync
#undef cuMemcpyWithAttributesAsync
#undef cuMemcpy3DWithAttributesAsync
#undef cuMemsetD8
#undef cuMemsetD16
#undef cuMemsetD32
#undef cuMemsetD2D8
#undef cuMemsetD2D16
#undef cuMemsetD2D32
#undef cuArrayCreate
#undef cuArrayGetDescriptor
#undef cuArray3DCreate
#undef cuArray3DGetDescriptor
#undef cuTexRefSetAddress
#undef cuTexRefSetAddress2D
#undef cuTexRefGetAddress
#undef cuGraphicsResourceGetMappedPointer
#undef cuCtxDestroy
#undef cuCtxPopCurrent
#undef cuCtxPushCurrent
#undef cuStreamDestroy
#undef cuEventDestroy
#undef cuEventElapsedTime
#undef cuMemcpy
#undef cuMemcpyAsync
#undef cuMemcpyPeer
#undef cuMemcpyPeerAsync
#undef cuMemcpy3DPeer
#undef cuMemcpy3DPeerAsync
#undef cuMemsetD8Async
#undef cuMemsetD16Async
#undef cuMemsetD32Async
#undef cuMemsetD2D8Async
#undef cuMemsetD2D16Async
#undef cuMemsetD2D32Async
#undef cuStreamGetPriority
#undef cuStreamGetId
#undef cuStreamGetFlags
#undef cuStreamGetDevice
#undef cuStreamGetDevResource
#undef cuStreamGetCtx
#undef cuStreamWaitEvent
#undef cuStreamAddCallback
#undef cuStreamAttachMemAsync
#undef cuStreamQuery
#undef cuStreamSynchronize
#undef cuEventRecord
#undef cuEventRecordWithFlags
#undef cuLaunchKernel
#undef cuLaunchKernelEx
#undef cuLaunchHostFunc
#undef cuLaunchHostFunc_v2
#undef cuGraphicsMapResources
#undef cuGraphicsUnmapResources
#undef cuStreamWriteValue32
#undef cuStreamWaitValue32
#undef cuStreamWriteValue64
#undef cuStreamWaitValue64
#undef cuStreamBatchMemOp
#undef cuStreamWriteValue32_v2
#undef cuStreamWaitValue32_v2
#undef cuStreamWriteValue64_v2
#undef cuStreamWaitValue64_v2
#undef cuStreamBatchMemOp_v2
#undef cuMemPrefetchAsync
#undef cuMemAdvise
#undef cuMemPrefetchBatchAsync
#undef cuMemDiscardBatchAsync
#undef cuMemDiscardAndPrefetchBatchAsync
#undef cuLaunchCooperativeKernel
#undef cuSignalExternalSemaphoresAsync
#undef cuWaitExternalSemaphoresAsync
#undef cuStreamBeginCapture
#undef cuStreamBeginCaptureToGraph
#undef cuStreamBeginRecaptureToGraph
#undef cuStreamEndCapture
#undef cuStreamIsCapturing
#undef cuStreamGetCaptureInfo
#undef cuGraphInstantiateWithParams
#undef cuGraphExecUpdate
#undef cuGraphUpload
#undef cuGraphLaunch
#undef cuDevicePrimaryCtxRelease
#undef cuDevicePrimaryCtxReset
#undef cuDevicePrimaryCtxSetFlags
#undef cuDeviceGetUuid
#undef cuIpcOpenMemHandle
#undef cuStreamCopyAttributes
#undef cuStreamSetAttribute
#undef cuStreamGetAttribute
#undef cuGraphInstantiate
#undef cuGraphAddKernelNode
#undef cuGraphKernelNodeGetParams
#undef cuGraphKernelNodeSetParams
#undef cuGraphExecKernelNodeSetParams
#undef cuGraphGetEdges
#undef cuGraphNodeGetDependencies
#undef cuGraphNodeGetDependentNodes
#undef cuGraphAddDependencies
#undef cuGraphRemoveDependencies
#undef cuGraphAddNode
#undef cuGraphNodeSetParams
#undef cuMemMapArrayAsync
#undef cuMemFreeAsync
#undef cuMemAllocAsync
#undef cuMemAllocFromPoolAsync
#undef cuStreamUpdateCaptureDependencies
#undef cuGetProcAddress
#undef cuStreamGetCtx_v2
#undef cuMemBatchDecompressAsync
#undef cuStreamBeginCaptureToCig
#undef cuStreamEndCaptureToCig
CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags);
CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags);
CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues, CUlinkState *stateOut);
CUresult CUDAAPI cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, const char *name,
unsigned int numOptions, CUjit_option *options, void **optionValues);
CUresult CUDAAPI cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path,
unsigned int numOptions, CUjit_option *options, void **optionValues);
CUresult CUDAAPI cuTexRefSetAddress2D_v2(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch);
typedef unsigned int CUdeviceptr_v1;
typedef struct CUDA_MEMCPY2D_v1_st
{
unsigned int srcXInBytes;
unsigned int srcY;
CUmemorytype srcMemoryType;
const void *srcHost;
CUdeviceptr_v1 srcDevice;
CUarray srcArray;
unsigned int srcPitch;
unsigned int dstXInBytes;
unsigned int dstY;
CUmemorytype dstMemoryType;
void *dstHost;
CUdeviceptr_v1 dstDevice;
CUarray dstArray;
unsigned int dstPitch;
unsigned int WidthInBytes;
unsigned int Height;
} CUDA_MEMCPY2D_v1;
typedef struct CUDA_MEMCPY3D_v1_st
{
unsigned int srcXInBytes;
unsigned int srcY;
unsigned int srcZ;
unsigned int srcLOD;
CUmemorytype srcMemoryType;
const void *srcHost;
CUdeviceptr_v1 srcDevice;
CUarray srcArray;
void *reserved0;
unsigned int srcPitch;
unsigned int srcHeight;
unsigned int dstXInBytes;
unsigned int dstY;
unsigned int dstZ;
unsigned int dstLOD;
CUmemorytype dstMemoryType;
void *dstHost;
CUdeviceptr_v1 dstDevice;
CUarray dstArray;
void *reserved1;
unsigned int dstPitch;
unsigned int dstHeight;
unsigned int WidthInBytes;
unsigned int Height;
unsigned int Depth;
} CUDA_MEMCPY3D_v1;
typedef struct CUDA_ARRAY_DESCRIPTOR_v1_st
{
unsigned int Width;
unsigned int Height;
CUarray_format Format;
unsigned int NumChannels;
} CUDA_ARRAY_DESCRIPTOR_v1;
typedef struct CUDA_ARRAY3D_DESCRIPTOR_v1_st
{
unsigned int Width;
unsigned int Height;
unsigned int Depth;
CUarray_format Format;
unsigned int NumChannels;
unsigned int Flags;
} CUDA_ARRAY3D_DESCRIPTOR_v1;
CUresult CUDAAPI cuDeviceTotalMem(unsigned int *bytes, CUdevice dev);
CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags, CUdevice dev);
CUresult CUDAAPI cuCtxCreate_v2(CUcontext *pctx, unsigned int flags, CUdevice dev);
CUresult CUDAAPI cuCtxCreate_v3(CUcontext *pctx, CUexecAffinityParam *paramsArray, int numParams, unsigned int flags, CUdevice dev);
CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr_v1 *dptr, unsigned int *bytes, CUmodule hmod, const char *name);
CUresult CUDAAPI cuMemGetInfo(unsigned int *free, unsigned int *total);
CUresult CUDAAPI cuMemAlloc(CUdeviceptr_v1 *dptr, unsigned int bytesize);
CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr_v1 *dptr, unsigned int *pPitch, unsigned int WidthInBytes, unsigned int Height, unsigned int ElementSizeBytes);
CUresult CUDAAPI cuMemFree(CUdeviceptr_v1 dptr);
CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr_v1 *pbase, unsigned int *psize, CUdeviceptr_v1 dptr);
CUresult CUDAAPI cuMemAllocHost(void **pp, unsigned int bytesize);
CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr_v1 *pdptr, void *p, unsigned int Flags);
CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr_v1 dstDevice, const void *srcHost, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr_v1 srcDevice, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr_v1 dstDevice, CUdeviceptr_v1 srcDevice, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, unsigned int dstOffset, CUdeviceptr_v1 srcDevice, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr_v1 dstDevice, CUarray srcArray, unsigned int srcOffset, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, unsigned int dstOffset, const void *srcHost, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, unsigned int srcOffset, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, unsigned int dstOffset, CUarray srcArray, unsigned int srcOffset, unsigned int ByteCount);
CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, unsigned int dstOffset, const void *srcHost, unsigned int ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, unsigned int srcOffset, unsigned int ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D_v1 *pCopy);
CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D_v1 *pCopy);
CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D_v1 *pCopy);
CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr_v1 dstDevice, const void *srcHost, unsigned int ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr_v1 srcDevice, unsigned int ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr_v1 dstDevice, CUdeviceptr_v1 srcDevice, unsigned int ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D_v1 *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D_v1 *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemsetD8(CUdeviceptr_v1 dstDevice, unsigned char uc, unsigned int N);
CUresult CUDAAPI cuMemsetD16(CUdeviceptr_v1 dstDevice, unsigned short us, unsigned int N);
CUresult CUDAAPI cuMemsetD32(CUdeviceptr_v1 dstDevice, unsigned int ui, unsigned int N);
CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr_v1 dstDevice, unsigned int dstPitch, unsigned char uc, unsigned int Width, unsigned int Height);
CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr_v1 dstDevice, unsigned int dstPitch, unsigned short us, unsigned int Width, unsigned int Height);
CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr_v1 dstDevice, unsigned int dstPitch, unsigned int ui, unsigned int Width, unsigned int Height);
CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR_v1 *pAllocateArray);
CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR_v1 *pArrayDescriptor, CUarray hArray);
CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR_v1 *pAllocateArray);
CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR_v1 *pArrayDescriptor, CUarray hArray);
CUresult CUDAAPI cuTexRefSetAddress(unsigned int *ByteOffset, CUtexref hTexRef, CUdeviceptr_v1 dptr, unsigned int bytes);
CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR_v1 *desc, CUdeviceptr_v1 dptr, unsigned int Pitch);
CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr_v1 *pdptr, CUtexref hTexRef);
CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr_v1 *pDevPtr, unsigned int *pSize, CUgraphicsResource resource);
CUresult CUDAAPI cuCtxDestroy(CUcontext ctx);
CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx);
CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx);
CUresult CUDAAPI cuStreamDestroy(CUstream hStream);
CUresult CUDAAPI cuEventDestroy(CUevent hEvent);
CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUevent hEnd);
CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev);
CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev);
CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags);
CUresult CUDAAPI cuDeviceGetUuid(CUuuid *uuid, CUdevice dev);
CUresult CUDAAPI cuMemcpyHtoD_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoH_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoD_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyDtoA_v2(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoD_v2(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpyHtoA_v2(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoH_v2(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAtoA_v2(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount);
CUresult CUDAAPI cuMemcpyHtoAAsync_v2(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyAtoHAsync_v2(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy2D_v2(const CUDA_MEMCPY2D *pCopy);
CUresult CUDAAPI cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *pCopy);
CUresult CUDAAPI cuMemcpy3D_v2(const CUDA_MEMCPY3D *pCopy);
CUresult CUDAAPI cuMemcpyHtoDAsync_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoHAsync_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyDtoDAsync_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemsetD8_v2(CUdeviceptr dstDevice, unsigned char uc, size_t N);
CUresult CUDAAPI cuMemsetD16_v2(CUdeviceptr dstDevice, unsigned short us, size_t N);
CUresult CUDAAPI cuMemsetD32_v2(CUdeviceptr dstDevice, unsigned int ui, size_t N);
CUresult CUDAAPI cuMemsetD2D8_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height);
CUresult CUDAAPI cuMemsetD2D16_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height);
CUresult CUDAAPI cuMemsetD2D32_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height);
CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount);
CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount);
CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy);
CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream);
CUresult CUDAAPI cuMemcpyBatchAsync(CUdeviceptr *dsts, CUdeviceptr *srcs, size_t *sizes, size_t count,
CUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs,
size_t *failIdx, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DBatchAsync(size_t numOps, CUDA_MEMCPY3D_BATCH_OP *opList,
size_t *failIdx, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemcpyBatchAsync_ptsz(CUdeviceptr *dsts, CUdeviceptr *srcs, size_t *sizes, size_t count,
CUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DBatchAsync_ptsz(size_t numOps, CUDA_MEMCPY3D_BATCH_OP *opList, size_t *failIdx, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemcpyBatchAsync_v2(CUdeviceptr *dsts, CUdeviceptr *srcs, size_t *sizes, size_t count,
CUmemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DBatchAsync_v2(size_t numOps, CUDA_MEMCPY3D_BATCH_OP *opList, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemcpyWithAttributesAsync(CUdeviceptr dst, CUdeviceptr src, size_t size, CUmemcpyAttributes *attr, CUstream hStream);
CUresult CUDAAPI cuMemcpy3DWithAttributesAsync(CUDA_MEMCPY3D_BATCH_OP *op, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream);
CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority);
CUresult CUDAAPI cuStreamGetId(CUstream hStream, unsigned long long *streamId);
CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags);
CUresult CUDAAPI cuStreamGetDevice(CUstream hStream, CUdevice *device);
CUresult CUDAAPI cuStreamGetDevResource(CUstream hStream, CUdevResource* resource, CUdevResourceType type);
CUresult CUDAAPI cuStreamGetCtx(CUstream hStream, CUcontext *pctx);
CUresult CUDAAPI cuStreamGetCtx_v2(CUstream hStream, CUcontext *pCtx, CUgreenCtx *pGreenCtx);
CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags);
CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags);
CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags);
CUresult CUDAAPI cuStreamQuery(CUstream hStream);
CUresult CUDAAPI cuStreamSynchronize(CUstream hStream);
CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream);
CUresult CUDAAPI cuEventRecordWithFlags(CUevent hEvent, CUstream hStream, unsigned int flags);
CUresult CUDAAPI cuLaunchKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void **kernelParams, void **extra);
CUresult CUDAAPI cuLaunchKernelEx(const CUlaunchConfig *config, CUfunction f, void **kernelParams, void **extra);
CUresult CUDAAPI cuLaunchHostFunc(CUstream hStream, CUhostFn fn, void *userData);
CUresult CUDAAPI cuLaunchHostFunc_v2(CUstream hStream, CUhostFn fn, void *userData, unsigned int syncMode);
CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream);
CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue32_ptsz(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue32_ptsz(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue64_ptsz(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue64_ptsz(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamBatchMemOp_ptsz(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue32_v2(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue32_v2(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWriteValue64_v2(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamWaitValue64_v2(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags);
CUresult CUDAAPI cuStreamBatchMemOp_v2(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags);
CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream);
CUresult CUDAAPI cuMemPrefetchAsync_ptsz(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream);
CUresult CUDAAPI cuMemPrefetchAsync_v2(CUdeviceptr devPtr, size_t count, CUmemLocation location, unsigned int flags, CUstream hStream);
CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUdevice device);
CUresult CUDAAPI cuMemPrefetchBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count, CUmemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemDiscardBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuMemDiscardAndPrefetchBatchAsync(CUdeviceptr *dptrs, size_t *sizes, size_t count, CUmemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, CUstream hStream);
CUresult CUDAAPI cuLaunchCooperativeKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void **kernelParams);
CUresult CUDAAPI cuSignalExternalSemaphoresAsync(const CUexternalSemaphore *extSemArray, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *paramsArray, unsigned int numExtSems, CUstream stream);
CUresult CUDAAPI cuWaitExternalSemaphoresAsync(const CUexternalSemaphore *extSemArray, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *paramsArray, unsigned int numExtSems, CUstream stream);
CUresult CUDAAPI cuStreamBeginCapture(CUstream hStream);
CUresult CUDAAPI cuStreamBeginCapture_ptsz(CUstream hStream);
CUresult CUDAAPI cuStreamBeginCapture_v2(CUstream hStream, CUstreamCaptureMode mode);
CUresult CUDAAPI cuStreamBeginCaptureToGraph(CUstream hStream, CUgraph hGraph, const CUgraphNode *dependencies, const CUgraphEdgeData *dependencyData, size_t numDependencies, CUstreamCaptureMode mode);
CUresult CUDAAPI cuStreamBeginRecaptureToGraph(CUstream hStream, CUstreamCaptureMode mode, CUgraph hGraph, CUgraphRecaptureCallback callbackFunc, void *userData);
CUresult CUDAAPI cuStreamEndCapture(CUstream hStream, CUgraph *phGraph);
CUresult CUDAAPI cuStreamIsCapturing(CUstream hStream, CUstreamCaptureStatus *captureStatus);
CUresult CUDAAPI cuStreamGetCaptureInfo(CUstream hStream, CUstreamCaptureStatus *captureStatus_out, cuuint64_t *id_out);
CUresult CUDAAPI cuStreamGetCaptureInfo_ptsz(CUstream hStream, CUstreamCaptureStatus *captureStatus_out, cuuint64_t *id_out);
CUresult CUDAAPI cuStreamGetCaptureInfo_v2(CUstream hStream, CUstreamCaptureStatus *captureStatus_out, cuuint64_t *id_out, CUgraph *graph_out, const CUgraphNode **dependencies_out, size_t *numDependencies_out);
CUresult CUDAAPI cuStreamGetCaptureInfo_v2_ptsz(CUstream hStream, CUstreamCaptureStatus *captureStatus_out, cuuint64_t *id_out, CUgraph *graph_out, const CUgraphNode **dependencies_out, size_t *numDependencies_out);
CUresult CUDAAPI cuStreamGetCaptureInfo_v3(CUstream hStream, CUstreamCaptureStatus *captureStatus_out, cuuint64_t *id_out, CUgraph *graph_out, const CUgraphNode **dependencies_out, const CUgraphEdgeData **edgeData_out, size_t *numDependencies_out);
CUresult CUDAAPI cuGraphAddKernelNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS_v1 *nodeParams);
CUresult CUDAAPI cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS_v1 *nodeParams);
CUresult CUDAAPI cuGraphKernelNodeSetParams(CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS_v1 *nodeParams);
CUresult CUDAAPI cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS_v1 *nodeParams);
CUresult CUDAAPI cuGraphInstantiateWithParams(CUgraphExec *phGraphExec, CUgraph hGraph, CUDA_GRAPH_INSTANTIATE_PARAMS *instantiateParams);
CUresult CUDAAPI cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraphNode *hErrorNode_out, CUgraphExecUpdateResult *updateResult_out);
CUresult CUDAAPI cuGraphUpload(CUgraphExec hGraph, CUstream hStream);
CUresult CUDAAPI cuGraphLaunch(CUgraphExec hGraph, CUstream hStream);
CUresult CUDAAPI cuGraphGetEdges(CUgraph hGraph, CUgraphNode *from, CUgraphNode *to, size_t *numEdges);
CUresult CUDAAPI cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode *dependencies, size_t *numDependencies);
CUresult CUDAAPI cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode *dependentNodes, size_t *numDependentNodes);
CUresult CUDAAPI cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode *from, const CUgraphNode *to, size_t numDependencies);
CUresult CUDAAPI cuGraphRemoveDependencies(CUgraph hGraph, const CUgraphNode *from, const CUgraphNode *to, size_t numDependencies);
CUresult CUDAAPI cuGraphAddNode(CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, size_t numDependencies, CUgraphNodeParams *nodeParams);
CUresult CUDAAPI cuStreamCopyAttributes(CUstream dstStream, CUstream srcStream);
CUresult CUDAAPI cuStreamGetAttribute(CUstream hStream, CUstreamAttrID attr, CUstreamAttrValue *value);
CUresult CUDAAPI cuStreamSetAttribute(CUstream hStream, CUstreamAttrID attr, const CUstreamAttrValue *param);
CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int Flags);
CUresult CUDAAPI cuGraphInstantiate(CUgraphExec *phGraphExec, CUgraph hGraph, CUgraphNode *phErrorNode, char *logBuffer, size_t bufferSize);
CUresult CUDAAPI cuGraphInstantiate_v2(CUgraphExec *phGraphExec, CUgraph hGraph, CUgraphNode *phErrorNode, char *logBuffer, size_t bufferSize);
CUresult CUDAAPI cuMemMapArrayAsync(CUarrayMapInfo *mapInfoList, unsigned int count, CUstream hStream);
CUresult CUDAAPI cuMemFreeAsync(CUdeviceptr dptr, CUstream hStream);
CUresult CUDAAPI cuMemAllocAsync(CUdeviceptr *dptr, size_t bytesize, CUstream hStream);
CUresult CUDAAPI cuMemAllocFromPoolAsync(CUdeviceptr *dptr, size_t bytesize, CUmemoryPool pool, CUstream hStream);
CUresult CUDAAPI cuStreamUpdateCaptureDependencies(CUstream hStream, CUgraphNode *dependencies, size_t numDependencies, unsigned int flags);
CUresult CUDAAPI cuStreamUpdateCaptureDependencies_ptsz(CUstream hStream, CUgraphNode *dependencies, size_t numDependencies, unsigned int flags);
CUresult CUDAAPI cuStreamUpdateCaptureDependencies_v2(CUstream hStream, CUgraphNode *dependencies, const CUgraphEdgeData *dependencyData, size_t numDependencies, unsigned int flags);
CUresult CUDAAPI cuStreamBeginCaptureToCig(CUstream hStream, CUstreamCigCaptureParams* streamCigCaptureParams);
CUresult CUDAAPI cuStreamEndCaptureToCig(CUstream hStream);
CUresult CUDAAPI cuMemBatchDecompressAsync(
CUmemDecompressParams *paramsArray,
size_t count,
unsigned int flags,
size_t *errorIndex,
CUstream stream
);
CUresult CUDAAPI cuGetProcAddress(const char *symbol, void **pfn, int cudaVersion, cuuint64_t flags);
#elif defined(__CUDA_API_PER_THREAD_DEFAULT_STREAM)
static inline CUresult cuGetProcAddress_v2_ptsz(const char *symbol, void **funcPtr, int driverVersion, cuuint64_t flags, CUdriverProcAddressQueryResult *symbolStatus) {
const int procAddressMask = (CU_GET_PROC_ADDRESS_LEGACY_STREAM|
CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM);
if ((flags & procAddressMask) == 0) {
flags |= CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM;
}
return cuGetProcAddress_v2(symbol, funcPtr, driverVersion, flags, symbolStatus);
}
#define cuGetProcAddress_v2 cuGetProcAddress_v2_ptsz
#endif
CUresult CUDAAPI cuCheckpointProcessGetRestoreThreadId(int pid, int *tid);
CUresult CUDAAPI cuCheckpointProcessGetState(int pid, CUprocessState *state);
CUresult CUDAAPI cuCheckpointProcessLock(int pid, CUcheckpointLockArgs *args);
CUresult CUDAAPI cuCheckpointProcessCheckpoint(int pid, CUcheckpointCheckpointArgs *args);
CUresult CUDAAPI cuCheckpointProcessRestore(int pid, CUcheckpointRestoreArgs *args);
CUresult CUDAAPI cuCheckpointOperationComplete(CUcheckpointOperationHandle handle);
CUresult CUDAAPI cuCheckpointProcessUnlock(int pid, CUcheckpointUnlockArgs *args);
/* End CUDA_CHECKPOINT */
#ifdef __cplusplus
}
#endif
#if defined(__GNUC__)
#if defined(__CUDA_API_PUSH_VISIBILITY_DEFAULT)
#pragma GCC visibility pop
#endif
#endif
#undef __CUDA_DEPRECATED
#endif /* __cuda_cuda_h__ */