diff options
Diffstat (limited to 'libcuda')
| -rw-r--r-- | libcuda/Makefile | 4 | ||||
| -rw-r--r-- | libcuda/cuda_api.h | 9954 | ||||
| -rw-r--r-- | libcuda/cuda_api_object.h | 217 | ||||
| -rw-r--r-- | libcuda/cuda_runtime_api.cc | 10851 | ||||
| -rw-r--r-- | libcuda/cuobjdump.h | 81 | ||||
| -rw-r--r-- | libcuda/cuobjdump.l | 56 | ||||
| -rw-r--r-- | libcuda/cuobjdump.y | 77 | ||||
| -rw-r--r-- | libcuda/gpgpu_context.h | 83 |
8 files changed, 13277 insertions, 8046 deletions
diff --git a/libcuda/Makefile b/libcuda/Makefile index 13932e2..c8ff2e3 100644 --- a/libcuda/Makefile +++ b/libcuda/Makefile @@ -111,10 +111,10 @@ $(OUTPUT_DIR)/%.o: %.cc $(CPP) $(CXXFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@ $(OUTPUT_DIR)/%.o: %.c - $(CC) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@ + $(CPP) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@ $(OUTPUT_DIR)/%.o: $(OUTPUT_DIR)/%.c - $(CC) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@ + $(CPP) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@ $(OUTPUT_DIR)/cuobjdump_parser.c: cuobjdump.y $(YACC) $(YFLAGS) -p cuobjdump_ -o$@ $< --file-prefix=$(OUTPUT_DIR)/cuobjdump diff --git a/libcuda/cuda_api.h b/libcuda/cuda_api.h index 0ded242..5a970ba 100644 --- a/libcuda/cuda_api.h +++ b/libcuda/cuda_api.h @@ -1,5 +1,5 @@ /* - * Copyright 1993-2014 NVIDIA Corporation. All rights reserved. + * Copyright 1993-2018 NVIDIA Corporation. All rights reserved. * * NOTICE TO LICENSEE: * @@ -63,120 +63,160 @@ typedef uint64_t cuuint64_t; /** * CUDA API versioning support */ +#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) - #if (CUDA_FORCE_API_VERSION == 3010) - #define __CUDA_API_VERSION 3010 - #else - #error "Unsupported value of CUDA_FORCE_API_VERSION" - #endif +#if (CUDA_FORCE_API_VERSION == 3010) +#define __CUDA_API_VERSION 3010 +#else +#error "Unsupported value of CUDA_FORCE_API_VERSION" +#endif #else - #define __CUDA_API_VERSION 8000 +#define __CUDA_API_VERSION 10010 #endif /* CUDA_FORCE_API_VERSION */ -#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 +#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 +#define __CUDA_API_PTDS(api) api +#define __CUDA_API_PTSZ(api) api #endif #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 3020 - #define cuDeviceTotalMem cuDeviceTotalMem_v2 - #define cuCtxCreate cuCtxCreate_v2 - #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 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 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 cuDeviceTotalMem cuDeviceTotalMem_v2 +#define cuCtxCreate cuCtxCreate_v2 +#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 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 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 #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 3020 */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 4000 - #define cuCtxDestroy cuCtxDestroy_v2 - #define cuCtxPopCurrent cuCtxPopCurrent_v2 - #define cuCtxPushCurrent cuCtxPushCurrent_v2 - #define cuStreamDestroy cuStreamDestroy_v2 - #define cuEventDestroy cuEventDestroy_v2 +#define cuCtxDestroy cuCtxDestroy_v2 +#define cuCtxPopCurrent cuCtxPopCurrent_v2 +#define cuCtxPushCurrent cuCtxPushCurrent_v2 +#define cuStreamDestroy cuStreamDestroy_v2 +#define cuEventDestroy cuEventDestroy_v2 #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 4000 */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 4010 - #define cuTexRefSetAddress2D cuTexRefSetAddress2D_v3 +#define cuTexRefSetAddress2D cuTexRefSetAddress2D_v3 #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 4010 */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 6050 - #define cuMemHostRegister cuMemHostRegister_v2 - #define cuGraphicsResourceSetMapFlags cuGraphicsResourceSetMapFlags_v2 +#define cuLinkCreate cuLinkCreate_v2 +#define cuLinkAddData cuLinkAddData_v2 +#define cuLinkAddFile cuLinkAddFile_v2 +#endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 6050 */ +#if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 6050 +#define cuMemHostRegister cuMemHostRegister_v2 +#define cuGraphicsResourceSetMapFlags cuGraphicsResourceSetMapFlags_v2 #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 6050 */ +#if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION >= 10010 +#define cuStreamBeginCapture __CUDA_API_PTSZ(cuStreamBeginCapture_v2) +#elif defined(__CUDA_API_PER_THREAD_DEFAULT_STREAM) +#define cuStreamBeginCapture __CUDA_API_PTSZ(cuStreamBeginCapture) +#endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION >= 10010 */ #if !defined(__CUDA_API_VERSION_INTERNAL) -#if defined(__CUDA_API_VERSION) && __CUDA_API_VERSION >= 3020 && __CUDA_API_VERSION < 4010 - #define cuTexRefSetAddress2D cuTexRefSetAddress2D_v2 -#endif /* __CUDA_API_VERSION && __CUDA_API_VERSION >= 3020 && __CUDA_API_VERSION < 4010 */ +#if defined(__CUDA_API_VERSION) && __CUDA_API_VERSION >= 3020 && \ + __CUDA_API_VERSION < 4010 +#define cuTexRefSetAddress2D cuTexRefSetAddress2D_v2 +#endif /* __CUDA_API_VERSION && __CUDA_API_VERSION >= 3020 && \ + __CUDA_API_VERSION < 4010 */ #endif /* __CUDA_API_VERSION_INTERNAL */ #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 cuMemPrefetchAsync __CUDA_API_PTSZ(cuMemPrefetchAsync) +#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 cuMemPrefetchAsync __CUDA_API_PTSZ(cuMemPrefetchAsync) + +#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 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 cuStreamGetFlags __CUDA_API_PTSZ(cuStreamGetFlags) +#define cuStreamGetCtx __CUDA_API_PTSZ(cuStreamGetCtx) +#define cuStreamWaitEvent __CUDA_API_PTSZ(cuStreamWaitEvent) +#define cuStreamEndCapture __CUDA_API_PTSZ(cuStreamEndCapture) +#define cuStreamIsCapturing __CUDA_API_PTSZ(cuStreamIsCapturing) +#define cuStreamGetCaptureInfo __CUDA_API_PTSZ(cuStreamGetCaptureInfo) +#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 cuLaunchKernel __CUDA_API_PTSZ(cuLaunchKernel) +#define cuLaunchHostFunc __CUDA_API_PTSZ(cuLaunchHostFunc) +#define cuGraphicsMapResources __CUDA_API_PTSZ(cuGraphicsMapResources) +#define cuGraphicsUnmapResources __CUDA_API_PTSZ(cuGraphicsUnmapResources) - #define cuStreamGetPriority __CUDA_API_PTSZ(cuStreamGetPriority) - #define cuStreamGetFlags __CUDA_API_PTSZ(cuStreamGetFlags) - #define cuStreamWaitEvent __CUDA_API_PTSZ(cuStreamWaitEvent) - #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 cuLaunchKernel __CUDA_API_PTSZ(cuLaunchKernel) - #define cuGraphicsMapResources __CUDA_API_PTSZ(cuGraphicsMapResources) - #define cuGraphicsUnmapResources __CUDA_API_PTSZ(cuGraphicsUnmapResources) +#define cuStreamWriteValue32 __CUDA_API_PTSZ(cuStreamWriteValue32) +#define cuStreamWaitValue32 __CUDA_API_PTSZ(cuStreamWaitValue32) +#define cuStreamWriteValue64 __CUDA_API_PTSZ(cuStreamWriteValue64) +#define cuStreamWaitValue64 __CUDA_API_PTSZ(cuStreamWaitValue64) +#define cuStreamBatchMemOp __CUDA_API_PTSZ(cuStreamBatchMemOp) - #define cuStreamWriteValue32 __CUDA_API_PTSZ(cuStreamWriteValue32) - #define cuStreamWaitValue32 __CUDA_API_PTSZ(cuStreamWaitValue32) - #define cuStreamBatchMemOp __CUDA_API_PTSZ(cuStreamBatchMemOp) +#define cuLaunchCooperativeKernel __CUDA_API_PTSZ(cuLaunchCooperativeKernel) + +#define cuSignalExternalSemaphoresAsync \ + __CUDA_API_PTSZ(cuSignalExternalSemaphoresAsync) +#define cuWaitExternalSemaphoresAsync \ + __CUDA_API_PTSZ(cuWaitExternalSemaphoresAsync) + +#define cuGraphLaunch __CUDA_API_PTSZ(cuGraphLaunch) #endif /** @@ -200,7 +240,7 @@ typedef uint64_t cuuint64_t; /** * CUDA API version number */ -#define CUDA_VERSION 8000 +#define CUDA_VERSION 10010 #ifdef __cplusplus extern "C" { @@ -208,8 +248,9 @@ extern "C" { /** * CUDA device pointer - * CUdeviceptr is defined as an unsigned integer type whose size matches the size of a pointer on the target platform. - */ + * CUdeviceptr is defined as an unsigned integer type whose size matches the + * size of a pointer on the target platform. + */ #if __CUDA_API_VERSION >= 3020 #if defined(_WIN64) || defined(__LP64__) @@ -220,30 +261,41 @@ typedef unsigned int CUdeviceptr; #endif /* __CUDA_API_VERSION >= 3020 */ -typedef int CUdevice; /**< CUDA device */ -typedef struct CUctx_st *CUcontext; /**< CUDA context */ -typedef struct CUmod_st *CUmodule; /**< CUDA module */ -typedef struct CUfunc_st *CUfunction; /**< CUDA function */ -typedef struct CUarray_st *CUarray; /**< CUDA array */ -typedef struct CUmipmappedArray_st *CUmipmappedArray; /**< CUDA mipmapped array */ -typedef struct CUtexref_st *CUtexref; /**< CUDA texture reference */ -typedef struct CUsurfref_st *CUsurfref; /**< CUDA surface reference */ -typedef struct CUevent_st *CUevent; /**< CUDA event */ -typedef struct CUstream_st *CUstream; /**< CUDA stream */ -typedef struct CUgraphicsResource_st *CUgraphicsResource; /**< CUDA graphics interop resource */ -typedef unsigned long long CUtexObject; /**< An opaque value that represents a CUDA texture object */ -typedef unsigned long long CUsurfObject; /**< An opaque value that represents a CUDA surface object */ +typedef int CUdevice; /**< CUDA device */ +typedef struct CUctx_st *CUcontext; /**< CUDA context */ +typedef struct CUmod_st *CUmodule; /**< CUDA module */ +typedef struct CUfunc_st *CUfunction; /**< CUDA function */ +typedef struct CUarray_st *CUarray; /**< CUDA array */ +typedef struct CUmipmappedArray_st + *CUmipmappedArray; /**< CUDA mipmapped array */ +typedef struct CUtexref_st *CUtexref; /**< CUDA texture reference */ +typedef struct CUsurfref_st *CUsurfref; /**< CUDA surface reference */ +typedef struct CUevent_st *CUevent; /**< CUDA event */ +typedef struct CUstream_st *CUstream; /**< CUDA stream */ +typedef struct CUgraphicsResource_st + *CUgraphicsResource; /**< CUDA graphics interop resource */ +typedef unsigned long long + CUtexObject; /**< An opaque value that represents a CUDA texture object */ +typedef unsigned long long + CUsurfObject; /**< An opaque value that represents a CUDA surface object */ +typedef struct CUextMemory_st *CUexternalMemory; /**< CUDA external memory */ +typedef struct CUextSemaphore_st + *CUexternalSemaphore; /**< CUDA external semaphore */ +typedef struct CUgraph_st *CUgraph; /**< CUDA graph */ +typedef struct CUgraphNode_st *CUgraphNode; /**< CUDA graph node */ +typedef struct CUgraphExec_st *CUgraphExec; /**< CUDA executable graph */ -#if CUDART_VERSION < 10000 -typedef struct CUuuid_st { /**< CUDA definition of UUID */ - char bytes[16]; +#ifndef CU_UUID_HAS_BEEN_DEFINED +#define CU_UUID_HAS_BEEN_DEFINED +typedef struct CUuuid_st { /**< CUDA definition of UUID */ + char bytes[16]; } CUuuid; -#endif // #if CUDART_VERSION < 10000 +#endif #if __CUDA_API_VERSION >= 4010 /** - * CUDA IPC handle size + * CUDA IPC handle size */ #define CU_IPC_HANDLE_SIZE 64 @@ -251,21 +303,23 @@ typedef struct CUuuid_st { /**< CUDA definition o * CUDA IPC event handle */ typedef struct CUipcEventHandle_st { - char reserved[CU_IPC_HANDLE_SIZE]; + char reserved[CU_IPC_HANDLE_SIZE]; } CUipcEventHandle; /** * CUDA IPC mem handle */ typedef struct CUipcMemHandle_st { - char reserved[CU_IPC_HANDLE_SIZE]; + char reserved[CU_IPC_HANDLE_SIZE]; } CUipcMemHandle; /** * CUDA Ipc Mem Flags */ typedef enum CUipcMem_flags_enum { - CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 0x1 /**< Automatically enable peer access between remote devices as needed */ + CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = + 0x1 /**< Automatically enable peer access between remote devices as needed + */ } CUipcMem_flags; #endif @@ -274,34 +328,41 @@ typedef enum CUipcMem_flags_enum { * CUDA Mem Attach Flags */ typedef enum CUmemAttach_flags_enum { - CU_MEM_ATTACH_GLOBAL = 0x1, /**< Memory can be accessed by any stream on any device */ - CU_MEM_ATTACH_HOST = 0x2, /**< Memory cannot be accessed by any stream on any device */ - CU_MEM_ATTACH_SINGLE = 0x4 /**< Memory can only be accessed by a single stream on the associated device */ + CU_MEM_ATTACH_GLOBAL = + 0x1, /**< Memory can be accessed by any stream on any device */ + CU_MEM_ATTACH_HOST = + 0x2, /**< Memory cannot be accessed by any stream on any device */ + CU_MEM_ATTACH_SINGLE = 0x4 /**< Memory can only be accessed by a single stream + on the associated device */ } CUmemAttach_flags; /** * Context creation flags */ typedef enum CUctx_flags_enum { - CU_CTX_SCHED_AUTO = 0x00, /**< Automatic scheduling */ - CU_CTX_SCHED_SPIN = 0x01, /**< Set spin as default scheduling */ - CU_CTX_SCHED_YIELD = 0x02, /**< Set yield as default scheduling */ - CU_CTX_SCHED_BLOCKING_SYNC = 0x04, /**< Set blocking synchronization as default scheduling */ - CU_CTX_BLOCKING_SYNC = 0x04, /**< Set blocking synchronization as default scheduling - * \deprecated This flag was deprecated as of CUDA 4.0 - * and was replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. */ - CU_CTX_SCHED_MASK = 0x07, - CU_CTX_MAP_HOST = 0x08, /**< Support mapped pinned allocations */ - CU_CTX_LMEM_RESIZE_TO_MAX = 0x10, /**< Keep local memory allocation after launch */ - CU_CTX_FLAGS_MASK = 0x1f + CU_CTX_SCHED_AUTO = 0x00, /**< Automatic scheduling */ + CU_CTX_SCHED_SPIN = 0x01, /**< Set spin as default scheduling */ + CU_CTX_SCHED_YIELD = 0x02, /**< Set yield as default scheduling */ + CU_CTX_SCHED_BLOCKING_SYNC = + 0x04, /**< Set blocking synchronization as default scheduling */ + CU_CTX_BLOCKING_SYNC = + 0x04, /**< Set blocking synchronization as default scheduling + * \deprecated This flag was deprecated as of CUDA 4.0 + * and was replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. */ + CU_CTX_SCHED_MASK = 0x07, + CU_CTX_MAP_HOST = 0x08, /**< Support mapped pinned allocations */ + CU_CTX_LMEM_RESIZE_TO_MAX = + 0x10, /**< Keep local memory allocation after launch */ + CU_CTX_FLAGS_MASK = 0x1f } CUctx_flags; /** * Stream creation flags */ typedef enum CUstream_flags_enum { - CU_STREAM_DEFAULT = 0x0, /**< Default stream flag */ - CU_STREAM_NON_BLOCKING = 0x1 /**< Stream does not synchronize with stream 0 (the NULL stream) */ + CU_STREAM_DEFAULT = 0x0, /**< Default stream flag */ + CU_STREAM_NON_BLOCKING = + 0x1 /**< Stream does not synchronize with stream 0 (the NULL stream) */ } CUstream_flags; /** @@ -312,7 +373,7 @@ typedef enum CUstream_flags_enum { * * See details of the \link_sync_behavior */ -#define CU_STREAM_LEGACY ((CUstream)0x1) +#define CU_STREAM_LEGACY ((CUstream)0x1) /** * Per-thread stream handle @@ -328,83 +389,105 @@ typedef enum CUstream_flags_enum { * Event creation flags */ typedef enum CUevent_flags_enum { - CU_EVENT_DEFAULT = 0x0, /**< Default event flag */ - CU_EVENT_BLOCKING_SYNC = 0x1, /**< Event uses blocking synchronization */ - CU_EVENT_DISABLE_TIMING = 0x2, /**< Event will not record timing data */ - CU_EVENT_INTERPROCESS = 0x4 /**< Event is suitable for interprocess use. CU_EVENT_DISABLE_TIMING must be set */ + CU_EVENT_DEFAULT = 0x0, /**< Default event flag */ + CU_EVENT_BLOCKING_SYNC = 0x1, /**< Event uses blocking synchronization */ + CU_EVENT_DISABLE_TIMING = 0x2, /**< Event will not record timing data */ + CU_EVENT_INTERPROCESS = 0x4 /**< Event is suitable for interprocess use. + CU_EVENT_DISABLE_TIMING must be set */ } CUevent_flags; #if __CUDA_API_VERSION >= 8000 /** - * Flags for ::cuStreamWaitValue32 + * Flags for ::cuStreamWaitValue32 and ::cuStreamWaitValue64 */ typedef enum CUstreamWaitValue_flags_enum { - CU_STREAM_WAIT_VALUE_GEQ = 0x0, /**< Wait until (int32_t)(*addr - value) >= 0. Note this is a - cyclic comparison which ignores wraparound. (Default behavior.) */ - CU_STREAM_WAIT_VALUE_EQ = 0x1, /**< Wait until *addr == value. */ - CU_STREAM_WAIT_VALUE_AND = 0x2, /**< Wait until (*addr & value) != 0. */ - CU_STREAM_WAIT_VALUE_FLUSH = 1<<30 /**< Follow the wait operation with a flush of outstanding remote writes. This - means that, if a remote write operation is guaranteed to have reached the - device before the wait can be satisfied, that write is guaranteed to be - visible to downstream device work. The device is permitted to reorder - remote writes internally. For example, this flag would be required if - two remote writes arrive in a defined order, the wait is satisfied by the - second write, and downstream work needs to observe the first write. */ + CU_STREAM_WAIT_VALUE_GEQ = + 0x0, /**< Wait until (int32_t)(*addr - value) >= 0 (or int64_t for 64 bit + values). Note this is a cyclic comparison which ignores + wraparound. (Default behavior.) */ + CU_STREAM_WAIT_VALUE_EQ = 0x1, /**< Wait until *addr == value. */ + CU_STREAM_WAIT_VALUE_AND = 0x2, /**< Wait until (*addr & value) != 0. */ + CU_STREAM_WAIT_VALUE_NOR = + 0x3, /**< Wait until ~(*addr | value) != 0. Support for this operation can + be queried with ::cuDeviceGetAttribute() and + ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR.*/ + CU_STREAM_WAIT_VALUE_FLUSH = + 1 << 30 /**< Follow the wait operation with a flush of outstanding remote + writes. This means that, if a remote write operation is + guaranteed to have reached the device before the wait can be + satisfied, that write is guaranteed to be visible to downstream + device work. The device is permitted to reorder remote writes + internally. For example, this flag would be required if two + remote writes arrive in a defined order, the wait is satisfied + by the second write, and downstream work needs to observe the + first write. Support for this operation is restricted to + selected platforms and can be queried with + ::CU_DEVICE_ATTRIBUTE_CAN_USE_WAIT_VALUE_FLUSH.*/ } CUstreamWaitValue_flags; /** * Flags for ::cuStreamWriteValue32 */ typedef enum CUstreamWriteValue_flags_enum { - CU_STREAM_WRITE_VALUE_DEFAULT = 0x0, /**< Default behavior */ - CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = 0x1 /**< Permits the write to be reordered with writes which were issued - before it, as a performance optimization. Normally, - ::cuStreamWriteValue32 will provide a memory fence before the - write, which has similar semantics to - __threadfence_system() but is scoped to the stream - rather than a CUDA thread. */ + CU_STREAM_WRITE_VALUE_DEFAULT = 0x0, /**< Default behavior */ + CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = + 0x1 /**< Permits the write to be reordered with writes which were issued + before it, as a performance optimization. Normally, + ::cuStreamWriteValue32 will provide a memory fence before the + write, which has similar semantics to + __threadfence_system() but is scoped to the stream + rather than a CUDA thread. */ } CUstreamWriteValue_flags; /** * Operations for ::cuStreamBatchMemOp */ typedef enum CUstreamBatchMemOpType_enum { - CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1, /**< Represents a ::cuStreamWaitValue32 operation */ - CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2, /**< Represents a ::cuStreamWriteValue32 operation */ - CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3 /**< This has the same effect as ::CU_STREAM_WAIT_VALUE_FLUSH, but as a - standalone operation. */ + CU_STREAM_MEM_OP_WAIT_VALUE_32 = + 1, /**< Represents a ::cuStreamWaitValue32 operation */ + CU_STREAM_MEM_OP_WRITE_VALUE_32 = + 2, /**< Represents a ::cuStreamWriteValue32 operation */ + CU_STREAM_MEM_OP_WAIT_VALUE_64 = + 4, /**< Represents a ::cuStreamWaitValue64 operation */ + CU_STREAM_MEM_OP_WRITE_VALUE_64 = + 5, /**< Represents a ::cuStreamWriteValue64 operation */ + CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = + 3 /**< This has the same effect as ::CU_STREAM_WAIT_VALUE_FLUSH, but as a + standalone operation. */ } CUstreamBatchMemOpType; /** * Per-operation parameters for ::cuStreamBatchMemOp */ 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; /**< For driver internal use. Initial value is unimportant. */ + } waitValue; + struct CUstreamMemOpWriteValueParams_st { CUstreamBatchMemOpType operation; - struct CUstreamMemOpWaitValueParams_st { - CUstreamBatchMemOpType operation; - CUdeviceptr address; - union { - cuuint32_t value; - cuuint64_t pad; - }; - unsigned int flags; - CUdeviceptr alias; /**< For driver internal use. Initial value is unimportant. */ - } waitValue; - struct CUstreamMemOpWriteValueParams_st { - CUstreamBatchMemOpType operation; - CUdeviceptr address; - union { - cuuint32_t value; - cuuint64_t pad; - }; - unsigned int flags; - CUdeviceptr alias; /**< For driver internal use. Initial value is unimportant. */ - } writeValue; - struct CUstreamMemOpFlushRemoteWritesParams_st { - CUstreamBatchMemOpType operation; - unsigned int flags; - } flushRemoteWrites; - cuuint64_t pad[6]; + CUdeviceptr address; + union { + cuuint32_t value; + cuuint64_t value64; + }; + unsigned int flags; + CUdeviceptr + alias; /**< For driver internal use. Initial value is unimportant. */ + } writeValue; + struct CUstreamMemOpFlushRemoteWritesParams_st { + CUstreamBatchMemOpType operation; + unsigned int flags; + } flushRemoteWrites; + cuuint64_t pad[6]; } CUstreamBatchMemOpParams; #endif /* __CUDA_API_VERSION >= 8000 */ @@ -412,517 +495,739 @@ typedef union CUstreamBatchMemOpParams_union { * Occupancy calculator flag */ typedef enum CUoccupancy_flags_enum { - CU_OCCUPANCY_DEFAULT = 0x0, /**< Default behavior */ - CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 0x1 /**< Assume global caching is enabled and cannot be automatically turned off */ + CU_OCCUPANCY_DEFAULT = 0x0, /**< Default behavior */ + CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = + 0x1 /**< Assume global caching is enabled and cannot be automatically + turned off */ } CUoccupancy_flags; /** * Array formats */ typedef enum CUarray_format_enum { - CU_AD_FORMAT_UNSIGNED_INT8 = 0x01, /**< Unsigned 8-bit integers */ - CU_AD_FORMAT_UNSIGNED_INT16 = 0x02, /**< Unsigned 16-bit integers */ - CU_AD_FORMAT_UNSIGNED_INT32 = 0x03, /**< Unsigned 32-bit integers */ - CU_AD_FORMAT_SIGNED_INT8 = 0x08, /**< Signed 8-bit integers */ - CU_AD_FORMAT_SIGNED_INT16 = 0x09, /**< Signed 16-bit integers */ - CU_AD_FORMAT_SIGNED_INT32 = 0x0a, /**< Signed 32-bit integers */ - CU_AD_FORMAT_HALF = 0x10, /**< 16-bit floating point */ - CU_AD_FORMAT_FLOAT = 0x20 /**< 32-bit floating point */ + CU_AD_FORMAT_UNSIGNED_INT8 = 0x01, /**< Unsigned 8-bit integers */ + CU_AD_FORMAT_UNSIGNED_INT16 = 0x02, /**< Unsigned 16-bit integers */ + CU_AD_FORMAT_UNSIGNED_INT32 = 0x03, /**< Unsigned 32-bit integers */ + CU_AD_FORMAT_SIGNED_INT8 = 0x08, /**< Signed 8-bit integers */ + CU_AD_FORMAT_SIGNED_INT16 = 0x09, /**< Signed 16-bit integers */ + CU_AD_FORMAT_SIGNED_INT32 = 0x0a, /**< Signed 32-bit integers */ + CU_AD_FORMAT_HALF = 0x10, /**< 16-bit floating point */ + CU_AD_FORMAT_FLOAT = 0x20 /**< 32-bit floating point */ } CUarray_format; /** * Texture reference addressing modes */ typedef enum CUaddress_mode_enum { - CU_TR_ADDRESS_MODE_WRAP = 0, /**< Wrapping address mode */ - CU_TR_ADDRESS_MODE_CLAMP = 1, /**< Clamp to edge address mode */ - CU_TR_ADDRESS_MODE_MIRROR = 2, /**< Mirror address mode */ - CU_TR_ADDRESS_MODE_BORDER = 3 /**< Border address mode */ + CU_TR_ADDRESS_MODE_WRAP = 0, /**< Wrapping address mode */ + CU_TR_ADDRESS_MODE_CLAMP = 1, /**< Clamp to edge address mode */ + CU_TR_ADDRESS_MODE_MIRROR = 2, /**< Mirror address mode */ + CU_TR_ADDRESS_MODE_BORDER = 3 /**< Border address mode */ } CUaddress_mode; /** * Texture reference filtering modes */ typedef enum CUfilter_mode_enum { - CU_TR_FILTER_MODE_POINT = 0, /**< Point filter mode */ - CU_TR_FILTER_MODE_LINEAR = 1 /**< Linear filter mode */ + CU_TR_FILTER_MODE_POINT = 0, /**< Point filter mode */ + CU_TR_FILTER_MODE_LINEAR = 1 /**< Linear filter mode */ } CUfilter_mode; /** * Device properties */ typedef enum CUdevice_attribute_enum { - CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1, /**< Maximum number of threads per block */ - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2, /**< Maximum block dimension X */ - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3, /**< Maximum block dimension Y */ - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4, /**< Maximum block dimension Z */ - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5, /**< Maximum grid dimension X */ - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6, /**< Maximum grid dimension Y */ - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7, /**< Maximum grid dimension Z */ - CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8, /**< Maximum shared memory available per block in bytes */ - CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = 8, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK */ - CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = 9, /**< Memory available on device for __constant__ variables in a CUDA C kernel in bytes */ - CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10, /**< Warp size in threads */ - CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11, /**< Maximum pitch in bytes allowed by memory copies */ - CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12, /**< Maximum number of 32-bit registers available per block */ - CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = 12, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK */ - CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13, /**< Typical clock frequency in kilohertz */ - CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14, /**< Alignment requirement for textures */ - CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15, /**< Device can possibly copy memory and execute a kernel concurrently. Deprecated. Use instead CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT. */ - CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16, /**< Number of multiprocessors on device */ - CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17, /**< Specifies whether there is a run time limit on kernels */ - CU_DEVICE_ATTRIBUTE_INTEGRATED = 18, /**< Device is integrated with host memory */ - CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19, /**< Device can map host memory into CUDA address space */ - CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20, /**< Compute mode (See ::CUcomputemode for details) */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21, /**< Maximum 1D texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22, /**< Maximum 2D texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23, /**< Maximum 2D texture height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24, /**< Maximum 3D texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25, /**< Maximum 3D texture height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26, /**< Maximum 3D texture depth */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27, /**< Maximum 2D layered texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28, /**< Maximum 2D layered texture height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29, /**< Maximum layers in a 2D layered texture */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = 27, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = 28, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = 29, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS */ - CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30, /**< Alignment requirement for surfaces */ - CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31, /**< Device can possibly execute multiple kernels concurrently */ - CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32, /**< Device has ECC support enabled */ - CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33, /**< PCI bus ID of the device */ - CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34, /**< PCI device ID of the device */ - CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35, /**< Device is using TCC driver model */ - CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36, /**< Peak memory clock frequency in kilohertz */ - CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37, /**< Global memory bus width in bits */ - CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38, /**< Size of L2 cache in bytes */ - CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39, /**< Maximum resident threads per multiprocessor */ - CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40, /**< Number of asynchronous engines */ - CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41, /**< Device shares a unified address space with the host */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42, /**< Maximum 1D layered texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43, /**< Maximum layers in a 1D layered texture */ - CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44, /**< Deprecated, do not use. */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45, /**< Maximum 2D texture width if CUDA_ARRAY3D_TEXTURE_GATHER is set */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46, /**< Maximum 2D texture height if CUDA_ARRAY3D_TEXTURE_GATHER is set */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47, /**< Alternate maximum 3D texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48,/**< Alternate maximum 3D texture height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49, /**< Alternate maximum 3D texture depth */ - CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50, /**< PCI domain ID of the device */ - CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51, /**< Pitch alignment requirement for textures */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52, /**< Maximum cubemap texture width/height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53, /**< Maximum cubemap layered texture width/height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54, /**< Maximum layers in a cubemap layered texture */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55, /**< Maximum 1D surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56, /**< Maximum 2D surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57, /**< Maximum 2D surface height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58, /**< Maximum 3D surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59, /**< Maximum 3D surface height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60, /**< Maximum 3D surface depth */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61, /**< Maximum 1D layered surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62, /**< Maximum layers in a 1D layered surface */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63, /**< Maximum 2D layered surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64, /**< Maximum 2D layered surface height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65, /**< Maximum layers in a 2D layered surface */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66, /**< Maximum cubemap surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67, /**< Maximum cubemap layered surface width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68, /**< Maximum layers in a cubemap layered surface */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69, /**< Maximum 1D linear texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70, /**< Maximum 2D linear texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71, /**< Maximum 2D linear texture height */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72, /**< Maximum 2D linear texture pitch in bytes */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73, /**< Maximum mipmapped 2D texture width */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74,/**< Maximum mipmapped 2D texture height */ - CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75, /**< Major compute capability version number */ - CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76, /**< Minor compute capability version number */ - CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77, /**< Maximum mipmapped 1D texture width */ - CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78, /**< Device supports stream priorities */ - CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79, /**< Device supports caching globals in L1 */ - CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80, /**< Device supports caching locals in L1 */ - CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81, /**< Maximum shared memory available per multiprocessor in bytes */ - CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82, /**< Maximum number of 32-bit registers available per multiprocessor */ - CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83, /**< Device can allocate managed memory on this system */ - CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84, /**< Device is on a multi-GPU board */ - CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85, /**< Unique id for a group of devices on the same multi-GPU board */ - CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86, /**< Link between the device and the host supports native atomic operations (this is a placeholder attribute, and is not supported on any current hardware)*/ - CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87, /**< Ratio of single precision performance (in floating-point operations per second) to double precision performance */ - CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88, /**< Device supports coherently accessing pageable memory without calling cudaHostRegister on it */ - CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89, /**< Device can coherently access managed memory concurrently with the CPU */ - CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90, /**< Device supports compute preemption. */ - CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91, /**< Device can access host registered memory at the same virtual address as the CPU */ - CU_DEVICE_ATTRIBUTE_MAX + CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = + 1, /**< Maximum number of threads per block */ + CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2, /**< Maximum block dimension X */ + CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3, /**< Maximum block dimension Y */ + CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4, /**< Maximum block dimension Z */ + CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5, /**< Maximum grid dimension X */ + CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = 6, /**< Maximum grid dimension Y */ + CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = 7, /**< Maximum grid dimension Z */ + CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = + 8, /**< Maximum shared memory available per block in bytes */ + CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = + 8, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK */ + CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = + 9, /**< Memory available on device for __constant__ variables in a CUDA C + kernel in bytes */ + CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10, /**< Warp size in threads */ + CU_DEVICE_ATTRIBUTE_MAX_PITCH = + 11, /**< Maximum pitch in bytes allowed by memory copies */ + CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = + 12, /**< Maximum number of 32-bit registers available per block */ + CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = + 12, /**< Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK */ + CU_DEVICE_ATTRIBUTE_CLOCK_RATE = + 13, /**< Typical clock frequency in kilohertz */ + CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = + 14, /**< Alignment requirement for textures */ + CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = + 15, /**< Device can possibly copy memory and execute a kernel + concurrently. Deprecated. Use instead + CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT. */ + CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = + 16, /**< Number of multiprocessors on device */ + CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = + 17, /**< Specifies whether there is a run time limit on kernels */ + CU_DEVICE_ATTRIBUTE_INTEGRATED = + 18, /**< Device is integrated with host memory */ + CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = + 19, /**< Device can map host memory into CUDA address space */ + CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = + 20, /**< Compute mode (See ::CUcomputemode for details) */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = + 21, /**< Maximum 1D texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = + 22, /**< Maximum 2D texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = + 23, /**< Maximum 2D texture height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = + 24, /**< Maximum 3D texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = + 25, /**< Maximum 3D texture height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = + 26, /**< Maximum 3D texture depth */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = + 27, /**< Maximum 2D layered texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = + 28, /**< Maximum 2D layered texture height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = + 29, /**< Maximum layers in a 2D layered texture */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = + 27, /**< Deprecated, use + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = + 28, /**< Deprecated, use + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = + 29, /**< Deprecated, use + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS */ + CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = + 30, /**< Alignment requirement for surfaces */ + CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = + 31, /**< Device can possibly execute multiple kernels concurrently */ + CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32, /**< Device has ECC support enabled */ + CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33, /**< PCI bus ID of the device */ + CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34, /**< PCI device ID of the device */ + CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35, /**< Device is using TCC driver model */ + CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = + 36, /**< Peak memory clock frequency in kilohertz */ + CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = + 37, /**< Global memory bus width in bits */ + CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38, /**< Size of L2 cache in bytes */ + CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = + 39, /**< Maximum resident threads per multiprocessor */ + CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = + 40, /**< Number of asynchronous engines */ + CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = + 41, /**< Device shares a unified address space with the host */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = + 42, /**< Maximum 1D layered texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = + 43, /**< Maximum layers in a 1D layered texture */ + CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = 44, /**< Deprecated, do not use. */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = + 45, /**< Maximum 2D texture width if CUDA_ARRAY3D_TEXTURE_GATHER is set */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = + 46, /**< Maximum 2D texture height if CUDA_ARRAY3D_TEXTURE_GATHER is set + */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = + 47, /**< Alternate maximum 3D texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = + 48, /**< Alternate maximum 3D texture height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = + 49, /**< Alternate maximum 3D texture depth */ + CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50, /**< PCI domain ID of the device */ + CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = + 51, /**< Pitch alignment requirement for textures */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = + 52, /**< Maximum cubemap texture width/height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = + 53, /**< Maximum cubemap layered texture width/height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = + 54, /**< Maximum layers in a cubemap layered texture */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = + 55, /**< Maximum 1D surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = + 56, /**< Maximum 2D surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = + 57, /**< Maximum 2D surface height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = + 58, /**< Maximum 3D surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = + 59, /**< Maximum 3D surface height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = + 60, /**< Maximum 3D surface depth */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = + 61, /**< Maximum 1D layered surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = + 62, /**< Maximum layers in a 1D layered surface */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = + 63, /**< Maximum 2D layered surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = + 64, /**< Maximum 2D layered surface height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = + 65, /**< Maximum layers in a 2D layered surface */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = + 66, /**< Maximum cubemap surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = + 67, /**< Maximum cubemap layered surface width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = + 68, /**< Maximum layers in a cubemap layered surface */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = + 69, /**< Maximum 1D linear texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = + 70, /**< Maximum 2D linear texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = + 71, /**< Maximum 2D linear texture height */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = + 72, /**< Maximum 2D linear texture pitch in bytes */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = + 73, /**< Maximum mipmapped 2D texture width */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = + 74, /**< Maximum mipmapped 2D texture height */ + CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = + 75, /**< Major compute capability version number */ + CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = + 76, /**< Minor compute capability version number */ + CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = + 77, /**< Maximum mipmapped 1D texture width */ + CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = + 78, /**< Device supports stream priorities */ + CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = + 79, /**< Device supports caching globals in L1 */ + CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = + 80, /**< Device supports caching locals in L1 */ + CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = + 81, /**< Maximum shared memory available per multiprocessor in bytes */ + CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = + 82, /**< Maximum number of 32-bit registers available per multiprocessor + */ + CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = + 83, /**< Device can allocate managed memory on this system */ + CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = + 84, /**< Device is on a multi-GPU board */ + CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = + 85, /**< Unique id for a group of devices on the same multi-GPU board */ + CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = + 86, /**< Link between the device and the host supports native atomic + operations (this is a placeholder attribute, and is not supported + on any current hardware)*/ + CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = + 87, /**< Ratio of single precision performance (in floating-point + operations per second) to double precision performance */ + CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = + 88, /**< Device supports coherently accessing pageable memory without + calling cudaHostRegister on it */ + CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = + 89, /**< Device can coherently access managed memory concurrently with the + CPU */ + CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = + 90, /**< Device supports compute preemption. */ + CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = + 91, /**< Device can access host registered memory at the same virtual + address as the CPU */ + CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS = + 92, /**< ::cuStreamBatchMemOp and related APIs are supported. */ + CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = + 93, /**< 64-bit operations are supported in ::cuStreamBatchMemOp and + related APIs. */ + CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = + 94, /**< ::CU_STREAM_WAIT_VALUE_NOR is supported. */ + CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = + 95, /**< Device supports launching cooperative kernels via + ::cuLaunchCooperativeKernel */ + CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = + 96, /**< Device can participate in cooperative kernels launched via + ::cuLaunchCooperativeKernelMultiDevice */ + CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = + 97, /**< Maximum optin shared memory per block */ + CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = + 98, /**< Both the ::CU_STREAM_WAIT_VALUE_FLUSH flag and the + ::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES MemOp are supported on the + device. See \ref CUDA_MEMOP for additional details. */ + CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = + 99, /**< Device supports host memory registration via ::cudaHostRegister. + */ + CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = + 100, /**< Device accesses pageable memory via the host's page tables. */ + CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = + 101, /**< The host can directly access managed memory on the device + without migration. */ + CU_DEVICE_ATTRIBUTE_MAX } CUdevice_attribute; /** * Legacy device properties */ typedef struct CUdevprop_st { - int maxThreadsPerBlock; /**< Maximum number of threads per block */ - int maxThreadsDim[3]; /**< Maximum size of each dimension of a block */ - int maxGridSize[3]; /**< Maximum size of each dimension of a grid */ - int sharedMemPerBlock; /**< Shared memory available per block in bytes */ - int totalConstantMemory; /**< Constant memory available on device in bytes */ - int SIMDWidth; /**< Warp size in threads */ - int memPitch; /**< Maximum pitch in bytes allowed by memory copies */ - int regsPerBlock; /**< 32-bit registers available per block */ - int clockRate; /**< Clock frequency in kilohertz */ - int textureAlign; /**< Alignment requirement for textures */ + int maxThreadsPerBlock; /**< Maximum number of threads per block */ + int maxThreadsDim[3]; /**< Maximum size of each dimension of a block */ + int maxGridSize[3]; /**< Maximum size of each dimension of a grid */ + int sharedMemPerBlock; /**< Shared memory available per block in bytes */ + int totalConstantMemory; /**< Constant memory available on device in bytes */ + int SIMDWidth; /**< Warp size in threads */ + int memPitch; /**< Maximum pitch in bytes allowed by memory copies */ + int regsPerBlock; /**< 32-bit registers available per block */ + int clockRate; /**< Clock frequency in kilohertz */ + int textureAlign; /**< Alignment requirement for textures */ } CUdevprop; /** * Pointer information */ typedef enum CUpointer_attribute_enum { - CU_POINTER_ATTRIBUTE_CONTEXT = 1, /**< The ::CUcontext on which a pointer was allocated or registered */ - CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2, /**< The ::CUmemorytype describing the physical location of a pointer */ - CU_POINTER_ATTRIBUTE_DEVICE_POINTER = 3, /**< The address at which a pointer's memory may be accessed on the device */ - CU_POINTER_ATTRIBUTE_HOST_POINTER = 4, /**< The address at which a pointer's memory may be accessed on the host */ - CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5, /**< A pair of tokens for use with the nv-p2p.h Linux kernel interface */ - CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6, /**< Synchronize every synchronous memory operation initiated on this region */ - CU_POINTER_ATTRIBUTE_BUFFER_ID = 7, /**< A process-wide unique ID for an allocated memory region*/ - CU_POINTER_ATTRIBUTE_IS_MANAGED = 8 /**< Indicates if the pointer points to managed memory */ + CU_POINTER_ATTRIBUTE_CONTEXT = + 1, /**< The ::CUcontext on which a pointer was allocated or registered */ + CU_POINTER_ATTRIBUTE_MEMORY_TYPE = 2, /**< The ::CUmemorytype describing the + physical location of a pointer */ + CU_POINTER_ATTRIBUTE_DEVICE_POINTER = + 3, /**< The address at which a pointer's memory may be accessed on the + device */ + CU_POINTER_ATTRIBUTE_HOST_POINTER = + 4, /**< The address at which a pointer's memory may be accessed on the + host */ + CU_POINTER_ATTRIBUTE_P2P_TOKENS = 5, /**< A pair of tokens for use with the + nv-p2p.h Linux kernel interface */ + CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = + 6, /**< Synchronize every synchronous memory operation initiated on this + region */ + CU_POINTER_ATTRIBUTE_BUFFER_ID = + 7, /**< A process-wide unique ID for an allocated memory region*/ + CU_POINTER_ATTRIBUTE_IS_MANAGED = + 8, /**< Indicates if the pointer points to managed memory */ + CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = + 9 /**< A device ordinal of a device on which a pointer was allocated or + registered */ } CUpointer_attribute; /** * Function properties */ typedef enum CUfunction_attribute_enum { - /** - * The maximum number of threads per block, beyond which a launch of the - * function would fail. This number depends on both the function and the - * device on which the function is currently loaded. - */ - CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0, + /** + * The maximum number of threads per block, beyond which a launch of the + * function would fail. This number depends on both the function and the + * device on which the function is currently loaded. + */ + CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0, - /** - * The size in bytes of statically-allocated shared memory required by - * this function. This does not include dynamically-allocated shared - * memory requested by the user at runtime. - */ - CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1, + /** + * The size in bytes of statically-allocated shared memory required by + * this function. This does not include dynamically-allocated shared + * memory requested by the user at runtime. + */ + CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1, - /** - * The size in bytes of user-allocated constant memory required by this - * function. - */ - CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2, + /** + * The size in bytes of user-allocated constant memory required by this + * function. + */ + CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2, - /** - * The size in bytes of local memory used by each thread of this function. - */ - CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3, + /** + * The size in bytes of local memory used by each thread of this function. + */ + CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3, - /** - * The number of registers used by each thread of this function. - */ - CU_FUNC_ATTRIBUTE_NUM_REGS = 4, + /** + * The number of registers used by each thread of this function. + */ + CU_FUNC_ATTRIBUTE_NUM_REGS = 4, - /** - * The PTX virtual architecture version for which the function was - * compiled. This value is the major PTX version * 10 + the minor PTX - * version, so a PTX version 1.3 function would return the value 13. - * Note that this may return the undefined value of 0 for cubins - * compiled prior to CUDA 3.0. - */ - CU_FUNC_ATTRIBUTE_PTX_VERSION = 5, + /** + * The PTX virtual architecture version for which the function was + * compiled. This value is the major PTX version * 10 + the minor PTX + * version, so a PTX version 1.3 function would return the value 13. + * Note that this may return the undefined value of 0 for cubins + * compiled prior to CUDA 3.0. + */ + CU_FUNC_ATTRIBUTE_PTX_VERSION = 5, - /** - * The binary architecture version for which the function was compiled. - * This value is the major binary version * 10 + the minor binary version, - * so a binary version 1.3 function would return the value 13. Note that - * this will return a value of 10 for legacy cubins that do not have a - * properly-encoded binary architecture version. - */ - CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6, + /** + * The binary architecture version for which the function was compiled. + * This value is the major binary version * 10 + the minor binary version, + * so a binary version 1.3 function would return the value 13. Note that + * this will return a value of 10 for legacy cubins that do not have a + * properly-encoded binary architecture version. + */ + CU_FUNC_ATTRIBUTE_BINARY_VERSION = 6, - /** - * The attribute to indicate whether the function has been compiled with - * user specified option "-Xptxas --dlcm=ca" set . - */ - CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7, + /** + * The attribute to indicate whether the function has been compiled with + * user specified option "-Xptxas --dlcm=ca" set . + */ + CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7, - CU_FUNC_ATTRIBUTE_MAX + /** + * The maximum size in bytes of dynamically-allocated shared memory that can + * be used by this function. If the user-specified dynamic shared memory size + * is larger than this value, the launch will fail. See ::cuFuncSetAttribute + */ + CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8, + + /** + * On devices where the L1 cache and shared memory use the same hardware + * resources, this sets the shared memory carveout preference, in percent of + * the total shared memory. Refer to + * ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR. This is only a + * hint, and the driver can choose a different ratio if required to execute + * the function. See ::cuFuncSetAttribute + */ + CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9, + + CU_FUNC_ATTRIBUTE_MAX } CUfunction_attribute; /** * Function cache configurations */ typedef enum CUfunc_cache_enum { - CU_FUNC_CACHE_PREFER_NONE = 0x00, /**< no preference for shared memory or L1 (default) */ - CU_FUNC_CACHE_PREFER_SHARED = 0x01, /**< prefer larger shared memory and smaller L1 cache */ - CU_FUNC_CACHE_PREFER_L1 = 0x02, /**< prefer larger L1 cache and smaller shared memory */ - CU_FUNC_CACHE_PREFER_EQUAL = 0x03 /**< prefer equal sized L1 cache and shared memory */ + CU_FUNC_CACHE_PREFER_NONE = + 0x00, /**< no preference for shared memory or L1 (default) */ + CU_FUNC_CACHE_PREFER_SHARED = + 0x01, /**< prefer larger shared memory and smaller L1 cache */ + CU_FUNC_CACHE_PREFER_L1 = + 0x02, /**< prefer larger L1 cache and smaller shared memory */ + CU_FUNC_CACHE_PREFER_EQUAL = + 0x03 /**< prefer equal sized L1 cache and shared memory */ } CUfunc_cache; /** * Shared memory configurations */ typedef enum CUsharedconfig_enum { - CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = 0x00, /**< set default shared memory bank size */ - CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = 0x01, /**< set shared memory bank width to four bytes */ - CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = 0x02 /**< set shared memory bank width to eight bytes */ + CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = + 0x00, /**< set default shared memory bank size */ + CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = + 0x01, /**< set shared memory bank width to four bytes */ + CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = + 0x02 /**< set shared memory bank width to eight bytes */ } CUsharedconfig; /** + * Shared memory carveout configurations. These may be passed to + * ::cuFuncSetAttribute + */ +typedef enum CUshared_carveout_enum { + CU_SHAREDMEM_CARVEOUT_DEFAULT = + -1, /**< No preference for shared memory or L1 (default) */ + CU_SHAREDMEM_CARVEOUT_MAX_SHARED = + 100, /**< Prefer maximum available shared memory, minimum L1 cache */ + CU_SHAREDMEM_CARVEOUT_MAX_L1 = + 0 /**< Prefer maximum available L1 cache, minimum shared memory */ +} CUshared_carveout; + +/** * Memory types */ typedef enum CUmemorytype_enum { - CU_MEMORYTYPE_HOST = 0x01, /**< Host memory */ - CU_MEMORYTYPE_DEVICE = 0x02, /**< Device memory */ - CU_MEMORYTYPE_ARRAY = 0x03, /**< Array memory */ - CU_MEMORYTYPE_UNIFIED = 0x04 /**< Unified device or host memory */ + CU_MEMORYTYPE_HOST = 0x01, /**< Host memory */ + CU_MEMORYTYPE_DEVICE = 0x02, /**< Device memory */ + CU_MEMORYTYPE_ARRAY = 0x03, /**< Array memory */ + CU_MEMORYTYPE_UNIFIED = 0x04 /**< Unified device or host memory */ } CUmemorytype; /** * Compute Modes */ typedef enum CUcomputemode_enum { - CU_COMPUTEMODE_DEFAULT = 0, /**< Default compute mode (Multiple contexts allowed per device) */ - CU_COMPUTEMODE_PROHIBITED = 2, /**< Compute-prohibited mode (No contexts can be created on this device at this time) */ - CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3 /**< Compute-exclusive-process mode (Only one context used by a single process can be present on this device at a time) */ + CU_COMPUTEMODE_DEFAULT = + 0, /**< Default compute mode (Multiple contexts allowed per device) */ + CU_COMPUTEMODE_PROHIBITED = 2, /**< Compute-prohibited mode (No contexts can + be created on this device at this time) */ + CU_COMPUTEMODE_EXCLUSIVE_PROCESS = + 3 /**< Compute-exclusive-process mode (Only one context used by a single + process can be present on this device at a time) */ } CUcomputemode; /** * Memory advise values */ typedef enum CUmem_advise_enum { - CU_MEM_ADVISE_SET_READ_MOSTLY = 1, /**< Data will mostly be read and only occassionally be written to */ - CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2, /**< Undo the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY */ - CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3, /**< Set the preferred location for the data as the specified device */ - CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4, /**< Clear the preferred location for the data */ - CU_MEM_ADVISE_SET_ACCESSED_BY = 5, /**< Data will be accessed by the specified device, so prevent page faults as much as possible */ - CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6 /**< Let the Unified Memory subsystem decide on the page faulting policy for the specified device */ + CU_MEM_ADVISE_SET_READ_MOSTLY = + 1, /**< Data will mostly be read and only occassionally be written to */ + CU_MEM_ADVISE_UNSET_READ_MOSTLY = + 2, /**< Undo the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY */ + CU_MEM_ADVISE_SET_PREFERRED_LOCATION = + 3, /**< Set the preferred location for the data as the specified device */ + CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = + 4, /**< Clear the preferred location for the data */ + CU_MEM_ADVISE_SET_ACCESSED_BY = + 5, /**< Data will be accessed by the specified device, so prevent page + faults as much as possible */ + CU_MEM_ADVISE_UNSET_ACCESSED_BY = + 6 /**< Let the Unified Memory subsystem decide on the page faulting policy + for the specified device */ } CUmem_advise; typedef enum CUmem_range_attribute_enum { - CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1, /**< Whether the range will mostly be read and only occassionally be written to */ - CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2, /**< The preferred location of the range */ - CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3, /**< Memory range has ::CU_MEM_ADVISE_SET_ACCESSED_BY set for specified device */ - CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4 /**< The last location to which the range was prefetched */ + CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = + 1, /**< Whether the range will mostly be read and only occassionally be + written to */ + CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = + 2, /**< The preferred location of the range */ + CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = + 3, /**< Memory range has ::CU_MEM_ADVISE_SET_ACCESSED_BY set for specified + device */ + CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = + 4 /**< The last location to which the range was prefetched */ } CUmem_range_attribute; /** * Online compiler and linker options */ -typedef enum CUjit_option_enum -{ - /** - * Max number of registers that a thread may use.\n - * Option type: unsigned int\n - * Applies to: compiler only - */ - CU_JIT_MAX_REGISTERS = 0, +typedef enum CUjit_option_enum { + /** + * Max number of registers that a thread may use.\n + * Option type: unsigned int\n + * Applies to: compiler only + */ + CU_JIT_MAX_REGISTERS = 0, - /** - * IN: Specifies minimum number of threads per block to target compilation - * for\n - * OUT: Returns the number of threads the compiler actually targeted. - * This restricts the resource utilization fo the compiler (e.g. max - * registers) such that a block with the given number of threads should be - * able to launch based on register limitations. Note, this option does not - * currently take into account any other resource limitations, such as - * shared memory utilization.\n - * Cannot be combined with ::CU_JIT_TARGET.\n - * Option type: unsigned int\n - * Applies to: compiler only - */ - CU_JIT_THREADS_PER_BLOCK, + /** + * IN: Specifies minimum number of threads per block to target compilation + * for\n + * OUT: Returns the number of threads the compiler actually targeted. + * This restricts the resource utilization fo the compiler (e.g. max + * registers) such that a block with the given number of threads should be + * able to launch based on register limitations. Note, this option does not + * currently take into account any other resource limitations, such as + * shared memory utilization.\n + * Cannot be combined with ::CU_JIT_TARGET.\n + * Option type: unsigned int\n + * Applies to: compiler only + */ + CU_JIT_THREADS_PER_BLOCK, - /** - * Overwrites the option value with the total wall clock time, in - * milliseconds, spent in the compiler and linker\n - * Option type: float\n - * Applies to: compiler and linker - */ - CU_JIT_WALL_TIME, + /** + * Overwrites the option value with the total wall clock time, in + * milliseconds, spent in the compiler and linker\n + * Option type: float\n + * Applies to: compiler and linker + */ + CU_JIT_WALL_TIME, - /** - * Pointer to a buffer in which to print any log messages - * that are informational in nature (the buffer size is specified via - * option ::CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES)\n - * Option type: char *\n - * Applies to: compiler and linker - */ - CU_JIT_INFO_LOG_BUFFER, + /** + * Pointer to a buffer in which to print any log messages + * that are informational in nature (the buffer size is specified via + * option ::CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES)\n + * Option type: char *\n + * Applies to: compiler and linker + */ + CU_JIT_INFO_LOG_BUFFER, - /** - * IN: Log buffer size in bytes. Log messages will be capped at this size - * (including null terminator)\n - * OUT: Amount of log buffer filled with messages\n - * Option type: unsigned int\n - * Applies to: compiler and linker - */ - CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, + /** + * IN: Log buffer size in bytes. Log messages will be capped at this size + * (including null terminator)\n + * OUT: Amount of log buffer filled with messages\n + * Option type: unsigned int\n + * Applies to: compiler and linker + */ + CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, - /** - * Pointer to a buffer in which to print any log messages that - * reflect errors (the buffer size is specified via option - * ::CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES)\n - * Option type: char *\n - * Applies to: compiler and linker - */ - CU_JIT_ERROR_LOG_BUFFER, + /** + * Pointer to a buffer in which to print any log messages that + * reflect errors (the buffer size is specified via option + * ::CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES)\n + * Option type: char *\n + * Applies to: compiler and linker + */ + CU_JIT_ERROR_LOG_BUFFER, - /** - * IN: Log buffer size in bytes. Log messages will be capped at this size - * (including null terminator)\n - * OUT: Amount of log buffer filled with messages\n - * Option type: unsigned int\n - * Applies to: compiler and linker - */ - CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES, + /** + * IN: Log buffer size in bytes. Log messages will be capped at this size + * (including null terminator)\n + * OUT: Amount of log buffer filled with messages\n + * Option type: unsigned int\n + * Applies to: compiler and linker + */ + CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES, - /** - * Level of optimizations to apply to generated code (0 - 4), with 4 - * being the default and highest level of optimizations.\n - * Option type: unsigned int\n - * Applies to: compiler only - */ - CU_JIT_OPTIMIZATION_LEVEL, + /** + * Level of optimizations to apply to generated code (0 - 4), with 4 + * being the default and highest level of optimizations.\n + * Option type: unsigned int\n + * Applies to: compiler only + */ + CU_JIT_OPTIMIZATION_LEVEL, - /** - * No option value required. Determines the target based on the current - * attached context (default)\n - * Option type: No option value needed\n - * Applies to: compiler and linker - */ - CU_JIT_TARGET_FROM_CUCONTEXT, + /** + * No option value required. Determines the target based on the current + * attached context (default)\n + * Option type: No option value needed\n + * Applies to: compiler and linker + */ + CU_JIT_TARGET_FROM_CUCONTEXT, - /** - * Target is chosen based on supplied ::CUjit_target. Cannot be - * combined with ::CU_JIT_THREADS_PER_BLOCK.\n - * Option type: unsigned int for enumerated type ::CUjit_target\n - * Applies to: compiler and linker - */ - CU_JIT_TARGET, + /** + * Target is chosen based on supplied ::CUjit_target. Cannot be + * combined with ::CU_JIT_THREADS_PER_BLOCK.\n + * Option type: unsigned int for enumerated type ::CUjit_target\n + * Applies to: compiler and linker + */ + CU_JIT_TARGET, - /** - * Specifies choice of fallback strategy if matching cubin is not found. - * Choice is based on supplied ::CUjit_fallback. This option cannot be - * used with cuLink* APIs as the linker requires exact matches.\n - * Option type: unsigned int for enumerated type ::CUjit_fallback\n - * Applies to: compiler only - */ - CU_JIT_FALLBACK_STRATEGY, + /** + * Specifies choice of fallback strategy if matching cubin is not found. + * Choice is based on supplied ::CUjit_fallback. This option cannot be + * used with cuLink* APIs as the linker requires exact matches.\n + * Option type: unsigned int for enumerated type ::CUjit_fallback\n + * Applies to: compiler only + */ + CU_JIT_FALLBACK_STRATEGY, - /** - * Specifies whether to create debug information in output (-g) - * (0: false, default)\n - * Option type: int\n - * Applies to: compiler and linker - */ - CU_JIT_GENERATE_DEBUG_INFO, + /** + * Specifies whether to create debug information in output (-g) + * (0: false, default)\n + * Option type: int\n + * Applies to: compiler and linker + */ + CU_JIT_GENERATE_DEBUG_INFO, - /** - * Generate verbose log messages (0: false, default)\n - * Option type: int\n - * Applies to: compiler and linker - */ - CU_JIT_LOG_VERBOSE, + /** + * Generate verbose log messages (0: false, default)\n + * Option type: int\n + * Applies to: compiler and linker + */ + CU_JIT_LOG_VERBOSE, - /** - * Generate line number information (-lineinfo) (0: false, default)\n - * Option type: int\n - * Applies to: compiler only - */ - CU_JIT_GENERATE_LINE_INFO, + /** + * Generate line number information (-lineinfo) (0: false, default)\n + * Option type: int\n + * Applies to: compiler only + */ + CU_JIT_GENERATE_LINE_INFO, - /** - * Specifies whether to enable caching explicitly (-dlcm) \n - * Choice is based on supplied ::CUjit_cacheMode_enum.\n - * Option type: unsigned int for enumerated type ::CUjit_cacheMode_enum\n - * Applies to: compiler only - */ - CU_JIT_CACHE_MODE, + /** + * Specifies whether to enable caching explicitly (-dlcm) \n + * Choice is based on supplied ::CUjit_cacheMode_enum.\n + * Option type: unsigned int for enumerated type ::CUjit_cacheMode_enum\n + * Applies to: compiler only + */ + CU_JIT_CACHE_MODE, - /** - * The below jit options are used for internal purposes only, in this version of CUDA - */ - CU_JIT_NEW_SM3X_OPT, - CU_JIT_FAST_COMPILE, + /** + * The below jit options are used for internal purposes only, in this version + * of CUDA + */ + CU_JIT_NEW_SM3X_OPT, + CU_JIT_FAST_COMPILE, + + /** + * Array of device symbol names that will be relocated to the corresponing + * host addresses stored in ::CU_JIT_GLOBAL_SYMBOL_ADDRESSES.\n + * Must contain ::CU_JIT_GLOBAL_SYMBOL_COUNT entries.\n + * When loding a device module, driver will relocate all encountered + * unresolved symbols to the host addresses.\n + * It is only allowed to register symbols that correspond to unresolved + * global variables.\n + * It is illegal to register the same device symbol at multiple addresses.\n + * Option type: const char **\n + * Applies to: dynamic linker only + */ + CU_JIT_GLOBAL_SYMBOL_NAMES, + + /** + * Array of host addresses that will be used to relocate corresponding + * device symbols stored in ::CU_JIT_GLOBAL_SYMBOL_NAMES.\n + * Must contain ::CU_JIT_GLOBAL_SYMBOL_COUNT entries.\n + * Option type: void **\n + * Applies to: dynamic linker only + */ + CU_JIT_GLOBAL_SYMBOL_ADDRESSES, + + /** + * Number of entries in ::CU_JIT_GLOBAL_SYMBOL_NAMES and + * ::CU_JIT_GLOBAL_SYMBOL_ADDRESSES arrays.\n + * Option type: unsigned int\n + * Applies to: dynamic linker only + */ + CU_JIT_GLOBAL_SYMBOL_COUNT, - CU_JIT_NUM_OPTIONS + CU_JIT_NUM_OPTIONS } CUjit_option; /** * Online compilation targets */ -typedef enum CUjit_target_enum -{ - CU_TARGET_COMPUTE_10 = 10, /**< Compute device class 1.0 */ - CU_TARGET_COMPUTE_11 = 11, /**< Compute device class 1.1 */ - CU_TARGET_COMPUTE_12 = 12, /**< Compute device class 1.2 */ - CU_TARGET_COMPUTE_13 = 13, /**< Compute device class 1.3 */ - CU_TARGET_COMPUTE_20 = 20, /**< Compute device class 2.0 */ - CU_TARGET_COMPUTE_21 = 21, /**< Compute device class 2.1 */ - CU_TARGET_COMPUTE_30 = 30, /**< Compute device class 3.0 */ - CU_TARGET_COMPUTE_32 = 32, /**< Compute device class 3.2 */ - CU_TARGET_COMPUTE_35 = 35, /**< Compute device class 3.5 */ - CU_TARGET_COMPUTE_37 = 37, /**< Compute device class 3.7 */ - CU_TARGET_COMPUTE_50 = 50, /**< Compute device class 5.0 */ - CU_TARGET_COMPUTE_52 = 52, /**< Compute device class 5.2 */ - CU_TARGET_COMPUTE_53 = 53, /**< Compute device class 5.3 */ - CU_TARGET_COMPUTE_60 = 60, /**< Compute device class 6.0. This must be removed for CUDA 7.0 toolkit. See bug 1518217. */ - CU_TARGET_COMPUTE_61 = 61, /**< Compute device class 6.1. This must be removed for CUDA 7.0 toolkit.*/ - CU_TARGET_COMPUTE_62 = 62 /**< Compute device class 6.2. This must be removed for CUDA 7.0 toolkit.*/ +typedef enum CUjit_target_enum { + CU_TARGET_COMPUTE_20 = 20, /**< Compute device class 2.0 */ + CU_TARGET_COMPUTE_21 = 21, /**< Compute device class 2.1 */ + CU_TARGET_COMPUTE_30 = 30, /**< Compute device class 3.0 */ + CU_TARGET_COMPUTE_32 = 32, /**< Compute device class 3.2 */ + CU_TARGET_COMPUTE_35 = 35, /**< Compute device class 3.5 */ + CU_TARGET_COMPUTE_37 = 37, /**< Compute device class 3.7 */ + CU_TARGET_COMPUTE_50 = 50, /**< Compute device class 5.0 */ + CU_TARGET_COMPUTE_52 = 52, /**< Compute device class 5.2 */ + CU_TARGET_COMPUTE_53 = 53, /**< Compute device class 5.3 */ + CU_TARGET_COMPUTE_60 = 60, /**< Compute device class 6.0.*/ + CU_TARGET_COMPUTE_61 = 61, /**< Compute device class 6.1.*/ + CU_TARGET_COMPUTE_62 = 62, /**< Compute device class 6.2.*/ + CU_TARGET_COMPUTE_70 = 70, /**< Compute device class 7.0.*/ + CU_TARGET_COMPUTE_72 = 72, /**< Compute device class 7.2.*/ + CU_TARGET_COMPUTE_75 = 75 /**< Compute device class 7.5.*/ } CUjit_target; /** * Cubin matching fallback strategies */ -typedef enum CUjit_fallback_enum -{ - CU_PREFER_PTX = 0, /**< Prefer to compile ptx if exact binary match not found */ +typedef enum CUjit_fallback_enum { + CU_PREFER_PTX = + 0, /**< Prefer to compile ptx if exact binary match not found */ - CU_PREFER_BINARY /**< Prefer to fall back to compatible binary code if exact match not found */ + CU_PREFER_BINARY /**< Prefer to fall back to compatible binary code if exact + match not found */ } CUjit_fallback; /** - * Caching modes for dlcm + * Caching modes for dlcm */ -typedef enum CUjit_cacheMode_enum -{ - CU_JIT_CACHE_OPTION_NONE = 0, /**< Compile with no -dlcm flag specified */ - CU_JIT_CACHE_OPTION_CG, /**< Compile with L1 cache disabled */ - CU_JIT_CACHE_OPTION_CA /**< Compile with L1 cache enabled */ +typedef enum CUjit_cacheMode_enum { + CU_JIT_CACHE_OPTION_NONE = 0, /**< Compile with no -dlcm flag specified */ + CU_JIT_CACHE_OPTION_CG, /**< Compile with L1 cache disabled */ + CU_JIT_CACHE_OPTION_CA /**< Compile with L1 cache enabled */ } CUjit_cacheMode; /** * Device code formats */ -typedef enum CUjitInputType_enum -{ - /** - * Compiled device-class-specific device code\n - * Applicable options: none - */ - CU_JIT_INPUT_CUBIN = 0, +typedef enum CUjitInputType_enum { + /** + * Compiled device-class-specific device code\n + * Applicable options: none + */ + CU_JIT_INPUT_CUBIN = 0, - /** - * PTX source code\n - * Applicable options: PTX compiler options - */ - CU_JIT_INPUT_PTX, + /** + * PTX source code\n + * Applicable options: PTX compiler options + */ + CU_JIT_INPUT_PTX, - /** - * Bundle of multiple cubins and/or PTX of some device code\n - * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY - */ - CU_JIT_INPUT_FATBINARY, + /** + * Bundle of multiple cubins and/or PTX of some device code\n + * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY + */ + CU_JIT_INPUT_FATBINARY, - /** - * Host object with embedded device code\n - * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY - */ - CU_JIT_INPUT_OBJECT, + /** + * Host object with embedded device code\n + * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY + */ + CU_JIT_INPUT_OBJECT, - /** - * Archive of host objects with embedded device code\n - * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY - */ - CU_JIT_INPUT_LIBRARY, + /** + * Archive of host objects with embedded device code\n + * Applicable options: PTX compiler options, ::CU_JIT_FALLBACK_STRATEGY + */ + CU_JIT_INPUT_LIBRARY, - CU_JIT_NUM_INPUT_TYPES + CU_JIT_NUM_INPUT_TYPES } CUjitInputType; #if __CUDA_API_VERSION >= 5050 @@ -933,479 +1238,682 @@ typedef struct CUlinkState_st *CUlinkState; * Flags to register a graphics resource */ 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 + 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; /** * Flags for mapping and unmapping interop resources */ 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 + CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0x00, + CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01, + CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02 } CUgraphicsMapResourceFlags; /** * Array indices for cube faces */ typedef enum CUarray_cubemap_face_enum { - CU_CUBEMAP_FACE_POSITIVE_X = 0x00, /**< Positive X face of cubemap */ - CU_CUBEMAP_FACE_NEGATIVE_X = 0x01, /**< Negative X face of cubemap */ - CU_CUBEMAP_FACE_POSITIVE_Y = 0x02, /**< Positive Y face of cubemap */ - CU_CUBEMAP_FACE_NEGATIVE_Y = 0x03, /**< Negative Y face of cubemap */ - CU_CUBEMAP_FACE_POSITIVE_Z = 0x04, /**< Positive Z face of cubemap */ - CU_CUBEMAP_FACE_NEGATIVE_Z = 0x05 /**< Negative Z face of cubemap */ + CU_CUBEMAP_FACE_POSITIVE_X = 0x00, /**< Positive X face of cubemap */ + CU_CUBEMAP_FACE_NEGATIVE_X = 0x01, /**< Negative X face of cubemap */ + CU_CUBEMAP_FACE_POSITIVE_Y = 0x02, /**< Positive Y face of cubemap */ + CU_CUBEMAP_FACE_NEGATIVE_Y = 0x03, /**< Negative Y face of cubemap */ + CU_CUBEMAP_FACE_POSITIVE_Z = 0x04, /**< Positive Z face of cubemap */ + CU_CUBEMAP_FACE_NEGATIVE_Z = 0x05 /**< Negative Z face of cubemap */ } CUarray_cubemap_face; /** * Limits */ typedef enum CUlimit_enum { - CU_LIMIT_STACK_SIZE = 0x00, /**< GPU thread stack size */ - CU_LIMIT_PRINTF_FIFO_SIZE = 0x01, /**< GPU printf FIFO size */ - CU_LIMIT_MALLOC_HEAP_SIZE = 0x02, /**< GPU malloc heap size */ - CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 0x03, /**< GPU device runtime launch synchronize depth */ - CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 0x04, /**< GPU device runtime pending launch count */ - CU_LIMIT_MAX + CU_LIMIT_STACK_SIZE = 0x00, /**< GPU thread stack size */ + CU_LIMIT_PRINTF_FIFO_SIZE = 0x01, /**< GPU printf FIFO size */ + CU_LIMIT_MALLOC_HEAP_SIZE = 0x02, /**< GPU malloc heap size */ + CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = + 0x03, /**< GPU device runtime launch synchronize depth */ + CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = + 0x04, /**< GPU device runtime pending launch count */ + CU_LIMIT_MAX_L2_FETCH_GRANULARITY = + 0x05, /**< A value between 0 and 128 that indicates the maximum fetch + granularity of L2 (in Bytes). This is a hint */ + CU_LIMIT_MAX } CUlimit; /** * Resource types */ typedef enum CUresourcetype_enum { - CU_RESOURCE_TYPE_ARRAY = 0x00, /**< Array resoure */ - CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01, /**< Mipmapped array resource */ - CU_RESOURCE_TYPE_LINEAR = 0x02, /**< Linear resource */ - CU_RESOURCE_TYPE_PITCH2D = 0x03 /**< Pitch 2D resource */ + CU_RESOURCE_TYPE_ARRAY = 0x00, /**< Array resoure */ + CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01, /**< Mipmapped array resource */ + CU_RESOURCE_TYPE_LINEAR = 0x02, /**< Linear resource */ + CU_RESOURCE_TYPE_PITCH2D = 0x03 /**< Pitch 2D resource */ } CUresourcetype; +#ifdef _WIN32 +#define CUDA_CB __stdcall +#else +#define CUDA_CB +#endif + +#if __CUDA_API_VERSION >= 10000 + +/** + * CUDA host function + * \param userData Argument value passed to the function + */ +typedef void(CUDA_CB *CUhostFn)(void *userData); + +/** + * GPU kernel node parameters + */ +typedef struct CUDA_KERNEL_NODE_PARAMS_st { + CUfunction func; /**< Kernel to launch */ + unsigned int gridDimX; /**< Width of grid in blocks */ + unsigned int gridDimY; /**< Height of grid in blocks */ + unsigned int gridDimZ; /**< Depth of grid in blocks */ + unsigned int blockDimX; /**< X dimension of each thread block */ + unsigned int blockDimY; /**< Y dimension of each thread block */ + unsigned int blockDimZ; /**< Z dimension of each thread block */ + unsigned int sharedMemBytes; /**< Dynamic shared-memory size per thread block + in bytes */ + void **kernelParams; /**< Array of pointers to kernel parameters */ + void **extra; /**< Extra options */ +} CUDA_KERNEL_NODE_PARAMS; + +/** + * Memset node parameters + */ +typedef struct CUDA_MEMSET_NODE_PARAMS_st { + CUdeviceptr dst; /**< Destination device pointer */ + size_t + pitch; /**< Pitch of destination device pointer. Unused if height is 1 */ + unsigned int value; /**< Value to be set */ + unsigned int + elementSize; /**< Size of each element in bytes. Must be 1, 2, or 4. */ + size_t width; /**< Width in bytes, of the row */ + size_t height; /**< Number of rows */ +} CUDA_MEMSET_NODE_PARAMS; + +/** + * Host node parameters + */ +typedef struct CUDA_HOST_NODE_PARAMS_st { + CUhostFn fn; /**< The function to call when the node executes */ + void *userData; /**< Argument to pass to the function */ +} CUDA_HOST_NODE_PARAMS; + +/** + * Graph node types + */ +typedef enum CUgraphNodeType_enum { + CU_GRAPH_NODE_TYPE_KERNEL = 0, /**< GPU kernel node */ + CU_GRAPH_NODE_TYPE_MEMCPY = 1, /**< Memcpy node */ + CU_GRAPH_NODE_TYPE_MEMSET = 2, /**< Memset node */ + CU_GRAPH_NODE_TYPE_HOST = 3, /**< Host (executable) node */ + CU_GRAPH_NODE_TYPE_GRAPH = 4, /**< Node which executes an embedded graph */ + CU_GRAPH_NODE_TYPE_EMPTY = 5, /**< Empty (no-op) node */ + CU_GRAPH_NODE_TYPE_COUNT +} CUgraphNodeType; + +/** + * Possible stream capture statuses returned by ::cuStreamIsCapturing + */ +typedef enum CUstreamCaptureStatus_enum { + CU_STREAM_CAPTURE_STATUS_NONE = 0, /**< Stream is not capturing */ + CU_STREAM_CAPTURE_STATUS_ACTIVE = 1, /**< Stream is actively capturing */ + CU_STREAM_CAPTURE_STATUS_INVALIDATED = + 2 /**< Stream is part of a capture sequence that + has been invalidated, but not terminated */ +} CUstreamCaptureStatus; + +#endif /* __CUDA_API_VERSION >= 10000 */ + +#if __CUDA_API_VERSION >= 10010 + +/** + * Possible modes for stream capture thread interactions. For more details see + * ::cuStreamBeginCapture and ::cuThreadExchangeStreamCaptureMode + */ +typedef enum CUstreamCaptureMode_enum { + CU_STREAM_CAPTURE_MODE_GLOBAL = 0, + CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = 1, + CU_STREAM_CAPTURE_MODE_RELAXED = 2 +} CUstreamCaptureMode; + +#endif /* __CUDA_API_VERSION >= 10010 */ + /** * Error codes */ typedef enum cudaError_enum { - /** - * The API call returned with no errors. In the case of query calls, this - * can also mean that the operation being queried is complete (see - * ::cuEventQuery() and ::cuStreamQuery()). - */ - CUDA_SUCCESS = 0, + /** + * The API call returned with no errors. In the case of query calls, this + * also means that the operation being queried is complete (see + * ::cuEventQuery() and ::cuStreamQuery()). + */ + CUDA_SUCCESS = 0, - /** - * This indicates that one or more of the parameters passed to the API call - * is not within an acceptable range of values. - */ - CUDA_ERROR_INVALID_VALUE = 1, + /** + * This indicates that one or more of the parameters passed to the API call + * is not within an acceptable range of values. + */ + CUDA_ERROR_INVALID_VALUE = 1, - /** - * The API call failed because it was unable to allocate enough memory to - * perform the requested operation. - */ - CUDA_ERROR_OUT_OF_MEMORY = 2, + /** + * The API call failed because it was unable to allocate enough memory to + * perform the requested operation. + */ + CUDA_ERROR_OUT_OF_MEMORY = 2, - /** - * This indicates that the CUDA driver has not been initialized with - * ::cuInit() or that initialization has failed. - */ - CUDA_ERROR_NOT_INITIALIZED = 3, + /** + * This indicates that the CUDA driver has not been initialized with + * ::cuInit() or that initialization has failed. + */ + CUDA_ERROR_NOT_INITIALIZED = 3, - /** - * This indicates that the CUDA driver is in the process of shutting down. - */ - CUDA_ERROR_DEINITIALIZED = 4, + /** + * This indicates that the CUDA driver is in the process of shutting down. + */ + CUDA_ERROR_DEINITIALIZED = 4, - /** - * This indicates profiler is not initialized for this run. This can - * happen when the application is running with external profiling tools - * like visual profiler. - */ - CUDA_ERROR_PROFILER_DISABLED = 5, + /** + * This indicates profiler is not initialized for this run. This can + * happen when the application is running with external profiling tools + * like visual profiler. + */ + CUDA_ERROR_PROFILER_DISABLED = 5, - /** - * \deprecated - * This error return is deprecated as of CUDA 5.0. It is no longer an error - * to attempt to enable/disable the profiling via ::cuProfilerStart or - * ::cuProfilerStop without initialization. - */ - CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6, + /** + * \deprecated + * This error return is deprecated as of CUDA 5.0. It is no longer an error + * to attempt to enable/disable the profiling via ::cuProfilerStart or + * ::cuProfilerStop without initialization. + */ + CUDA_ERROR_PROFILER_NOT_INITIALIZED = 6, - /** - * \deprecated - * This error return is deprecated as of CUDA 5.0. It is no longer an error - * to call cuProfilerStart() when profiling is already enabled. - */ - CUDA_ERROR_PROFILER_ALREADY_STARTED = 7, + /** + * \deprecated + * This error return is deprecated as of CUDA 5.0. It is no longer an error + * to call cuProfilerStart() when profiling is already enabled. + */ + CUDA_ERROR_PROFILER_ALREADY_STARTED = 7, - /** - * \deprecated - * This error return is deprecated as of CUDA 5.0. It is no longer an error - * to call cuProfilerStop() when profiling is already disabled. - */ - CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8, + /** + * \deprecated + * This error return is deprecated as of CUDA 5.0. It is no longer an error + * to call cuProfilerStop() when profiling is already disabled. + */ + CUDA_ERROR_PROFILER_ALREADY_STOPPED = 8, - /** - * This indicates that no CUDA-capable devices were detected by the installed - * CUDA driver. - */ - CUDA_ERROR_NO_DEVICE = 100, + /** + * This indicates that no CUDA-capable devices were detected by the installed + * CUDA driver. + */ + CUDA_ERROR_NO_DEVICE = 100, - /** - * This indicates that the device ordinal supplied by the user does not - * correspond to a valid CUDA device. - */ - CUDA_ERROR_INVALID_DEVICE = 101, + /** + * This indicates that the device ordinal supplied by the user does not + * correspond to a valid CUDA device. + */ + CUDA_ERROR_INVALID_DEVICE = 101, + /** + * This indicates that the device kernel image is invalid. This can also + * indicate an invalid CUDA module. + */ + CUDA_ERROR_INVALID_IMAGE = 200, - /** - * This indicates that the device kernel image is invalid. This can also - * indicate an invalid CUDA module. - */ - CUDA_ERROR_INVALID_IMAGE = 200, + /** + * This most frequently indicates that there is no context bound to the + * current thread. This can also be returned if the context passed to an + * API call is not a valid handle (such as a context that has had + * ::cuCtxDestroy() invoked on it). This can also be returned if a user + * mixes different API versions (i.e. 3010 context with 3020 API calls). + * See ::cuCtxGetApiVersion() for more details. + */ + CUDA_ERROR_INVALID_CONTEXT = 201, - /** - * This most frequently indicates that there is no context bound to the - * current thread. This can also be returned if the context passed to an - * API call is not a valid handle (such as a context that has had - * ::cuCtxDestroy() invoked on it). This can also be returned if a user - * mixes different API versions (i.e. 3010 context with 3020 API calls). - * See ::cuCtxGetApiVersion() for more details. - */ - CUDA_ERROR_INVALID_CONTEXT = 201, + /** + * This indicated that the context being supplied as a parameter to the + * API call was already the active context. + * \deprecated + * This error return is deprecated as of CUDA 3.2. It is no longer an + * error to attempt to push the active context via ::cuCtxPushCurrent(). + */ + CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202, - /** - * This indicated that the context being supplied as a parameter to the - * API call was already the active context. - * \deprecated - * This error return is deprecated as of CUDA 3.2. It is no longer an - * error to attempt to push the active context via ::cuCtxPushCurrent(). - */ - CUDA_ERROR_CONTEXT_ALREADY_CURRENT = 202, + /** + * This indicates that a map or register operation has failed. + */ + CUDA_ERROR_MAP_FAILED = 205, - /** - * This indicates that a map or register operation has failed. - */ - CUDA_ERROR_MAP_FAILED = 205, + /** + * This indicates that an unmap or unregister operation has failed. + */ + CUDA_ERROR_UNMAP_FAILED = 206, - /** - * This indicates that an unmap or unregister operation has failed. - */ - CUDA_ERROR_UNMAP_FAILED = 206, + /** + * This indicates that the specified array is currently mapped and thus + * cannot be destroyed. + */ + CUDA_ERROR_ARRAY_IS_MAPPED = 207, - /** - * This indicates that the specified array is currently mapped and thus - * cannot be destroyed. - */ - CUDA_ERROR_ARRAY_IS_MAPPED = 207, + /** + * This indicates that the resource is already mapped. + */ + CUDA_ERROR_ALREADY_MAPPED = 208, - /** - * This indicates that the resource is already mapped. - */ - CUDA_ERROR_ALREADY_MAPPED = 208, + /** + * This indicates that there is no kernel image available that is suitable + * for the device. This can occur when a user specifies code generation + * options for a particular CUDA source file that do not include the + * corresponding device configuration. + */ + CUDA_ERROR_NO_BINARY_FOR_GPU = 209, - /** - * This indicates that there is no kernel image available that is suitable - * for the device. This can occur when a user specifies code generation - * options for a particular CUDA source file that do not include the - * corresponding device configuration. - */ - CUDA_ERROR_NO_BINARY_FOR_GPU = 209, + /** + * This indicates that a resource has already been acquired. + */ + CUDA_ERROR_ALREADY_ACQUIRED = 210, - /** - * This indicates that a resource has already been acquired. - */ - CUDA_ERROR_ALREADY_ACQUIRED = 210, + /** + * This indicates that a resource is not mapped. + */ + CUDA_ERROR_NOT_MAPPED = 211, - /** - * This indicates that a resource is not mapped. - */ - CUDA_ERROR_NOT_MAPPED = 211, + /** + * This indicates that a mapped resource is not available for access as an + * array. + */ + CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212, - /** - * This indicates that a mapped resource is not available for access as an - * array. - */ - CUDA_ERROR_NOT_MAPPED_AS_ARRAY = 212, + /** + * This indicates that a mapped resource is not available for access as a + * pointer. + */ + CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213, - /** - * This indicates that a mapped resource is not available for access as a - * pointer. - */ - CUDA_ERROR_NOT_MAPPED_AS_POINTER = 213, + /** + * This indicates that an uncorrectable ECC error was detected during + * execution. + */ + CUDA_ERROR_ECC_UNCORRECTABLE = 214, - /** - * This indicates that an uncorrectable ECC error was detected during - * execution. - */ - CUDA_ERROR_ECC_UNCORRECTABLE = 214, + /** + * This indicates that the ::CUlimit passed to the API call is not + * supported by the active device. + */ + CUDA_ERROR_UNSUPPORTED_LIMIT = 215, - /** - * This indicates that the ::CUlimit passed to the API call is not - * supported by the active device. - */ - CUDA_ERROR_UNSUPPORTED_LIMIT = 215, + /** + * This indicates that the ::CUcontext passed to the API call can + * only be bound to a single CPU thread at a time but is already + * bound to a CPU thread. + */ + CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216, - /** - * This indicates that the ::CUcontext passed to the API call can - * only be bound to a single CPU thread at a time but is already - * bound to a CPU thread. - */ - CUDA_ERROR_CONTEXT_ALREADY_IN_USE = 216, + /** + * This indicates that peer access is not supported across the given + * devices. + */ + CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217, - /** - * This indicates that peer access is not supported across the given - * devices. - */ - CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = 217, + /** + * This indicates that a PTX JIT compilation failed. + */ + CUDA_ERROR_INVALID_PTX = 218, - /** - * This indicates that a PTX JIT compilation failed. - */ - CUDA_ERROR_INVALID_PTX = 218, + /** + * This indicates an error with OpenGL or DirectX context. + */ + CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219, - /** - * This indicates an error with OpenGL or DirectX context. - */ - CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = 219, + /** + * This indicates that an uncorrectable NVLink error was detected during the + * execution. + */ + CUDA_ERROR_NVLINK_UNCORRECTABLE = 220, - /** - * This indicates that an uncorrectable NVLink error was detected during the - * execution. - */ - CUDA_ERROR_NVLINK_UNCORRECTABLE = 220, + /** + * This indicates that the PTX JIT compiler library was not found. + */ + CUDA_ERROR_JIT_COMPILER_NOT_FOUND = 221, - /** - * This indicates that the device kernel source is invalid. - */ - CUDA_ERROR_INVALID_SOURCE = 300, + /** + * This indicates that the device kernel source is invalid. + */ + CUDA_ERROR_INVALID_SOURCE = 300, - /** - * This indicates that the file specified was not found. - */ - CUDA_ERROR_FILE_NOT_FOUND = 301, + /** + * This indicates that the file specified was not found. + */ + CUDA_ERROR_FILE_NOT_FOUND = 301, - /** - * This indicates that a link to a shared object failed to resolve. - */ - CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302, + /** + * This indicates that a link to a shared object failed to resolve. + */ + CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = 302, - /** - * This indicates that initialization of a shared object failed. - */ - CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303, + /** + * This indicates that initialization of a shared object failed. + */ + CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = 303, - /** - * This indicates that an OS call failed. - */ - CUDA_ERROR_OPERATING_SYSTEM = 304, + /** + * This indicates that an OS call failed. + */ + CUDA_ERROR_OPERATING_SYSTEM = 304, - /** - * This indicates that a resource handle passed to the API call was not - * valid. Resource handles are opaque types like ::CUstream and ::CUevent. - */ - CUDA_ERROR_INVALID_HANDLE = 400, + /** + * This indicates that a resource handle passed to the API call was not + * valid. Resource handles are opaque types like ::CUstream and ::CUevent. + */ + CUDA_ERROR_INVALID_HANDLE = 400, - /** - * This indicates that a named symbol was not found. Examples of symbols - * are global/constant variable names, texture names, and surface names. - */ - CUDA_ERROR_NOT_FOUND = 500, + /** + * This indicates that a resource required by the API call is not in a + * valid state to perform the requested operation. + */ + CUDA_ERROR_ILLEGAL_STATE = 401, - /** - * This indicates that asynchronous operations issued previously have not - * completed yet. This result is not actually an error, but must be indicated - * differently than ::CUDA_SUCCESS (which indicates completion). Calls that - * may return this value include ::cuEventQuery() and ::cuStreamQuery(). - */ - CUDA_ERROR_NOT_READY = 600, + /** + * This indicates that a named symbol was not found. Examples of symbols + * are global/constant variable names, texture names, and surface names. + */ + CUDA_ERROR_NOT_FOUND = 500, - /** - * While executing a kernel, the device encountered a - * load or store instruction on an invalid memory address. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_ILLEGAL_ADDRESS = 700, + /** + * This indicates that asynchronous operations issued previously have not + * completed yet. This result is not actually an error, but must be indicated + * differently than ::CUDA_SUCCESS (which indicates completion). Calls that + * may return this value include ::cuEventQuery() and ::cuStreamQuery(). + */ + CUDA_ERROR_NOT_READY = 600, - /** - * This indicates that a launch did not occur because it did not have - * appropriate resources. This error usually indicates that the user has - * attempted to pass too many arguments to the device kernel, or the - * kernel launch specifies too many threads for the kernel's register - * count. Passing arguments of the wrong size (i.e. a 64-bit pointer - * when a 32-bit int is expected) is equivalent to passing too many - * arguments and can also result in this error. - */ - CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701, + /** + * While executing a kernel, the device encountered a + * load or store instruction on an invalid memory address. + * This leaves the process in an inconsistent state and any further CUDA work + * will return the same error. To continue using CUDA, the process must be + * terminated and relaunched. + */ + CUDA_ERROR_ILLEGAL_ADDRESS = 700, - /** - * This indicates that the device kernel took too long to execute. This can - * only occur if timeouts are enabled - see the device attribute - * ::CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT for more information. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_LAUNCH_TIMEOUT = 702, + /** + * This indicates that a launch did not occur because it did not have + * appropriate resources. This error usually indicates that the user has + * attempted to pass too many arguments to the device kernel, or the + * kernel launch specifies too many threads for the kernel's register + * count. Passing arguments of the wrong size (i.e. a 64-bit pointer + * when a 32-bit int is expected) is equivalent to passing too many + * arguments and can also result in this error. + */ + CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701, - /** - * This error indicates a kernel launch that uses an incompatible texturing - * mode. - */ - CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703, - - /** - * This error indicates that a call to ::cuCtxEnablePeerAccess() is - * trying to re-enable peer access to a context which has already - * had peer access to it enabled. - */ - CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704, + /** + * This indicates that the device kernel took too long to execute. This can + * only occur if timeouts are enabled - see the device attribute + * ::CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT for more information. + * This leaves the process in an inconsistent state and any further CUDA work + * will return the same error. To continue using CUDA, the process must be + * terminated and relaunched. + */ + CUDA_ERROR_LAUNCH_TIMEOUT = 702, - /** - * This error indicates that ::cuCtxDisablePeerAccess() is - * trying to disable peer access which has not been enabled yet - * via ::cuCtxEnablePeerAccess(). - */ - CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705, + /** + * This error indicates a kernel launch that uses an incompatible texturing + * mode. + */ + CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703, - /** - * This error indicates that the primary context for the specified device - * has already been initialized. - */ - CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708, + /** + * This error indicates that a call to ::cuCtxEnablePeerAccess() is + * trying to re-enable peer access to a context which has already + * had peer access to it enabled. + */ + CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = 704, - /** - * This error indicates that the context current to the calling thread - * has been destroyed using ::cuCtxDestroy, or is a primary context which - * has not yet been initialized. - */ - CUDA_ERROR_CONTEXT_IS_DESTROYED = 709, + /** + * This error indicates that ::cuCtxDisablePeerAccess() is + * trying to disable peer access which has not been enabled yet + * via ::cuCtxEnablePeerAccess(). + */ + CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = 705, - /** - * A device-side assert triggered during kernel execution. The context - * cannot be used anymore, and must be destroyed. All existing device - * memory allocations from this context are invalid and must be - * reconstructed if the program is to continue using CUDA. - */ - CUDA_ERROR_ASSERT = 710, + /** + * This error indicates that the primary context for the specified device + * has already been initialized. + */ + CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = 708, - /** - * This error indicates that the hardware resources required to enable - * peer access have been exhausted for one or more of the devices - * passed to ::cuCtxEnablePeerAccess(). - */ - CUDA_ERROR_TOO_MANY_PEERS = 711, + /** + * This error indicates that the context current to the calling thread + * has been destroyed using ::cuCtxDestroy, or is a primary context which + * has not yet been initialized. + */ + CUDA_ERROR_CONTEXT_IS_DESTROYED = 709, - /** - * This error indicates that the memory range passed to ::cuMemHostRegister() - * has already been registered. - */ - CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712, + /** + * A device-side assert triggered during kernel execution. The context + * cannot be used anymore, and must be destroyed. All existing device + * memory allocations from this context are invalid and must be + * reconstructed if the program is to continue using CUDA. + */ + CUDA_ERROR_ASSERT = 710, - /** - * This error indicates that the pointer passed to ::cuMemHostUnregister() - * does not correspond to any currently registered memory region. - */ - CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713, + /** + * This error indicates that the hardware resources required to enable + * peer access have been exhausted for one or more of the devices + * passed to ::cuCtxEnablePeerAccess(). + */ + CUDA_ERROR_TOO_MANY_PEERS = 711, - /** - * While executing a kernel, the device encountered a stack error. - * This can be due to stack corruption or exceeding the stack size limit. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_HARDWARE_STACK_ERROR = 714, + /** + * This error indicates that the memory range passed to ::cuMemHostRegister() + * has already been registered. + */ + CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = 712, - /** - * While executing a kernel, the device encountered an illegal instruction. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_ILLEGAL_INSTRUCTION = 715, + /** + * This error indicates that the pointer passed to ::cuMemHostUnregister() + * does not correspond to any currently registered memory region. + */ + CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = 713, - /** - * While executing a kernel, the device encountered a load or store instruction - * on a memory address which is not aligned. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_MISALIGNED_ADDRESS = 716, + /** + * While executing a kernel, the device encountered a stack error. + * This can be due to stack corruption or exceeding the stack size limit. + * This leaves the process in an inconsistent state and any further CUDA work + * will return the same error. To continue using CUDA, the process must be + * terminated and relaunched. + */ + CUDA_ERROR_HARDWARE_STACK_ERROR = 714, - /** - * While executing a kernel, the device encountered an instruction - * which can only operate on memory locations in certain address spaces - * (global, shared, or local), but was supplied a memory address not - * belonging to an allowed address space. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_INVALID_ADDRESS_SPACE = 717, + /** + * While executing a kernel, the device encountered an illegal instruction. + * This leaves the process in an inconsistent state and any further CUDA work + * will return the same error. To continue using CUDA, the process must be + * terminated and relaunched. + */ + CUDA_ERROR_ILLEGAL_INSTRUCTION = 715, - /** - * While executing a kernel, the device program counter wrapped its address space. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_INVALID_PC = 718, + /** + * While executing a kernel, the device encountered a load or store + * instruction on a memory address which is not aligned. This leaves the + * process in an inconsistent state and any further CUDA work will return the + * same error. To continue using CUDA, the process must be terminated and + * relaunched. + */ + CUDA_ERROR_MISALIGNED_ADDRESS = 716, - /** - * An exception occurred on the device while executing a kernel. Common - * causes include dereferencing an invalid device pointer and accessing - * out of bounds shared memory. - * This leaves the process in an inconsistent state and any further CUDA work - * will return the same error. To continue using CUDA, the process must be terminated - * and relaunched. - */ - CUDA_ERROR_LAUNCH_FAILED = 719, + /** + * While executing a kernel, the device encountered an instruction + * which can only operate on memory locations in certain address spaces + * (global, shared, or local), but was supplied a memory address not + * belonging to an allowed address space. + * This leaves the process in an inconsistent state and any further CUDA work + * will return the same error. To continue using CUDA, the process must be + * terminated and relaunched. + */ + CUDA_ERROR_INVALID_ADDRESS_SPACE = 717, + /** + * While executing a kernel, the device program counter wrapped its address + * space. This leaves the process in an inconsistent state and any further + * CUDA work will return the same error. To continue using CUDA, the process + * must be terminated and relaunched. + */ + CUDA_ERROR_INVALID_PC = 718, - /** - * This error indicates that the attempted operation is not permitted. - */ - CUDA_ERROR_NOT_PERMITTED = 800, + /** + * An exception occurred on the device while executing a kernel. Common + * causes include dereferencing an invalid device pointer and accessing + * out of bounds shared memory. Less common cases can be system specific - + * more information about these cases can be found in the system specific user + * guide. This leaves the process in an inconsistent state and any further + * CUDA work will return the same error. To continue using CUDA, the process + * must be terminated and relaunched. + */ + CUDA_ERROR_LAUNCH_FAILED = 719, - /** - * This error indicates that the attempted operation is not supported - * on the current system or device. - */ - CUDA_ERROR_NOT_SUPPORTED = 801, + /** + * This error indicates that the number of blocks launched per grid for a + * kernel that was launched via either ::cuLaunchCooperativeKernel or + * ::cuLaunchCooperativeKernelMultiDevice exceeds the maximum number of blocks + * as allowed by ::cuOccupancyMaxActiveBlocksPerMultiprocessor or + * ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of + * multiprocessors as specified by the device attribute + * ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT. + */ + CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = 720, - /** - * This indicates that an unknown internal error has occurred. - */ - CUDA_ERROR_UNKNOWN = 999 + /** + * This error indicates that the attempted operation is not permitted. + */ + CUDA_ERROR_NOT_PERMITTED = 800, + + /** + * This error indicates that the attempted operation is not supported + * on the current system or device. + */ + CUDA_ERROR_NOT_SUPPORTED = 801, + + /** + * This error indicates that the system is not yet ready to start any CUDA + * work. To continue using CUDA, verify the system configuration is in a + * valid state and all required driver daemons are actively running. + * More information about this error can be found in the system specific + * user guide. + */ + CUDA_ERROR_SYSTEM_NOT_READY = 802, + + /** + * This error indicates that there is a mismatch between the versions of + * the display driver and the CUDA driver. Refer to the compatibility + * documentation for supported versions. + */ + CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = 803, + + /** + * This error indicates that the system was upgraded to run with forward + * compatibility but the visible hardware detected by CUDA does not support + * this configuration. Refer to the compatibility documentation for the + * supported hardware matrix or ensure that only supported hardware is visible + * during initialization via the CUDA_VISIBLE_DEVICES environment variable. + */ + CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = 804, + + /** + * This error indicates that the operation is not permitted when + * the stream is capturing. + */ + CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = 900, + + /** + * This error indicates that the current capture sequence on the stream + * has been invalidated due to a previous error. + */ + CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = 901, + + /** + * This error indicates that the operation would have resulted in a merge + * of two independent capture sequences. + */ + CUDA_ERROR_STREAM_CAPTURE_MERGE = 902, + + /** + * This error indicates that the capture was not initiated in this stream. + */ + CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = 903, + + /** + * This error indicates that the capture sequence contains a fork that was + * not joined to the primary stream. + */ + CUDA_ERROR_STREAM_CAPTURE_UNJOINED = 904, + + /** + * This error indicates that a dependency would have been created which + * crosses the capture sequence boundary. Only implicit in-stream ordering + * dependencies are allowed to cross the boundary. + */ + CUDA_ERROR_STREAM_CAPTURE_ISOLATION = 905, + + /** + * This error indicates a disallowed implicit dependency on a current capture + * sequence from cudaStreamLegacy. + */ + CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = 906, + + /** + * This error indicates that the operation is not permitted on an event which + * was last recorded in a capturing stream. + */ + CUDA_ERROR_CAPTURED_EVENT = 907, + + /** + * A stream capture sequence not initiated with the + * ::CU_STREAM_CAPTURE_MODE_RELAXED argument to ::cuStreamBeginCapture was + * passed to ::cuStreamEndCapture in a different thread. + */ + CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = 908, + + /** + * This indicates that an unknown internal error has occurred. + */ + CUDA_ERROR_UNKNOWN = 999 } CUresult; /** * P2P Attributes */ typedef enum CUdevice_P2PAttribute_enum { - CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 0x01, /**< A relative value indicating the performance of the link between two devices */ - CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 0x02, /**< P2P Access is enable */ - CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 0x03 /**< Atomic operation over the link supported */ + CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = + 0x01, /**< A relative value indicating the performance of the link between + two devices */ + CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 0x02, /**< P2P Access is enable */ + CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = + 0x03, /**< Atomic operation over the link supported */ + CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = + 0x04, /**< \deprecated use + CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED instead */ + CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED = + 0x04 /**< Accessing CUDA arrays over the link supported */ } CUdevice_P2PAttribute; -#ifdef _WIN32 -#define CUDA_CB __stdcall -#else -#define CUDA_CB -#endif - /** * CUDA stream callback - * \param hStream The stream the callback was added to, as passed to ::cuStreamAddCallback. May be NULL. - * \param status ::CUDA_SUCCESS or any persistent error on the stream. - * \param userData User parameter provided at registration. + * \param hStream The stream the callback was added to, as passed to + * ::cuStreamAddCallback. May be NULL. \param status ::CUDA_SUCCESS or any + * persistent error on the stream. \param userData User parameter provided at + * registration. */ -typedef void (CUDA_CB *CUstreamCallback)(CUstream hStream, CUresult status, void *userData); +typedef void(CUDA_CB *CUstreamCallback)(CUstream hStream, CUresult status, + void *userData); /** * Block size to per-block dynamic shared memory mapping for a certain @@ -1413,20 +1921,20 @@ typedef void (CUDA_CB *CUstreamCallback)(CUstream hStream, CUresult status, void * * \return The dynamic shared memory needed by a block. */ -typedef size_t (CUDA_CB *CUoccupancyB2DSize)(int blockSize); +typedef size_t(CUDA_CB *CUoccupancyB2DSize)(int blockSize); /** * If set, host memory is portable between CUDA contexts. * Flag for ::cuMemHostAlloc() */ -#define CU_MEMHOSTALLOC_PORTABLE 0x01 +#define CU_MEMHOSTALLOC_PORTABLE 0x01 /** * If set, host memory is mapped into CUDA address space and * ::cuMemHostGetDevicePointer() may be called on the host pointer. * Flag for ::cuMemHostAlloc() */ -#define CU_MEMHOSTALLOC_DEVICEMAP 0x02 +#define CU_MEMHOSTALLOC_DEVICEMAP 0x02 /** * If set, host memory is allocated as write-combined - fast to write, @@ -1434,20 +1942,20 @@ typedef size_t (CUDA_CB *CUoccupancyB2DSize)(int blockSize); * (MOVNTDQA). * Flag for ::cuMemHostAlloc() */ -#define CU_MEMHOSTALLOC_WRITECOMBINED 0x04 +#define CU_MEMHOSTALLOC_WRITECOMBINED 0x04 /** * If set, host memory is portable between CUDA contexts. * Flag for ::cuMemHostRegister() */ -#define CU_MEMHOSTREGISTER_PORTABLE 0x01 +#define CU_MEMHOSTREGISTER_PORTABLE 0x01 /** * If set, host memory is mapped into CUDA address space and * ::cuMemHostGetDevicePointer() may be called on the host pointer. * Flag for ::cuMemHostRegister() */ -#define CU_MEMHOSTREGISTER_DEVICEMAP 0x02 +#define CU_MEMHOSTREGISTER_DEVICEMAP 0x02 /** * If set, the passed memory pointer is treated as pointing to some @@ -1461,7 +1969,7 @@ typedef size_t (CUDA_CB *CUoccupancyB2DSize)(int blockSize); * is returned. * Flag for ::cuMemHostRegister() */ -#define CU_MEMHOSTREGISTER_IOMEMORY 0x04 +#define CU_MEMHOSTREGISTER_IOMEMORY 0x04 #if __CUDA_API_VERSION >= 3020 @@ -1469,118 +1977,125 @@ typedef size_t (CUDA_CB *CUoccupancyB2DSize)(int blockSize); * 2D memory copy parameters */ typedef struct CUDA_MEMCPY2D_st { - size_t srcXInBytes; /**< Source X in bytes */ - size_t srcY; /**< Source Y */ + size_t srcXInBytes; /**< Source X in bytes */ + size_t srcY; /**< Source Y */ - CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ - const void *srcHost; /**< Source host pointer */ - CUdeviceptr srcDevice; /**< Source device pointer */ - CUarray srcArray; /**< Source array reference */ - size_t srcPitch; /**< Source pitch (ignored when src is array) */ + CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ + const void *srcHost; /**< Source host pointer */ + CUdeviceptr srcDevice; /**< Source device pointer */ + CUarray srcArray; /**< Source array reference */ + size_t srcPitch; /**< Source pitch (ignored when src is array) */ - size_t dstXInBytes; /**< Destination X in bytes */ - size_t dstY; /**< Destination Y */ + size_t dstXInBytes; /**< Destination X in bytes */ + size_t dstY; /**< Destination Y */ - CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ - void *dstHost; /**< Destination host pointer */ - CUdeviceptr dstDevice; /**< Destination device pointer */ - CUarray dstArray; /**< Destination array reference */ - size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ + CUmemorytype + dstMemoryType; /**< Destination memory type (host, device, array) */ + void *dstHost; /**< Destination host pointer */ + CUdeviceptr dstDevice; /**< Destination device pointer */ + CUarray dstArray; /**< Destination array reference */ + size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ - size_t WidthInBytes; /**< Width of 2D memory copy in bytes */ - size_t Height; /**< Height of 2D memory copy */ + size_t WidthInBytes; /**< Width of 2D memory copy in bytes */ + size_t Height; /**< Height of 2D memory copy */ } CUDA_MEMCPY2D; /** * 3D memory copy parameters */ typedef struct CUDA_MEMCPY3D_st { - size_t srcXInBytes; /**< Source X in bytes */ - size_t srcY; /**< Source Y */ - size_t srcZ; /**< Source Z */ - size_t srcLOD; /**< Source LOD */ - CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ - const void *srcHost; /**< Source host pointer */ - CUdeviceptr srcDevice; /**< Source device pointer */ - CUarray srcArray; /**< Source array reference */ - void *reserved0; /**< Must be NULL */ - size_t srcPitch; /**< Source pitch (ignored when src is array) */ - size_t srcHeight; /**< Source height (ignored when src is array; may be 0 if Depth==1) */ + size_t srcXInBytes; /**< Source X in bytes */ + size_t srcY; /**< Source Y */ + size_t srcZ; /**< Source Z */ + size_t srcLOD; /**< Source LOD */ + CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ + const void *srcHost; /**< Source host pointer */ + CUdeviceptr srcDevice; /**< Source device pointer */ + CUarray srcArray; /**< Source array reference */ + void *reserved0; /**< Must be NULL */ + size_t srcPitch; /**< Source pitch (ignored when src is array) */ + size_t srcHeight; /**< Source height (ignored when src is array; may be 0 if + Depth==1) */ - size_t dstXInBytes; /**< Destination X in bytes */ - size_t dstY; /**< Destination Y */ - size_t dstZ; /**< Destination Z */ - size_t dstLOD; /**< Destination LOD */ - CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ - void *dstHost; /**< Destination host pointer */ - CUdeviceptr dstDevice; /**< Destination device pointer */ - CUarray dstArray; /**< Destination array reference */ - void *reserved1; /**< Must be NULL */ - size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ - size_t dstHeight; /**< Destination height (ignored when dst is array; may be 0 if Depth==1) */ + size_t dstXInBytes; /**< Destination X in bytes */ + size_t dstY; /**< Destination Y */ + size_t dstZ; /**< Destination Z */ + size_t dstLOD; /**< Destination LOD */ + CUmemorytype + dstMemoryType; /**< Destination memory type (host, device, array) */ + void *dstHost; /**< Destination host pointer */ + CUdeviceptr dstDevice; /**< Destination device pointer */ + CUarray dstArray; /**< Destination array reference */ + void *reserved1; /**< Must be NULL */ + size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ + size_t dstHeight; /**< Destination height (ignored when dst is array; may be 0 + if Depth==1) */ - size_t WidthInBytes; /**< Width of 3D memory copy in bytes */ - size_t Height; /**< Height of 3D memory copy */ - size_t Depth; /**< Depth of 3D memory copy */ + size_t WidthInBytes; /**< Width of 3D memory copy in bytes */ + size_t Height; /**< Height of 3D memory copy */ + size_t Depth; /**< Depth of 3D memory copy */ } CUDA_MEMCPY3D; /** * 3D memory cross-context copy parameters */ typedef struct CUDA_MEMCPY3D_PEER_st { - size_t srcXInBytes; /**< Source X in bytes */ - size_t srcY; /**< Source Y */ - size_t srcZ; /**< Source Z */ - size_t srcLOD; /**< Source LOD */ - CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ - const void *srcHost; /**< Source host pointer */ - CUdeviceptr srcDevice; /**< Source device pointer */ - CUarray srcArray; /**< Source array reference */ - CUcontext srcContext; /**< Source context (ignored with srcMemoryType is ::CU_MEMORYTYPE_ARRAY) */ - size_t srcPitch; /**< Source pitch (ignored when src is array) */ - size_t srcHeight; /**< Source height (ignored when src is array; may be 0 if Depth==1) */ + size_t srcXInBytes; /**< Source X in bytes */ + size_t srcY; /**< Source Y */ + size_t srcZ; /**< Source Z */ + size_t srcLOD; /**< Source LOD */ + CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ + const void *srcHost; /**< Source host pointer */ + CUdeviceptr srcDevice; /**< Source device pointer */ + CUarray srcArray; /**< Source array reference */ + CUcontext srcContext; /**< Source context (ignored with srcMemoryType is + ::CU_MEMORYTYPE_ARRAY) */ + size_t srcPitch; /**< Source pitch (ignored when src is array) */ + size_t srcHeight; /**< Source height (ignored when src is array; may be 0 if + Depth==1) */ - size_t dstXInBytes; /**< Destination X in bytes */ - size_t dstY; /**< Destination Y */ - size_t dstZ; /**< Destination Z */ - size_t dstLOD; /**< Destination LOD */ - CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ - void *dstHost; /**< Destination host pointer */ - CUdeviceptr dstDevice; /**< Destination device pointer */ - CUarray dstArray; /**< Destination array reference */ - CUcontext dstContext; /**< Destination context (ignored with dstMemoryType is ::CU_MEMORYTYPE_ARRAY) */ - size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ - size_t dstHeight; /**< Destination height (ignored when dst is array; may be 0 if Depth==1) */ + size_t dstXInBytes; /**< Destination X in bytes */ + size_t dstY; /**< Destination Y */ + size_t dstZ; /**< Destination Z */ + size_t dstLOD; /**< Destination LOD */ + CUmemorytype + dstMemoryType; /**< Destination memory type (host, device, array) */ + void *dstHost; /**< Destination host pointer */ + CUdeviceptr dstDevice; /**< Destination device pointer */ + CUarray dstArray; /**< Destination array reference */ + CUcontext dstContext; /**< Destination context (ignored with dstMemoryType is + ::CU_MEMORYTYPE_ARRAY) */ + size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ + size_t dstHeight; /**< Destination height (ignored when dst is array; may be 0 + if Depth==1) */ - size_t WidthInBytes; /**< Width of 3D memory copy in bytes */ - size_t Height; /**< Height of 3D memory copy */ - size_t Depth; /**< Depth of 3D memory copy */ + size_t WidthInBytes; /**< Width of 3D memory copy in bytes */ + size_t Height; /**< Height of 3D memory copy */ + size_t Depth; /**< Depth of 3D memory copy */ } CUDA_MEMCPY3D_PEER; /** * Array descriptor */ -typedef struct CUDA_ARRAY_DESCRIPTOR_st -{ - size_t Width; /**< Width of array */ - size_t Height; /**< Height of array */ +typedef struct CUDA_ARRAY_DESCRIPTOR_st { + size_t Width; /**< Width of array */ + size_t Height; /**< Height of array */ - CUarray_format Format; /**< Array format */ - unsigned int NumChannels; /**< Channels per array element */ + CUarray_format Format; /**< Array format */ + unsigned int NumChannels; /**< Channels per array element */ } CUDA_ARRAY_DESCRIPTOR; /** * 3D array descriptor */ -typedef struct CUDA_ARRAY3D_DESCRIPTOR_st -{ - size_t Width; /**< Width of 3D array */ - size_t Height; /**< Height of 3D array */ - size_t Depth; /**< Depth of 3D array */ +typedef struct CUDA_ARRAY3D_DESCRIPTOR_st { + size_t Width; /**< Width of 3D array */ + size_t Height; /**< Height of 3D array */ + size_t Depth; /**< Depth of 3D array */ - CUarray_format Format; /**< Array format */ - unsigned int NumChannels; /**< Channels per array element */ - unsigned int Flags; /**< Flags */ + CUarray_format Format; /**< Array format */ + unsigned int NumChannels; /**< Channels per array element */ + unsigned int Flags; /**< Flags */ } CUDA_ARRAY3D_DESCRIPTOR; #endif /* __CUDA_API_VERSION >= 3020 */ @@ -1590,148 +2105,428 @@ typedef struct CUDA_ARRAY3D_DESCRIPTOR_st /** * CUDA Resource descriptor */ -typedef struct CUDA_RESOURCE_DESC_st -{ - CUresourcetype resType; /**< Resource type */ +typedef struct CUDA_RESOURCE_DESC_st { + CUresourcetype resType; /**< Resource type */ - union { - struct { - CUarray hArray; /**< CUDA array */ - } array; - struct { - CUmipmappedArray hMipmappedArray; /**< CUDA mipmapped array */ - } mipmap; - struct { - CUdeviceptr devPtr; /**< Device pointer */ - CUarray_format format; /**< Array format */ - unsigned int numChannels; /**< Channels per array element */ - size_t sizeInBytes; /**< Size in bytes */ - } linear; - struct { - CUdeviceptr devPtr; /**< Device pointer */ - CUarray_format format; /**< Array format */ - unsigned int numChannels; /**< Channels per array element */ - size_t width; /**< Width of the array in elements */ - size_t height; /**< Height of the array in elements */ - size_t pitchInBytes; /**< Pitch between two rows in bytes */ - } pitch2D; - struct { - int reserved[32]; - } reserved; - } res; + union { + struct { + CUarray hArray; /**< CUDA array */ + } array; + struct { + CUmipmappedArray hMipmappedArray; /**< CUDA mipmapped array */ + } mipmap; + struct { + CUdeviceptr devPtr; /**< Device pointer */ + CUarray_format format; /**< Array format */ + unsigned int numChannels; /**< Channels per array element */ + size_t sizeInBytes; /**< Size in bytes */ + } linear; + struct { + CUdeviceptr devPtr; /**< Device pointer */ + CUarray_format format; /**< Array format */ + unsigned int numChannels; /**< Channels per array element */ + size_t width; /**< Width of the array in elements */ + size_t height; /**< Height of the array in elements */ + size_t pitchInBytes; /**< Pitch between two rows in bytes */ + } pitch2D; + struct { + int reserved[32]; + } reserved; + } res; - unsigned int flags; /**< Flags (must be zero) */ + unsigned int flags; /**< Flags (must be zero) */ } CUDA_RESOURCE_DESC; /** * Texture descriptor */ typedef struct CUDA_TEXTURE_DESC_st { - CUaddress_mode addressMode[3]; /**< Address modes */ - CUfilter_mode filterMode; /**< Filter mode */ - unsigned int flags; /**< Flags */ - unsigned int maxAnisotropy; /**< Maximum anisotropy ratio */ - CUfilter_mode mipmapFilterMode; /**< Mipmap filter mode */ - float mipmapLevelBias; /**< Mipmap level bias */ - float minMipmapLevelClamp; /**< Mipmap minimum level clamp */ - float maxMipmapLevelClamp; /**< Mipmap maximum level clamp */ - float borderColor[4]; /**< Border Color */ - int reserved[12]; + CUaddress_mode addressMode[3]; /**< Address modes */ + CUfilter_mode filterMode; /**< Filter mode */ + unsigned int flags; /**< Flags */ + unsigned int maxAnisotropy; /**< Maximum anisotropy ratio */ + CUfilter_mode mipmapFilterMode; /**< Mipmap filter mode */ + float mipmapLevelBias; /**< Mipmap level bias */ + float minMipmapLevelClamp; /**< Mipmap minimum level clamp */ + float maxMipmapLevelClamp; /**< Mipmap maximum level clamp */ + float borderColor[4]; /**< Border Color */ + int reserved[12]; } CUDA_TEXTURE_DESC; /** * Resource view format */ -typedef enum CUresourceViewFormat_enum -{ - CU_RES_VIEW_FORMAT_NONE = 0x00, /**< No resource view format (use underlying resource format) */ - CU_RES_VIEW_FORMAT_UINT_1X8 = 0x01, /**< 1 channel unsigned 8-bit integers */ - CU_RES_VIEW_FORMAT_UINT_2X8 = 0x02, /**< 2 channel unsigned 8-bit integers */ - CU_RES_VIEW_FORMAT_UINT_4X8 = 0x03, /**< 4 channel unsigned 8-bit integers */ - CU_RES_VIEW_FORMAT_SINT_1X8 = 0x04, /**< 1 channel signed 8-bit integers */ - CU_RES_VIEW_FORMAT_SINT_2X8 = 0x05, /**< 2 channel signed 8-bit integers */ - CU_RES_VIEW_FORMAT_SINT_4X8 = 0x06, /**< 4 channel signed 8-bit integers */ - CU_RES_VIEW_FORMAT_UINT_1X16 = 0x07, /**< 1 channel unsigned 16-bit integers */ - CU_RES_VIEW_FORMAT_UINT_2X16 = 0x08, /**< 2 channel unsigned 16-bit integers */ - CU_RES_VIEW_FORMAT_UINT_4X16 = 0x09, /**< 4 channel unsigned 16-bit integers */ - CU_RES_VIEW_FORMAT_SINT_1X16 = 0x0a, /**< 1 channel signed 16-bit integers */ - CU_RES_VIEW_FORMAT_SINT_2X16 = 0x0b, /**< 2 channel signed 16-bit integers */ - CU_RES_VIEW_FORMAT_SINT_4X16 = 0x0c, /**< 4 channel signed 16-bit integers */ - CU_RES_VIEW_FORMAT_UINT_1X32 = 0x0d, /**< 1 channel unsigned 32-bit integers */ - CU_RES_VIEW_FORMAT_UINT_2X32 = 0x0e, /**< 2 channel unsigned 32-bit integers */ - CU_RES_VIEW_FORMAT_UINT_4X32 = 0x0f, /**< 4 channel unsigned 32-bit integers */ - CU_RES_VIEW_FORMAT_SINT_1X32 = 0x10, /**< 1 channel signed 32-bit integers */ - CU_RES_VIEW_FORMAT_SINT_2X32 = 0x11, /**< 2 channel signed 32-bit integers */ - CU_RES_VIEW_FORMAT_SINT_4X32 = 0x12, /**< 4 channel signed 32-bit integers */ - CU_RES_VIEW_FORMAT_FLOAT_1X16 = 0x13, /**< 1 channel 16-bit floating point */ - CU_RES_VIEW_FORMAT_FLOAT_2X16 = 0x14, /**< 2 channel 16-bit floating point */ - CU_RES_VIEW_FORMAT_FLOAT_4X16 = 0x15, /**< 4 channel 16-bit floating point */ - CU_RES_VIEW_FORMAT_FLOAT_1X32 = 0x16, /**< 1 channel 32-bit floating point */ - CU_RES_VIEW_FORMAT_FLOAT_2X32 = 0x17, /**< 2 channel 32-bit floating point */ - CU_RES_VIEW_FORMAT_FLOAT_4X32 = 0x18, /**< 4 channel 32-bit floating point */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 0x19, /**< Block compressed 1 */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 0x1a, /**< Block compressed 2 */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 0x1b, /**< Block compressed 3 */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 0x1c, /**< Block compressed 4 unsigned */ - CU_RES_VIEW_FORMAT_SIGNED_BC4 = 0x1d, /**< Block compressed 4 signed */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 0x1e, /**< Block compressed 5 unsigned */ - CU_RES_VIEW_FORMAT_SIGNED_BC5 = 0x1f, /**< Block compressed 5 signed */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 0x20, /**< Block compressed 6 unsigned half-float */ - CU_RES_VIEW_FORMAT_SIGNED_BC6H = 0x21, /**< Block compressed 6 signed half-float */ - CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 0x22 /**< Block compressed 7 */ +typedef enum CUresourceViewFormat_enum { + CU_RES_VIEW_FORMAT_NONE = + 0x00, /**< No resource view format (use underlying resource format) */ + CU_RES_VIEW_FORMAT_UINT_1X8 = 0x01, /**< 1 channel unsigned 8-bit integers */ + CU_RES_VIEW_FORMAT_UINT_2X8 = 0x02, /**< 2 channel unsigned 8-bit integers */ + CU_RES_VIEW_FORMAT_UINT_4X8 = 0x03, /**< 4 channel unsigned 8-bit integers */ + CU_RES_VIEW_FORMAT_SINT_1X8 = 0x04, /**< 1 channel signed 8-bit integers */ + CU_RES_VIEW_FORMAT_SINT_2X8 = 0x05, /**< 2 channel signed 8-bit integers */ + CU_RES_VIEW_FORMAT_SINT_4X8 = 0x06, /**< 4 channel signed 8-bit integers */ + CU_RES_VIEW_FORMAT_UINT_1X16 = + 0x07, /**< 1 channel unsigned 16-bit integers */ + CU_RES_VIEW_FORMAT_UINT_2X16 = + 0x08, /**< 2 channel unsigned 16-bit integers */ + CU_RES_VIEW_FORMAT_UINT_4X16 = + 0x09, /**< 4 channel unsigned 16-bit integers */ + CU_RES_VIEW_FORMAT_SINT_1X16 = 0x0a, /**< 1 channel signed 16-bit integers */ + CU_RES_VIEW_FORMAT_SINT_2X16 = 0x0b, /**< 2 channel signed 16-bit integers */ + CU_RES_VIEW_FORMAT_SINT_4X16 = 0x0c, /**< 4 channel signed 16-bit integers */ + CU_RES_VIEW_FORMAT_UINT_1X32 = + 0x0d, /**< 1 channel unsigned 32-bit integers */ + CU_RES_VIEW_FORMAT_UINT_2X32 = + 0x0e, /**< 2 channel unsigned 32-bit integers */ + CU_RES_VIEW_FORMAT_UINT_4X32 = + 0x0f, /**< 4 channel unsigned 32-bit integers */ + CU_RES_VIEW_FORMAT_SINT_1X32 = 0x10, /**< 1 channel signed 32-bit integers */ + CU_RES_VIEW_FORMAT_SINT_2X32 = 0x11, /**< 2 channel signed 32-bit integers */ + CU_RES_VIEW_FORMAT_SINT_4X32 = 0x12, /**< 4 channel signed 32-bit integers */ + CU_RES_VIEW_FORMAT_FLOAT_1X16 = 0x13, /**< 1 channel 16-bit floating point */ + CU_RES_VIEW_FORMAT_FLOAT_2X16 = 0x14, /**< 2 channel 16-bit floating point */ + CU_RES_VIEW_FORMAT_FLOAT_4X16 = 0x15, /**< 4 channel 16-bit floating point */ + CU_RES_VIEW_FORMAT_FLOAT_1X32 = 0x16, /**< 1 channel 32-bit floating point */ + CU_RES_VIEW_FORMAT_FLOAT_2X32 = 0x17, /**< 2 channel 32-bit floating point */ + CU_RES_VIEW_FORMAT_FLOAT_4X32 = 0x18, /**< 4 channel 32-bit floating point */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 0x19, /**< Block compressed 1 */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 0x1a, /**< Block compressed 2 */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 0x1b, /**< Block compressed 3 */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 0x1c, /**< Block compressed 4 unsigned */ + CU_RES_VIEW_FORMAT_SIGNED_BC4 = 0x1d, /**< Block compressed 4 signed */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 0x1e, /**< Block compressed 5 unsigned */ + CU_RES_VIEW_FORMAT_SIGNED_BC5 = 0x1f, /**< Block compressed 5 signed */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = + 0x20, /**< Block compressed 6 unsigned half-float */ + CU_RES_VIEW_FORMAT_SIGNED_BC6H = + 0x21, /**< Block compressed 6 signed half-float */ + CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 0x22 /**< Block compressed 7 */ } CUresourceViewFormat; /** * Resource view descriptor */ -typedef struct CUDA_RESOURCE_VIEW_DESC_st -{ - CUresourceViewFormat format; /**< Resource view format */ - size_t width; /**< Width of the resource view */ - size_t height; /**< Height of the resource view */ - size_t depth; /**< Depth of the resource view */ - unsigned int firstMipmapLevel; /**< First defined mipmap level */ - unsigned int lastMipmapLevel; /**< Last defined mipmap level */ - unsigned int firstLayer; /**< First layer index */ - unsigned int lastLayer; /**< Last layer index */ - unsigned int reserved[16]; +typedef struct CUDA_RESOURCE_VIEW_DESC_st { + CUresourceViewFormat format; /**< Resource view format */ + size_t width; /**< Width of the resource view */ + size_t height; /**< Height of the resource view */ + size_t depth; /**< Depth of the resource view */ + unsigned int firstMipmapLevel; /**< First defined mipmap level */ + unsigned int lastMipmapLevel; /**< Last defined mipmap level */ + unsigned int firstLayer; /**< First layer index */ + unsigned int lastLayer; /**< Last layer index */ + unsigned int reserved[16]; } CUDA_RESOURCE_VIEW_DESC; /** * GPU Direct v3 tokens */ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { - unsigned long long p2pToken; - unsigned int vaSpaceToken; + unsigned long long p2pToken; + unsigned int vaSpaceToken; } CUDA_POINTER_ATTRIBUTE_P2P_TOKENS; #endif /* __CUDA_API_VERSION >= 5000 */ +#if __CUDA_API_VERSION >= 9000 + +/** + * Kernel launch parameters + */ +typedef struct CUDA_LAUNCH_PARAMS_st { + CUfunction function; /**< Kernel to launch */ + unsigned int gridDimX; /**< Width of grid in blocks */ + unsigned int gridDimY; /**< Height of grid in blocks */ + unsigned int gridDimZ; /**< Depth of grid in blocks */ + unsigned int blockDimX; /**< X dimension of each thread block */ + unsigned int blockDimY; /**< Y dimension of each thread block */ + unsigned int blockDimZ; /**< Z dimension of each thread block */ + unsigned int sharedMemBytes; /**< Dynamic shared-memory size per thread block + in bytes */ + CUstream hStream; /**< Stream identifier */ + void **kernelParams; /**< Array of pointers to kernel parameters */ +} CUDA_LAUNCH_PARAMS; + +#endif /* __CUDA_API_VERSION >= 9000 */ + +#if __CUDA_API_VERSION >= 10000 + +/** + * External memory handle types + */ +typedef enum CUexternalMemoryHandleType_enum { + /** + * Handle is an opaque file descriptor + */ + CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = 1, + /** + * Handle is an opaque shared NT handle + */ + CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = 2, + /** + * Handle is an opaque, globally shared handle + */ + CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3, + /** + * Handle is a D3D12 heap object + */ + CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = 4, + /** + * Handle is a D3D12 committed resource + */ + CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = 5 +} CUexternalMemoryHandleType; + /** - * If set, the CUDA array is a collection of layers, where each layer is either a 1D - * or a 2D array and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies the number - * of layers, not the depth of a 3D array. + * Indicates that the external memory object is a dedicated resource */ -#define CUDA_ARRAY3D_LAYERED 0x01 +#define CUDA_EXTERNAL_MEMORY_DEDICATED 0x1 + +/** + * External memory handle descriptor + */ +typedef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st { + /** + * Type of the handle + */ + CUexternalMemoryHandleType type; + union { + /** + * File descriptor referencing the memory object. Valid + * when type is + * ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD + */ + int fd; + /** + * Win32 handle referencing the semaphore object. Valid when + * type is one of the following: + * - ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 + * - ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT + * - ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP + * - ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE + * Exactly one of 'handle' and 'name' must be non-NULL. If + * type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT + * then 'name' must be NULL. + */ + struct { + /** + * Valid NT handle. Must be NULL if 'name' is non-NULL + */ + void *handle; + /** + * Name of a valid memory object. + * Must be NULL if 'handle' is non-NULL. + */ + const void *name; + } win32; + } handle; + /** + * Size of the memory allocation + */ + unsigned long long size; + /** + * Flags must either be zero or ::CUDA_EXTERNAL_MEMORY_DEDICATED + */ + unsigned int flags; + unsigned int reserved[16]; +} CUDA_EXTERNAL_MEMORY_HANDLE_DESC; + +/** + * External memory buffer descriptor + */ +typedef struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st { + /** + * Offset into the memory object where the buffer's base is + */ + unsigned long long offset; + /** + * Size of the buffer + */ + unsigned long long size; + /** + * Flags reserved for future use. Must be zero. + */ + unsigned int flags; + unsigned int reserved[16]; +} CUDA_EXTERNAL_MEMORY_BUFFER_DESC; + +/** + * External memory mipmap descriptor + */ +typedef struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st { + /** + * Offset into the memory object where the base level of the + * mipmap chain is. + */ + unsigned long long offset; + /** + * Format, dimension and type of base level of the mipmap chain + */ + CUDA_ARRAY3D_DESCRIPTOR arrayDesc; + /** + * Total number of levels in the mipmap chain + */ + unsigned int numLevels; + unsigned int reserved[16]; +} CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC; + +/** + * External semaphore handle types + */ +typedef enum CUexternalSemaphoreHandleType_enum { + /** + * Handle is an opaque file descriptor + */ + CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = 1, + /** + * Handle is an opaque shared NT handle + */ + CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = 2, + /** + * Handle is an opaque, globally shared handle + */ + CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = 3, + /** + * Handle is a shared NT handle referencing a D3D12 fence object + */ + CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = 4 +} CUexternalSemaphoreHandleType; + +/** + * External semaphore handle descriptor + */ +typedef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st { + /** + * Type of the handle + */ + CUexternalSemaphoreHandleType type; + union { + /** + * File descriptor referencing the semaphore object. Valid + * when type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD + */ + int fd; + /** + * Win32 handle referencing the semaphore object. Valid when + * type is one of the following: + * - ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 + * - ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT + * - ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE + * Exactly one of 'handle' and 'name' must be non-NULL. If + * type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT + * then 'name' must be NULL. + */ + struct { + /** + * Valid NT handle. Must be NULL if 'name' is non-NULL + */ + void *handle; + /** + * Name of a valid synchronization primitive. + * Must be NULL if 'handle' is non-NULL. + */ + const void *name; + } win32; + } handle; + /** + * Flags reserved for the future. Must be zero. + */ + unsigned int flags; + unsigned int reserved[16]; +} CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC; + +/** + * External semaphore signal parameters + */ +typedef struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st { + struct { + /** + * Parameters for fence objects + */ + struct { + /** + * Value of fence to be signaled + */ + unsigned long long value; + } fence; + unsigned int reserved[16]; + } params; + /** + * Flags reserved for the future. Must be zero. + */ + unsigned int flags; + unsigned int reserved[16]; +} CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS; + +/** + * External semaphore wait parameters + */ +typedef struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st { + struct { + /** + * Parameters for fence objects + */ + struct { + /** + * Value of fence to be waited on + */ + unsigned long long value; + } fence; + unsigned int reserved[16]; + } params; + /** + * Flags reserved for the future. Must be zero. + */ + unsigned int flags; + unsigned int reserved[16]; +} CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS; + +#endif /* __CUDA_API_VERSION >= 10000 */ + +/** + * If set, each kernel launched as part of + * ::cuLaunchCooperativeKernelMultiDevice only waits for prior work in the + * stream corresponding to that GPU to complete before the kernel begins + * execution. + */ +#define CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC 0x01 + +/** + * If set, any subsequent work pushed in a stream that participated in a call to + * ::cuLaunchCooperativeKernelMultiDevice will only wait for the kernel launched + * on the GPU corresponding to that stream to complete before it begins + * execution. + */ +#define CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC 0x02 + +/** + * If set, the CUDA array is a collection of layers, where each layer is either + * a 1D or a 2D array and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies + * the number of layers, not the depth of a 3D array. + */ +#define CUDA_ARRAY3D_LAYERED 0x01 /** * Deprecated, use CUDA_ARRAY3D_LAYERED */ -#define CUDA_ARRAY3D_2DARRAY 0x01 +#define CUDA_ARRAY3D_2DARRAY 0x01 /** * This flag must be set in order to bind a surface reference * to the CUDA array */ -#define CUDA_ARRAY3D_SURFACE_LDST 0x02 +#define CUDA_ARRAY3D_SURFACE_LDST 0x02 /** - * If set, the CUDA array is a collection of six 2D arrays, representing faces of a cube. The - * width of such a CUDA array must be equal to its height, and Depth must be six. - * If ::CUDA_ARRAY3D_LAYERED flag is also set, then the CUDA array is a collection of cubemaps - * and Depth must be a multiple of six. + * If set, the CUDA array is a collection of six 2D arrays, representing faces + * of a cube. The width of such a CUDA array must be equal to its height, and + * Depth must be six. If ::CUDA_ARRAY3D_LAYERED flag is also set, then the CUDA + * array is a collection of cubemaps and Depth must be a multiple of six. */ -#define CUDA_ARRAY3D_CUBEMAP 0x04 +#define CUDA_ARRAY3D_CUBEMAP 0x04 /** * This flag must be set in order to perform texture gather operations @@ -1742,10 +2537,16 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { /** * This flag if set indicates that the CUDA * array is a DEPTH_TEXTURE. -*/ + */ #define CUDA_ARRAY3D_DEPTH_TEXTURE 0x10 /** + * This flag indicates that the CUDA array may be bound as a color target + * in an external graphics API + */ +#define CUDA_ARRAY3D_COLOR_ATTACHMENT 0x20 + +/** * Override the texref format with a format inferred from the array. * Flag for ::cuTexRefSetArray() */ @@ -1756,25 +2557,25 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { * in the range [0,1]. * Flag for ::cuTexRefSetFlags() */ -#define CU_TRSF_READ_AS_INTEGER 0x01 +#define CU_TRSF_READ_AS_INTEGER 0x01 /** * Use normalized texture coordinates in the range [0,1) instead of [0,dim). * Flag for ::cuTexRefSetFlags() */ -#define CU_TRSF_NORMALIZED_COORDINATES 0x02 +#define CU_TRSF_NORMALIZED_COORDINATES 0x02 /** * Perform sRGB->linear conversion during texture read. * Flag for ::cuTexRefSetFlags() */ -#define CU_TRSF_SRGB 0x10 +#define CU_TRSF_SRGB 0x10 /** * End of array terminator for the \p extra parameter to * ::cuLaunchKernel */ -#define CU_LAUNCH_PARAM_END ((void*)0x00) +#define CU_LAUNCH_PARAM_END ((void *)0x00) /** * Indicator that the next value in the \p extra parameter to @@ -1785,7 +2586,7 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { * \p extra array, then ::CU_LAUNCH_PARAM_BUFFER_POINTER will have no * effect. */ -#define CU_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01) +#define CU_LAUNCH_PARAM_BUFFER_POINTER ((void *)0x01) /** * Indicator that the next value in the \p extra parameter to @@ -1795,7 +2596,7 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { * in the \p extra array if the value associated with * ::CU_LAUNCH_PARAM_BUFFER_SIZE is not zero. */ -#define CU_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02) +#define CU_LAUNCH_PARAM_BUFFER_SIZE ((void *)0x02) /** * For texture references loaded into the module, use default texunit from @@ -1806,12 +2607,12 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { /** * Device that represents the CPU */ -#define CU_DEVICE_CPU ((CUdevice)-1) +#define CU_DEVICE_CPU ((CUdevice)-1) /** * Device that represents an invalid device */ -#define CU_DEVICE_INVALID ((CUdevice)-2) +#define CU_DEVICE_INVALID ((CUdevice)-2) /** @} */ /* END CUDA_TYPES */ @@ -1848,7 +2649,9 @@ typedef struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st { * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::CUresult + * \sa + * ::CUresult, + * ::cudaGetErrorString */ CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr); @@ -1867,7 +2670,9 @@ CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr); * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::CUresult + * \sa + * ::CUresult, + * ::cudaGetErrorName */ CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr); @@ -1898,7 +2703,9 @@ CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr); * \return * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_VALUE, - * ::CUDA_ERROR_INVALID_DEVICE + * ::CUDA_ERROR_INVALID_DEVICE, + * ::CUDA_ERROR_SYSTEM_DRIVER_MISMATCH, + * ::CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE * \notefnerr */ CUresult CUDAAPI cuInit(unsigned int Flags); @@ -1918,11 +2725,15 @@ CUresult CUDAAPI cuInit(unsigned int Flags); */ /** - * \brief Returns the CUDA driver version + * \brief Returns the latest CUDA version supported by driver + * + * Returns in \p *driverVersion the version of CUDA supported by + * the driver. The version is returned as + * (1000 × major + 10 × minor). For example, CUDA 9.2 + * would be represented by 9020. * - * Returns in \p *driverVersion the version number of the installed CUDA - * driver. This function automatically returns ::CUDA_ERROR_INVALID_VALUE if - * the \p driverVersion argument is NULL. + * This function automatically returns ::CUDA_ERROR_INVALID_VALUE if + * \p driverVersion is NULL. * * \param driverVersion - Returns the CUDA driver version * @@ -1930,6 +2741,10 @@ CUresult CUDAAPI cuInit(unsigned int Flags); * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_VALUE * \notefnerr + * + * \sa + * ::cudaDriverGetVersion, + * ::cudaRuntimeGetVersion */ CUresult CUDAAPI cuDriverGetVersion(int *driverVersion); @@ -1969,6 +2784,8 @@ CUresult CUDAAPI cuDriverGetVersion(int *driverVersion); * ::cuDeviceGetAttribute, * ::cuDeviceGetCount, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, + * ::cuDeviceGetLuid, * ::cuDeviceTotalMem */ CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal); @@ -1977,7 +2794,7 @@ CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal); * \brief Returns the number of compute-capable devices * * Returns in \p *count the number of devices with compute capability greater - * than or equal to 1.0 that are available for execution. If there is no such + * than or equal to 2.0 that are available for execution. If there is no such * device, ::cuDeviceGetCount() returns 0. * * \param count - Returned number of compute-capable devices @@ -1993,8 +2810,11 @@ CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal); * \sa * ::cuDeviceGetAttribute, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, + * ::cuDeviceGetLuid, * ::cuDeviceGet, - * ::cuDeviceTotalMem + * ::cuDeviceTotalMem, + * ::cudaGetDeviceCount */ CUresult CUDAAPI cuDeviceGetCount(int *count); @@ -2020,12 +2840,76 @@ CUresult CUDAAPI cuDeviceGetCount(int *count); * * \sa * ::cuDeviceGetAttribute, + * ::cuDeviceGetUuid, + * ::cuDeviceGetLuid, * ::cuDeviceGetCount, * ::cuDeviceGet, - * ::cuDeviceTotalMem + * ::cuDeviceTotalMem, + * ::cudaGetDeviceProperties */ CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev); +#if __CUDA_API_VERSION >= 9020 +/** + * \brief Return an UUID for the device + * + * Returns 16-octets identifing the device \p dev in the structure + * pointed by the \p uuid. + * + * \param uuid - Returned UUID + * \param dev - Device to get identifier string for + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_DEVICE + * \notefnerr + * + * \sa + * ::cuDeviceGetAttribute, + * ::cuDeviceGetCount, + * ::cuDeviceGetName, + * ::cuDeviceGetLuid, + * ::cuDeviceGet, + * ::cuDeviceTotalMem, + * ::cudaGetDeviceProperties + */ +CUresult CUDAAPI cuDeviceGetUuid(CUuuid *uuid, CUdevice dev); +#endif + +#if defined(_WIN32) && __CUDA_API_VERSION >= 10000 +/** + * \brief Return an LUID and device node mask for the device + * + * Return identifying information (\p luid and \p deviceNodeMask) to allow + * matching device with graphics APIs. + * + * \param luid - Returned LUID + * \param deviceNodeMask - Returned device node mask + * \param dev - Device to get identifier string for + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_DEVICE + * \notefnerr + * + * \sa + * ::cuDeviceGetAttribute, + * ::cuDeviceGetCount, + * ::cuDeviceGetName, + * ::cuDeviceGet, + * ::cuDeviceTotalMem, + * ::cudaGetDeviceProperties + */ +CUresult CUDAAPI cuDeviceGetLuid(char *luid, unsigned int *deviceNodeMask, + CUdevice dev); +#endif + #if __CUDA_API_VERSION >= 3020 /** * \brief Returns the total amount of memory on the device @@ -2049,7 +2933,9 @@ CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev); * ::cuDeviceGetAttribute, * ::cuDeviceGetCount, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, * ::cuDeviceGet, + * ::cudaMemGetInfo */ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); #endif /* __CUDA_API_VERSION >= 3020 */ @@ -2075,15 +2961,15 @@ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); * - ::CU_DEVICE_ATTRIBUTE_MAX_PITCH: Maximum pitch in bytes allowed by the * memory copy functions that involve memory regions allocated through * ::cuMemAllocPitch(); - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: Maximum 1D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: Maximum 1D * texture width; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH: Maximum width * for a 1D texture bound to linear memory; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: Maximum + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: Maximum * mipmapped 1D texture width; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: Maximum 2D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: Maximum 2D * texture width; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: Maximum 2D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: Maximum 2D * texture height; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH: Maximum width * for a 2D texture bound to linear memory; @@ -2091,40 +2977,40 @@ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); * for a 2D texture bound to linear memory; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH: Maximum pitch * in bytes for a 2D texture bound to linear memory; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: Maximum + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: Maximum * mipmapped 2D texture width; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT: Maximum * mipmapped 2D texture height; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: Maximum 3D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: Maximum 3D * texture width; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: Maximum 3D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: Maximum 3D * texture height; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: Maximum 3D + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: Maximum 3D * texture depth; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: * Alternate maximum 3D texture width, 0 if no alternate * maximum 3D texture size is supported; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: * Alternate maximum 3D texture height, 0 if no alternate * maximum 3D texture size is supported; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: * Alternate maximum 3D texture depth, 0 if no alternate * maximum 3D texture size is supported; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH: * Maximum cubemap texture width or height; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: * Maximum 1D layered texture width; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: * Maximum layers in a 1D layered texture; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: * Maximum 2D layered texture width; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: * Maximum 2D layered texture height; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: * Maximum layers in a 2D layered texture; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: * Maximum cubemap layered texture width or height; - * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: + * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: * Maximum layers in a cubemap layered texture; * - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH: * Maximum 1D surface width; @@ -2178,8 +3064,8 @@ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); * can have multiple CUDA contexts present at a single time. * - ::CU_COMPUTEMODE_PROHIBITED: Compute-prohibited mode - Device is * prohibited from creating new CUDA contexts. - * - ::CU_COMPUTEMODE_EXCLUSIVE_PROCESS: Compute-exclusive-process mode - Device - * can have only one context used by a single process at a time. + * - ::CU_COMPUTEMODE_EXCLUSIVE_PROCESS: Compute-exclusive-process mode - + * Device can have only one context used by a single process at a time. * - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS: 1 if the device supports * executing multiple kernels within the same context simultaneously, or 0 if * not. It is not guaranteed that multiple kernels will be resident @@ -2188,44 +3074,66 @@ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); * - ::CU_DEVICE_ATTRIBUTE_ECC_ENABLED: 1 if error correction is enabled on the * device, 0 if error correction is disabled or not supported by the device; * - ::CU_DEVICE_ATTRIBUTE_PCI_BUS_ID: PCI bus identifier of the device; - * - ::CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: PCI device (also known as slot) identifier - * of the device; - * - ::CU_DEVICE_ATTRIBUTE_TCC_DRIVER: 1 if the device is using a TCC driver. TCC - * is only available on Tesla hardware running Windows Vista or later; - * - ::CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: Peak memory clock frequency in kilohertz; - * - ::CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: Global memory bus width in bits; - * - ::CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: Size of L2 cache in bytes. 0 if the device doesn't have L2 cache; - * - ::CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: Maximum resident threads per multiprocessor; - * - ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: 1 if the device shares a unified address space with - * the host, or 0 if not; - * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: Major compute capability version number; - * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: Minor compute capability version number; - * - ::CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: 1 if device supports caching globals - * in L1 cache, 0 if caching globals in L1 cache is not supported by the device; - * - ::CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: 1 if device supports caching locals - * in L1 cache, 0 if caching locals in L1 cache is not supported by the device; - * - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: Maximum amount of - * shared memory available to a multiprocessor in bytes; this amount is shared - * by all thread blocks simultaneously resident on a multiprocessor; - * - ::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: Maximum number of 32-bit - * registers available to a multiprocessor; this number is shared by all thread - * blocks simultaneously resident on a multiprocessor; - * - ::CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: 1 if device supports allocating managed memory - * on this system, 0 if allocating managed memory is not supported by the device on this system. - * - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: 1 if device is on a multi-GPU board, 0 if not. - * - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: Unique identifier for a group of devices - * associated with the same board. Devices on the same multi-GPU board will share the same identifier. - * - ::CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: 1 if Link between the device and the host - * supports native atomic operations. - * - ::CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: Ratio of single precision performance - * (in floating-point operations per second) to double precision performance. - * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device suppports coherently accessing - * pageable memory without calling cudaHostRegister on it. - * - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: Device can coherently access managed memory - * concurrently with the CPU. - * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: Device supports Compute Preemption. - * - ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: Device can access host registered - * memory at the same virtual address as the CPU. + * - ::CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: PCI device (also known as slot) + * identifier of the device; + * - ::CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID: PCI domain identifier of the device + * - ::CU_DEVICE_ATTRIBUTE_TCC_DRIVER: 1 if the device is using a TCC driver. + * TCC is only available on Tesla hardware running Windows Vista or later; + * - ::CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: Peak memory clock frequency in + * kilohertz; + * - ::CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: Global memory bus width in + * bits; + * - ::CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: Size of L2 cache in bytes. 0 if the + * device doesn't have L2 cache; + * - ::CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: Maximum resident + * threads per multiprocessor; + * - ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: 1 if the device shares a unified + * address space with the host, or 0 if not; + * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: Major compute capability + * version number; + * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: Minor compute capability + * version number; + * - ::CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: 1 if device supports + * caching globals in L1 cache, 0 if caching globals in L1 cache is not + * supported by the device; + * - ::CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: 1 if device supports + * caching locals in L1 cache, 0 if caching locals in L1 cache is not supported + * by the device; + * - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: Maximum amount + * of shared memory available to a multiprocessor in bytes; this amount is + * shared by all thread blocks simultaneously resident on a multiprocessor; + * - ::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: Maximum number of + * 32-bit registers available to a multiprocessor; this number is shared by all + * thread blocks simultaneously resident on a multiprocessor; + * - ::CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: 1 if device supports allocating + * managed memory on this system, 0 if allocating managed memory is not + * supported by the device on this system. + * - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: 1 if device is on a multi-GPU board, + * 0 if not. + * - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: Unique identifier for a + * group of devices associated with the same board. Devices on the same + * multi-GPU board will share the same identifier. + * - ::CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: 1 if Link between the + * device and the host supports native atomic operations. + * - ::CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: Ratio of + * single precision performance (in floating-point operations per second) to + * double precision performance. + * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device suppports coherently + * accessing pageable memory without calling cudaHostRegister on it. + * - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: Device can coherently + * access managed memory concurrently with the CPU. + * - ::CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: Device supports Compute + * Preemption. + * - ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: Device can + * access host registered memory at the same virtual address as the CPU. + * - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: The maximum per + * block shared memory size suported on this device. This is the maximum value + * that can be opted into when using the cuFuncSetAttribute() call. For more + * details see ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES + * - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES: Device + * accesses pageable memory via the host's page tables. + * - ::CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST: The host can + * directly access managed memory on the device without migration. * * \param pi - Returned device attribute value * \param attrib - Device attribute to query @@ -2243,10 +3151,14 @@ CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev); * \sa * ::cuDeviceGetCount, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, * ::cuDeviceGet, - * ::cuDeviceTotalMem + * ::cuDeviceTotalMem, + * ::cudaDeviceGetAttribute, + * ::cudaGetDeviceProperties */ -CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevice dev); +CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, + CUdevice dev); /** @} */ /* END CUDA_DEVICE */ @@ -2267,7 +3179,8 @@ CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevi * * \deprecated * - * This function was deprecated as of CUDA 5.0 and replaced by ::cuDeviceGetAttribute(). + * This function was deprecated as of CUDA 5.0 and replaced by + ::cuDeviceGetAttribute(). * * Returns in \p *prop the properties of device \p dev. The ::CUdevprop * structure is defined as: @@ -2320,10 +3233,12 @@ CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevi * ::cuDeviceGetAttribute, * ::cuDeviceGetCount, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, * ::cuDeviceGet, * ::cuDeviceTotalMem */ -CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev); +__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, + CUdevice dev); /** * \brief Returns the compute capability of the device @@ -2331,7 +3246,7 @@ CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev); * \deprecated * * This function was deprecated as of CUDA 5.0 and its functionality superceded - * by ::cuDeviceGetAttribute(). + * by ::cuDeviceGetAttribute(). * * Returns in \p *major and \p *minor the major and minor revision numbers that * define the compute capability of the device \p dev. @@ -2353,24 +3268,27 @@ CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev); * ::cuDeviceGetAttribute, * ::cuDeviceGetCount, * ::cuDeviceGetName, + * ::cuDeviceGetUuid, * ::cuDeviceGet, * ::cuDeviceTotalMem */ -CUresult CUDAAPI cuDeviceComputeCapability(int *major, int *minor, CUdevice dev); +__CUDA_DEPRECATED CUresult CUDAAPI cuDeviceComputeCapability(int *major, + int *minor, + CUdevice dev); /** @} */ /* END CUDA_DEVICE_DEPRECATED */ /** * \defgroup CUDA_PRIMARY_CTX Primary Context Management * - * ___MANBRIEF___ primary context management functions of the low-level CUDA driver - * API (___CURRENT_FILE___) ___ENDMANBRIEF___ + * ___MANBRIEF___ primary context management functions of the low-level CUDA + * driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the primary context management functions of the low-level - * CUDA driver application programming interface. + * This section describes the primary context management functions of the + * low-level CUDA driver application programming interface. * - * The primary context unique per device and it's shared with CUDA runtime API. - * Those functions allows seemless integration with other libraries using CUDA. + * The primary context is unique per device and shared with the CUDA runtime + * API. These functions allow integration with other libraries using CUDA. * * @{ */ @@ -2383,18 +3301,18 @@ CUresult CUDAAPI cuDeviceComputeCapability(int *major, int *minor, CUdevice dev) * Retains the primary context on the device, creating it if necessary, * increasing its usage count. The caller must call * ::cuDevicePrimaryCtxRelease() when done using the context. - * Unlike ::cuCtxCreate() the newly created context is not pushed onto the stack. + * Unlike ::cuCtxCreate() the newly created context is not pushed onto the + * stack. * * Context creation will fail with ::CUDA_ERROR_UNKNOWN if the compute mode of - * the device is ::CU_COMPUTEMODE_PROHIBITED. The function ::cuDeviceGetAttribute() - * can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE to determine the compute mode - * of the device. - * The <i>nvidia-smi</i> tool can be used to set the compute mode for - * devices. Documentation for <i>nvidia-smi</i> can be obtained by passing a - * -h option to it. + * the device is ::CU_COMPUTEMODE_PROHIBITED. The function + * ::cuDeviceGetAttribute() can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE + * to determine the compute mode of the device. The <i>nvidia-smi</i> tool can + * be used to set the compute mode for devices. Documentation for + * <i>nvidia-smi</i> can be obtained by passing a -h option to it. * - * Please note that the primary context always supports pinned allocations. Other - * flags can be specified by ::cuDevicePrimaryCtxSetFlags(). + * Please note that the primary context always supports pinned allocations. + * Other flags can be specified by ::cuDevicePrimaryCtxSetFlags(). * * \param pctx - Returned context handle of the new context * \param dev - Device for which primary context is requested @@ -2496,8 +3414,9 @@ CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev); * \e C > \e P, then CUDA will yield to other OS threads when waiting for * the GPU (::CU_CTX_SCHED_YIELD), otherwise CUDA will not yield while * waiting for results and actively spin on the processor (::CU_CTX_SCHED_SPIN). - * However, on low power devices like Tegra, it always defaults to - * ::CU_CTX_SCHED_BLOCKING_SYNC. + * Additionally, on Tegra devices, ::CU_CTX_SCHED_AUTO uses a heuristic based on + * the power profile of the platform and may choose ::CU_CTX_SCHED_BLOCKING_SYNC + * for low-powered devices. * * - ::CU_CTX_LMEM_RESIZE_TO_MAX: Instruct CUDA to not reduce local memory * after resizing local memory for a kernel. This can prevent thrashing by @@ -2519,7 +3438,8 @@ CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev); * \sa ::cuDevicePrimaryCtxRetain, * ::cuDevicePrimaryCtxGetState, * ::cuCtxCreate, - * ::cuCtxGetFlags + * ::cuCtxGetFlags, + * ::cudaSetDeviceFlags */ CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags); @@ -2542,10 +3462,13 @@ CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags); * ::CUDA_ERROR_INVALID_VALUE, * \notefnerr * - * \sa ::cuDevicePrimaryCtxSetFlags, - * ::cuCtxGetFlags + * \sa + * ::cuDevicePrimaryCtxSetFlags, + * ::cuCtxGetFlags, + * ::cudaGetDeviceFlags */ -CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, int *active); +CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, + int *active); /** * \brief Destroy all allocations and reset all state on the primary context @@ -2580,8 +3503,8 @@ CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, i * ::cuCtxPushCurrent, * ::cuCtxSetCacheConfig, * ::cuCtxSetLimit, - * ::cuCtxSynchronize - * + * ::cuCtxSynchronize, + * ::cudaDeviceReset */ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); @@ -2589,7 +3512,6 @@ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); /** @} */ /* END CUDA_PRIMARY_CTX */ - /** * \defgroup CUDA_CTX Context Management * @@ -2599,6 +3521,9 @@ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); * This section describes the context management functions of the low-level * CUDA driver application programming interface. * + * Please note that some functions are described in + * \ref CUDA_PRIMARY_CTX "Primary Context Management" section. + * * @{ */ @@ -2606,12 +3531,14 @@ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); /** * \brief Create a CUDA context * + * \note In most cases it is recommended to use ::cuDevicePrimaryCtxRetain. + * * Creates a new CUDA context and associates it with the calling thread. The * \p flags parameter is described below. The context is created with a usage - * count of 1 and the caller of ::cuCtxCreate() must call ::cuCtxDestroy() or - * when done using the context. If a context is already current to the thread, - * it is supplanted by the newly created context and may be restored by a subsequent - * call to ::cuCtxPopCurrent(). + * count of 1 and the caller of ::cuCtxCreate() must call ::cuCtxDestroy() + * when done using the context. If a context is already current to the thread, + * it is supplanted by the newly created context and may be restored by a + * subsequent call to ::cuCtxPopCurrent(). * * The three LSBs of the \p flags parameter can be used to control how the OS * thread, which owns the CUDA context at the time of an API call, interacts @@ -2627,23 +3554,24 @@ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); * results from the GPU. This can increase latency when waiting for the GPU, * but can increase the performance of CPU threads performing work in parallel * with the GPU. - * + * * - ::CU_CTX_SCHED_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a * synchronization primitive when waiting for the GPU to finish work. * * - ::CU_CTX_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a * synchronization primitive when waiting for the GPU to finish work. <br> * <b>Deprecated:</b> This flag was deprecated as of CUDA 4.0 and was - * replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. + * replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. * * - ::CU_CTX_SCHED_AUTO: The default value if the \p flags parameter is zero, * uses a heuristic based on the number of active CUDA contexts in the * process \e C and the number of logical processors in the system \e P. If - * \e C > \e P, then CUDA will yield to other OS threads when waiting for - * the GPU (::CU_CTX_SCHED_YIELD), otherwise CUDA will not yield while - * waiting for results and actively spin on the processor (::CU_CTX_SCHED_SPIN). - * However, on low power devices like Tegra, it always defaults to - * ::CU_CTX_SCHED_BLOCKING_SYNC. + * \e C > \e P, then CUDA will yield to other OS threads when waiting for + * the GPU (::CU_CTX_SCHED_YIELD), otherwise CUDA will not yield while + * waiting for results and actively spin on the processor (::CU_CTX_SCHED_SPIN). + * Additionally, on Tegra devices, ::CU_CTX_SCHED_AUTO uses a heuristic based on + * the power profile of the platform and may choose ::CU_CTX_SCHED_BLOCKING_SYNC + * for low-powered devices. * * - ::CU_CTX_MAP_HOST: Instruct CUDA to support mapped pinned allocations. * This flag must be set in order to allocate pinned host memory that is @@ -2655,12 +3583,11 @@ CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev); * memory usage at the cost of potentially increased memory usage. * * Context creation will fail with ::CUDA_ERROR_UNKNOWN if the compute mode of - * the device is ::CU_COMPUTEMODE_PROHIBITED. The function ::cuDeviceGetAttribute() - * can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE to determine the - * compute mode of the device. The <i>nvidia-smi</i> tool can be used to set - * the compute mode for * devices. - * Documentation for <i>nvidia-smi</i> can be obtained by passing a - * -h option to it. + * the device is ::CU_COMPUTEMODE_PROHIBITED. The function + * ::cuDeviceGetAttribute() can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE + * to determine the compute mode of the device. The <i>nvidia-smi</i> tool can + * be used to set the compute mode for * devices. Documentation for + * <i>nvidia-smi</i> can be obtained by passing a -h option to it. * * \param pctx - Returned context handle of the new context * \param flags - Context creation flags @@ -2701,7 +3628,7 @@ CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags, CUdevice dev); * It is the responsibility of the calling function to ensure that no API * call issues using \p ctx while ::cuCtxDestroy() is executing. * - * If \p ctx is current to the calling thread then \p ctx will also be + * If \p ctx is current to the calling thread then \p ctx will also be * popped from the current thread's context stack (as though ::cuCtxPopCurrent() * were called). If \p ctx is current to other threads, then \p ctx will * remain current to those threads, and attempting to access \p ctx from @@ -2770,8 +3697,8 @@ CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx); /** * \brief Pops the current CUDA context from the current CPU thread. * - * Pops the current CUDA context from the CPU thread and passes back the - * old context handle in \p *pctx. That context may then be made current + * Pops the current CUDA context from the CPU thread and passes back the + * old context handle in \p *pctx. That context may then be made current * to a different CPU thread by calling ::cuCtxPushCurrent(). * * If a context was current to the CPU thread before ::cuCtxCreate() or @@ -2809,7 +3736,7 @@ CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx); * calling CPU thread is unbound and ::CUDA_SUCCESS is returned. * * If there exists a CUDA context stack on the calling CPU thread, this - * will replace the top of that stack with \p ctx. + * will replace the top of that stack with \p ctx. * If \p ctx is NULL then this will be equivalent to popping the top * of the calling CPU thread's CUDA context stack (or a no-op if the * calling CPU thread's CUDA context stack is empty). @@ -2823,7 +3750,11 @@ CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx); * ::CUDA_ERROR_INVALID_CONTEXT * \notefnerr * - * \sa ::cuCtxGetCurrent, ::cuCtxCreate, ::cuCtxDestroy + * \sa + * ::cuCtxGetCurrent, + * ::cuCtxCreate, + * ::cuCtxDestroy, + * ::cudaSetDevice */ CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx); @@ -2842,7 +3773,11 @@ CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx); * ::CUDA_ERROR_NOT_INITIALIZED, * \notefnerr * - * \sa ::cuCtxSetCurrent, ::cuCtxCreate, ::cuCtxDestroy + * \sa + * ::cuCtxSetCurrent, + * ::cuCtxCreate, + * ::cuCtxDestroy, + * ::cudaGetDevice */ CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx); #endif /* __CUDA_API_VERSION >= 4000 */ @@ -2872,7 +3807,8 @@ CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx); * ::cuCtxPushCurrent, * ::cuCtxSetCacheConfig, * ::cuCtxSetLimit, - * ::cuCtxSynchronize + * ::cuCtxSynchronize, + * ::cudaGetDevice */ CUresult CUDAAPI cuCtxGetDevice(CUdevice *device); @@ -2900,7 +3836,8 @@ CUresult CUDAAPI cuCtxGetDevice(CUdevice *device); * ::cuCtxGetDevice * ::cuCtxGetLimit, * ::cuCtxGetSharedMemConfig, - * ::cuCtxGetStreamPriorityRange + * ::cuCtxGetStreamPriorityRange, + * ::cudaGetDeviceFlags */ CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags); #endif /* __CUDA_API_VERSION >= 7000 */ @@ -2910,7 +3847,7 @@ CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags); * * Blocks until the device has completed all preceding requested tasks. * ::cuCtxSynchronize() returns an error if one of the preceding tasks failed. - * If the context was created with the ::CU_CTX_SCHED_BLOCKING_SYNC flag, the + * If the context was created with the ::CU_CTX_SCHED_BLOCKING_SYNC flag, the * CPU thread will block until the GPU context has finished its work. * * \return @@ -2930,7 +3867,8 @@ CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags); * ::cuCtxPopCurrent, * ::cuCtxPushCurrent, * ::cuCtxSetCacheConfig, - * ::cuCtxSetLimit + * ::cuCtxSetLimit, + * ::cudaDeviceSynchronize */ CUresult CUDAAPI cuCtxSynchronize(void); @@ -2948,50 +3886,41 @@ CUresult CUDAAPI cuCtxSynchronize(void); * discussed here. * * - ::CU_LIMIT_STACK_SIZE controls the stack size in bytes of each GPU thread. - * This limit is only applicable to devices of compute capability 2.0 and - * higher. Attempting to set this limit on devices of compute capability - * less than 2.0 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT - * being returned. + * Note that the CUDA driver will set the \p limit to the maximum of \p value + * and what the kernel function requires. * * - ::CU_LIMIT_PRINTF_FIFO_SIZE controls the size in bytes of the FIFO used * by the ::printf() device system call. Setting ::CU_LIMIT_PRINTF_FIFO_SIZE * must be performed before launching any kernel that uses the ::printf() * device system call, otherwise ::CUDA_ERROR_INVALID_VALUE will be returned. - * This limit is only applicable to devices of compute capability 2.0 and - * higher. Attempting to set this limit on devices of compute capability - * less than 2.0 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT - * being returned. * * - ::CU_LIMIT_MALLOC_HEAP_SIZE controls the size in bytes of the heap used * by the ::malloc() and ::free() device system calls. Setting * ::CU_LIMIT_MALLOC_HEAP_SIZE must be performed before launching any kernel * that uses the ::malloc() or ::free() device system calls, otherwise - * ::CUDA_ERROR_INVALID_VALUE will be returned. This limit is only applicable - * to devices of compute capability 2.0 and higher. Attempting to set this - * limit on devices of compute capability less than 2.0 will result in the - * error ::CUDA_ERROR_UNSUPPORTED_LIMIT being returned. + * ::CUDA_ERROR_INVALID_VALUE will be returned. * * - ::CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH controls the maximum nesting depth of * a grid at which a thread can safely call ::cudaDeviceSynchronize(). Setting - * this limit must be performed before any launch of a kernel that uses the + * this limit must be performed before any launch of a kernel that uses the * device runtime and calls ::cudaDeviceSynchronize() above the default sync - * depth, two levels of grids. Calls to ::cudaDeviceSynchronize() will fail - * with error code ::cudaErrorSyncDepthExceeded if the limitation is + * depth, two levels of grids. Calls to ::cudaDeviceSynchronize() will fail + * with error code ::cudaErrorSyncDepthExceeded if the limitation is * violated. This limit can be set smaller than the default or up the maximum * launch depth of 24. When setting this limit, keep in mind that additional * levels of sync depth require the driver to reserve large amounts of device - * memory which can no longer be used for user allocations. If these - * reservations of device memory fail, ::cuCtxSetLimit will return + * memory which can no longer be used for user allocations. If these + * reservations of device memory fail, ::cuCtxSetLimit will return * ::CUDA_ERROR_OUT_OF_MEMORY, and the limit can be reset to a lower value. * This limit is only applicable to devices of compute capability 3.5 and * higher. Attempting to set this limit on devices of compute capability less - * than 3.5 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT being + * than 3.5 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT being * returned. * * - ::CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT controls the maximum number of * outstanding device runtime launches that can be made from the current * context. A grid is outstanding from the point of launch up until the grid - * is known to have been completed. Device runtime launches which violate + * is known to have been completed. Device runtime launches which violate * this limitation fail and return ::cudaErrorLaunchPendingCountExceeded when * ::cudaGetLastError() is called after launch. If more pending launches than * the default (2048 launches) are needed for a module using the device @@ -3005,6 +3934,10 @@ CUresult CUDAAPI cuCtxSynchronize(void); * than 3.5 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT being * returned. * + * - ::CU_LIMIT_MAX_L2_FETCH_GRANULARITY controls the L2 cache fetch + * granularity. Values can range from 0B to 128B. This is purely a performance + * hint and it can be ignored or clamped depending on the platform. + * * \param limit - Limit to set * \param value - Size of limit * @@ -3012,7 +3945,8 @@ CUresult CUDAAPI cuCtxSynchronize(void); * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_VALUE, * ::CUDA_ERROR_UNSUPPORTED_LIMIT, - * ::CUDA_ERROR_OUT_OF_MEMORY + * ::CUDA_ERROR_OUT_OF_MEMORY, + * ::CUDA_ERROR_INVALID_CONTEXT * \notefnerr * * \sa ::cuCtxCreate, @@ -3025,7 +3959,8 @@ CUresult CUDAAPI cuCtxSynchronize(void); * ::cuCtxPopCurrent, * ::cuCtxPushCurrent, * ::cuCtxSetCacheConfig, - * ::cuCtxSynchronize + * ::cuCtxSynchronize, + * ::cudaDeviceSetLimit */ CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value); @@ -3044,6 +3979,7 @@ CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value); * child grid launches to complete. * - ::CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT: maximum number of outstanding * device runtime launches that can be made from this context. + * - ::CU_LIMIT_MAX_L2_FETCH_GRANULARITY: L2 cache fetch granularity. * * \param limit - Limit to query * \param pvalue - Returned size of limit @@ -3064,7 +4000,8 @@ CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value); * ::cuCtxPushCurrent, * ::cuCtxSetCacheConfig, * ::cuCtxSetLimit, - * ::cuCtxSynchronize + * ::cuCtxSynchronize, + * ::cudaDeviceGetLimit */ CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit); @@ -3072,17 +4009,19 @@ CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit); * \brief Returns the preferred cache configuration for the current context. * * On devices where the L1 cache and shared memory use the same hardware - * resources, this function returns through \p pconfig the preferred cache configuration - * for the current context. This is only a preference. The driver will use - * the requested configuration if possible, but it is free to choose a different - * configuration if required to execute functions. + * resources, this function returns through \p pconfig the preferred cache + * configuration for the current context. This is only a preference. The driver + * will use the requested configuration if possible, but it is free to choose a + * different configuration if required to execute functions. * * This will return a \p pconfig of ::CU_FUNC_CACHE_PREFER_NONE on devices * where the size of the L1 cache and shared memory are fixed. * * The supported cache configurations are: - * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache + * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 + * (default) + * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 + * cache * - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory * - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory * @@ -3107,7 +4046,8 @@ CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit); * ::cuCtxSetCacheConfig, * ::cuCtxSetLimit, * ::cuCtxSynchronize, - * ::cuFuncSetCacheConfig + * ::cuFuncSetCacheConfig, + * ::cudaDeviceGetCacheConfig */ CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig); @@ -3131,8 +4071,10 @@ CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig); * preference setting may insert a device-side synchronization point. * * The supported cache configurations are: - * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache + * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 + * (default) + * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 + * cache * - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory * - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory * @@ -3157,29 +4099,32 @@ CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig); * ::cuCtxPushCurrent, * ::cuCtxSetLimit, * ::cuCtxSynchronize, - * ::cuFuncSetCacheConfig + * ::cuFuncSetCacheConfig, + * ::cudaDeviceSetCacheConfig */ CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config); #if __CUDA_API_VERSION >= 4020 /** - * \brief Returns the current shared memory configuration for the current context. + * \brief Returns the current shared memory configuration for the current + * context. * - * This function will return in \p pConfig the current size of shared memory banks - * in the current context. On devices with configurable shared memory banks, - * ::cuCtxSetSharedMemConfig can be used to change this setting, so that all - * subsequent kernel launches will by default use the new bank size. When - * ::cuCtxGetSharedMemConfig is called on devices without configurable shared + * This function will return in \p pConfig the current size of shared memory + * banks in the current context. On devices with configurable shared memory + * banks, + * ::cuCtxSetSharedMemConfig can be used to change this setting, so that all + * subsequent kernel launches will by default use the new bank size. When + * ::cuCtxGetSharedMemConfig is called on devices without configurable shared * memory, it will return the fixed bank size of the hardware. * * The returned bank configurations can be either: - * - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: shared memory bank width is + * - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: shared memory bank width is * four bytes. * - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: shared memory bank width will * eight bytes. * * \param pConfig - returned shared memory configuration - * \return + * \return * ::CUDA_SUCCESS, * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, @@ -3200,6 +4145,7 @@ CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config); * ::cuCtxSynchronize, * ::cuCtxGetSharedMemConfig, * ::cuFuncSetCacheConfig, + * ::cudaDeviceGetSharedMemConfig */ CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig); @@ -3207,27 +4153,27 @@ CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig); * \brief Sets the shared memory configuration for the current context. * * On devices with configurable shared memory banks, this function will set - * the context's shared memory bank size which is used for subsequent kernel - * launches. + * the context's shared memory bank size which is used for subsequent kernel + * launches. * * Changed the shared memory configuration between launches may insert a device * side synchronization point between those launches. * * Changing the shared memory bank size will not increase shared memory usage - * or affect occupancy of kernels, but may have major effects on performance. - * Larger bank sizes will allow for greater potential bandwidth to shared memory, - * but will change what kinds of accesses to shared memory will result in bank - * conflicts. + * or affect occupancy of kernels, but may have major effects on performance. + * Larger bank sizes will allow for greater potential bandwidth to shared + * memory, but will change what kinds of accesses to shared memory will result + * in bank conflicts. * * This function will do nothing on devices with fixed shared memory bank size. * * The supported bank configurations are: - * - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: set bank width to the default initial - * setting (currently, four bytes). + * - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: set bank width to the default + * initial setting (currently, four bytes). * - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: set shared memory bank width to * be natively four bytes. - * - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width to - * be natively eight bytes. + * - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width + * to be natively eight bytes. * * \param config - requested shared memory configuration * @@ -3252,6 +4198,7 @@ CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig); * ::cuCtxSynchronize, * ::cuCtxGetSharedMemConfig, * ::cuFuncSetCacheConfig, + * ::cudaDeviceSetSharedMemConfig */ CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config); #endif @@ -3265,9 +4212,9 @@ CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config); * used to create the currently bound context. * * Note that new API versions are only introduced when context capabilities are - * changed that break binary compatibility, so the API version and driver version - * may be different. For example, it is valid for the API version to be 3020 while - * the driver version is 4020. + * changed that break binary compatibility, so the API version and driver + * version may be different. For example, it is valid for the API version to be + * 3020 while the driver version is 4020. * * \param ctx - Context to check * \param version - Pointer to version @@ -3277,6 +4224,7 @@ CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config); * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_VALUE, * ::CUDA_ERROR_UNKNOWN * \notefnerr * @@ -3297,26 +4245,25 @@ CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version); * \brief Returns numerical values that correspond to the least and * greatest stream priorities. * - * Returns in \p *leastPriority and \p *greatestPriority the numerical values that correspond - * to the least and greatest stream priorities respectively. Stream priorities - * follow a convention where lower numbers imply greater priorities. The range of - * meaningful stream priorities is given by [\p *greatestPriority, \p *leastPriority]. - * If the user attempts to create a stream with a priority value that is - * outside the meaningful range as specified by this API, the priority is - * automatically clamped down or up to either \p *leastPriority or \p *greatestPriority - * respectively. See ::cuStreamCreateWithPriority for details on creating a - * priority stream. - * A NULL may be passed in for \p *leastPriority or \p *greatestPriority if the value - * is not desired. + * Returns in \p *leastPriority and \p *greatestPriority the numerical values + * that correspond to the least and greatest stream priorities respectively. + * Stream priorities follow a convention where lower numbers imply greater + * priorities. The range of meaningful stream priorities is given by [\p + * *greatestPriority, \p *leastPriority]. If the user attempts to create a + * stream with a priority value that is outside the meaningful range as + * specified by this API, the priority is automatically clamped down or up to + * either \p *leastPriority or \p *greatestPriority respectively. See + * ::cuStreamCreateWithPriority for details on creating a priority stream. A + * NULL may be passed in for \p *leastPriority or \p *greatestPriority if the + * value is not desired. * - * This function will return '0' in both \p *leastPriority and \p *greatestPriority if - * the current context's device does not support stream priorities - * (see ::cuDeviceGetAttribute). + * This function will return '0' in both \p *leastPriority and \p + * *greatestPriority if the current context's device does not support stream + * priorities (see ::cuDeviceGetAttribute). * - * \param leastPriority - Pointer to an int in which the numerical value for least - * stream priority is returned - * \param greatestPriority - Pointer to an int in which the numerical value for greatest - * stream priority is returned + * \param leastPriority - Pointer to an int in which the numerical value for + * least stream priority is returned \param greatestPriority - Pointer to an int + * in which the numerical value for greatest stream priority is returned * * \return * ::CUDA_SUCCESS, @@ -3328,9 +4275,11 @@ CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version); * ::cuCtxGetDevice, * ::cuCtxGetFlags, * ::cuCtxSetLimit, - * ::cuCtxSynchronize + * ::cuCtxSynchronize, + * ::cudaDeviceGetStreamPriorityRange */ -CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPriority); +CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, + int *greatestPriority); /** @} */ /* END CUDA_CTX */ @@ -3340,8 +4289,8 @@ CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPr * ___MANBRIEF___ deprecated context management functions of the low-level CUDA * driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the deprecated context management functions of the low-level - * CUDA driver application programming interface. + * This section describes the deprecated context management functions of the + * low-level CUDA driver application programming interface. * * @{ */ @@ -3385,7 +4334,8 @@ CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPr * ::cuCtxSetLimit, * ::cuCtxSynchronize */ -CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, unsigned int flags); +__CUDA_DEPRECATED CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, + unsigned int flags); /** * \brief Decrement a context's usage-count @@ -3421,11 +4371,10 @@ CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, unsigned int flags); * ::cuCtxSetLimit, * ::cuCtxSynchronize */ -CUresult CUDAAPI cuCtxDetach(CUcontext ctx); +__CUDA_DEPRECATED CUresult CUDAAPI cuCtxDetach(CUcontext ctx); /** @} */ /* END CUDA_CTX_DEPRECATED */ - /** * \defgroup CUDA_MODULE Module Management * @@ -3464,7 +4413,8 @@ CUresult CUDAAPI cuCtxDetach(CUcontext ctx); * ::CUDA_ERROR_FILE_NOT_FOUND, * ::CUDA_ERROR_NO_BINARY_FOR_GPU, * ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, - * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, + * ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND * \notefnerr * * \sa ::cuModuleGetFunction, @@ -3500,7 +4450,8 @@ CUresult CUDAAPI cuModuleLoad(CUmodule *module, const char *fname); * ::CUDA_ERROR_OUT_OF_MEMORY, * ::CUDA_ERROR_NO_BINARY_FOR_GPU, * ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, - * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, + * ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND * \notefnerr * * \sa ::cuModuleGetFunction, @@ -3524,7 +4475,7 @@ CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image); * as Windows \c FindResource() to obtain the pointer. Options are passed as * an array via \p options and any corresponding parameters are passed in * \p optionValues. The number of total options is supplied via \p numOptions. - * Any outputs will be returned via \p optionValues. + * Any outputs will be returned via \p optionValues. * * \param module - Returned module * \param image - Module data to load @@ -3542,7 +4493,8 @@ CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image); * ::CUDA_ERROR_OUT_OF_MEMORY, * ::CUDA_ERROR_NO_BINARY_FOR_GPU, * ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, - * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, + * ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND * \notefnerr * * \sa ::cuModuleGetFunction, @@ -3553,7 +4505,9 @@ CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image); * ::cuModuleLoadFatBinary, * ::cuModuleUnload */ -CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, unsigned int numOptions, CUjit_option *options, void **optionValues); +CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, + unsigned int numOptions, + CUjit_option *options, void **optionValues); /** * \brief Load a module's data @@ -3583,7 +4537,8 @@ CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, unsigne * ::CUDA_ERROR_OUT_OF_MEMORY, * ::CUDA_ERROR_NO_BINARY_FOR_GPU, * ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, - * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, + * ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND * \notefnerr * * \sa ::cuModuleGetFunction, @@ -3649,7 +4604,8 @@ CUresult CUDAAPI cuModuleUnload(CUmodule hmod); * ::cuModuleLoadFatBinary, * ::cuModuleUnload */ -CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, const char *name); +CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, + const char *name); #if __CUDA_API_VERSION >= 3020 /** @@ -3681,9 +4637,12 @@ CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, const cha * ::cuModuleLoadData, * ::cuModuleLoadDataEx, * ::cuModuleLoadFatBinary, - * ::cuModuleUnload + * ::cuModuleUnload, + * ::cudaGetSymbolAddress, + * ::cudaGetSymbolSize */ -CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char *name); +CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, + CUmodule hmod, const char *name); #endif /* __CUDA_API_VERSION >= 3020 */ /** @@ -3715,9 +4674,11 @@ CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hm * ::cuModuleLoadData, * ::cuModuleLoadDataEx, * ::cuModuleLoadFatBinary, - * ::cuModuleUnload + * ::cuModuleUnload, + * ::cudaGetTextureReference */ -CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, const char *name); +CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, + const char *name); /** * \brief Returns a handle to a surface reference @@ -3746,9 +4707,11 @@ CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, const char * ::cuModuleLoadData, * ::cuModuleLoadDataEx, * ::cuModuleLoadFatBinary, - * ::cuModuleUnload + * ::cuModuleUnload, + * ::cudaGetSurfaceReference */ -CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const char *name); +CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, + const char *name); #if __CUDA_API_VERSION >= 5050 @@ -3781,7 +4744,8 @@ CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const ch * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE, - * ::CUDA_ERROR_OUT_OF_MEMORY + * ::CUDA_ERROR_OUT_OF_MEMORY, + * ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND * \notefnerr * * \sa ::cuLinkAddData, @@ -3789,14 +4753,14 @@ CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const ch * ::cuLinkComplete, * ::cuLinkDestroy */ -CUresult CUDAAPI -cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues, CUlinkState *stateOut); +CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options, + void **optionValues, CUlinkState *stateOut); /** * \brief Add an input to a pending linker invocation * - * Ownership of \p data is retained by the caller. No reference is retained to any - * inputs after this call returns. + * Ownership of \p data is retained by the caller. No reference is retained to + * any inputs after this call returns. * * This method accepts only compiler options, which are used if the data must * be compiled from PTX, and does not accept any of @@ -3809,8 +4773,9 @@ cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues * \param size The length of the input data. * \param name An optional name for this input in log messages. * \param numOptions Size of options. - * \param options Options to be applied only for this input (overrides options from ::cuLinkCreate). - * \param optionValues Array of option values, each cast to void *. + * \param options Options to be applied only for this input (overrides + * options from ::cuLinkCreate). \param optionValues Array of option values, + * each cast to void *. * * \return * ::CUDA_SUCCESS, @@ -3826,9 +4791,10 @@ cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues * ::cuLinkComplete, * ::cuLinkDestroy */ -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 cuLinkAddData(CUlinkState state, CUjitInputType type, + void *data, size_t size, const char *name, + unsigned int numOptions, CUjit_option *options, + void **optionValues); /** * \brief Add a file input to a pending linker invocation @@ -3847,8 +4813,9 @@ cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, c * \param type The type of the input data * \param path Path to the input file * \param numOptions Size of options - * \param options Options to be applied only for this input (overrides options from ::cuLinkCreate) - * \param optionValues Array of option values, each cast to void * + * \param options Options to be applied only for this input (overrides + * options from ::cuLinkCreate) \param optionValues Array of option values, each + * cast to void * * * \return * ::CUDA_SUCCESS, @@ -3865,17 +4832,17 @@ cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, c * ::cuLinkComplete, * ::cuLinkDestroy */ -CUresult CUDAAPI -cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path, - 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); /** * \brief Complete a pending linker invocation * - * Completes the pending linker action and returns the cubin image for the linked - * device code, which can be used with ::cuModuleLoadData. The cubin is owned by - * \p state, so it should be loaded before \p state is destroyed via ::cuLinkDestroy. - * This call does not destroy \p state. + * Completes the pending linker action and returns the cubin image for the + * linked device code, which can be used with ::cuModuleLoadData. The cubin is + * owned by \p state, so it should be loaded before \p state is destroyed via + * ::cuLinkDestroy. This call does not destroy \p state. * * \param state A pending linker invocation * \param cubinOut On success, this will point to the output image @@ -3892,8 +4859,8 @@ cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path, * ::cuLinkDestroy, * ::cuModuleLoadData */ -CUresult CUDAAPI -cuLinkComplete(CUlinkState state, void **cubinOut, size_t *sizeOut); +CUresult CUDAAPI cuLinkComplete(CUlinkState state, void **cubinOut, + size_t *sizeOut); /** * \brief Destroys state for a JIT linker invocation. @@ -3906,14 +4873,12 @@ cuLinkComplete(CUlinkState state, void **cubinOut, size_t *sizeOut); * * \sa ::cuLinkCreate */ -CUresult CUDAAPI -cuLinkDestroy(CUlinkState state); +CUresult CUDAAPI cuLinkDestroy(CUlinkState state); #endif /* __CUDA_API_VERSION >= 5050 */ /** @} */ /* END CUDA_MODULE */ - /** * \defgroup CUDA_MEM Memory Management * @@ -3948,12 +4913,14 @@ cuLinkDestroy(CUlinkState state); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemGetInfo */ CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total); @@ -3981,12 +4948,14 @@ CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMalloc */ CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize); @@ -4042,14 +5011,18 @@ CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMallocPitch */ -CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes); +CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, + size_t WidthInBytes, size_t Height, + unsigned int ElementSizeBytes); /** * \brief Frees device memory @@ -4071,12 +5044,14 @@ CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, size_t Width * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaFree */ CUresult CUDAAPI cuMemFree(CUdeviceptr dptr); @@ -4097,6 +5072,7 @@ CUresult CUDAAPI cuMemFree(CUdeviceptr dptr); * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_NOT_FOUND, * ::CUDA_ERROR_INVALID_VALUE * \notefnerr * @@ -4104,14 +5080,16 @@ CUresult CUDAAPI cuMemFree(CUdeviceptr dptr); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 */ -CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdeviceptr dptr); +CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, + CUdeviceptr dptr); /** * \brief Allocates page-locked host memory @@ -4128,11 +5106,11 @@ CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdevic * staging areas for data exchange between host and device. * * Note all host memory allocated using ::cuMemHostAlloc() will automatically - * be immediately accessible to all contexts on all devices which support unified - * addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). - * The device pointer that may be used to access this host memory from those - * contexts is always equal to the returned host pointer \p *pp. - * See \ref CUDA_UNIFIED for additional details. + * be immediately accessible to all contexts on all devices which support + * unified addressing (as may be queried using + * ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). The device pointer that may be + * used to access this host memory from those contexts is always equal to the + * returned host pointer \p *pp. See \ref CUDA_UNIFIED for additional details. * * \param pp - Returned host pointer to page-locked memory * \param bytesize - Requested allocation size in bytes @@ -4150,12 +5128,14 @@ CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdevic * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMallocHost */ CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize); #endif /* __CUDA_API_VERSION >= 3020 */ @@ -4180,12 +5160,14 @@ CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaFreeHost */ CUresult CUDAAPI cuMemFreeHost(void *p); @@ -4212,8 +5194,7 @@ CUresult CUDAAPI cuMemFreeHost(void *p); * * - ::CU_MEMHOSTALLOC_DEVICEMAP: Maps the allocation into the CUDA address * space. The device pointer to the memory may be obtained by calling - * ::cuMemHostGetDevicePointer(). This feature is available only on GPUs - * with compute capability greater than or equal to 1.1. + * ::cuMemHostGetDevicePointer(). * * - ::CU_MEMHOSTALLOC_WRITECOMBINED: Allocates the memory as write-combined * (WC). WC memory can be transferred across the PCI Express bus more @@ -4236,13 +5217,14 @@ CUresult CUDAAPI cuMemFreeHost(void *p); * The memory allocated by this function must be freed with ::cuMemFreeHost(). * * Note all host memory allocated using ::cuMemHostAlloc() will automatically - * be immediately accessible to all contexts on all devices which support unified - * addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). - * Unless the flag ::CU_MEMHOSTALLOC_WRITECOMBINED is specified, the device pointer - * that may be used to access this host memory from those contexts is always equal - * to the returned host pointer \p *pp. If the flag ::CU_MEMHOSTALLOC_WRITECOMBINED - * is specified, then the function ::cuMemHostGetDevicePointer() must be used - * to query the device pointer, even if the context supports unified addressing. + * be immediately accessible to all contexts on all devices which support + * unified addressing (as may be queried using + * ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). Unless the flag + * ::CU_MEMHOSTALLOC_WRITECOMBINED is specified, the device pointer that may be + * used to access this host memory from those contexts is always equal to the + * returned host pointer \p *pp. If the flag ::CU_MEMHOSTALLOC_WRITECOMBINED is + * specified, then the function ::cuMemHostGetDevicePointer() must be used to + * query the device pointer, even if the context supports unified addressing. * See \ref CUDA_UNIFIED for additional details. * * \param pp - Returned host pointer to page-locked memory @@ -4262,12 +5244,14 @@ CUresult CUDAAPI cuMemFreeHost(void *p); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaHostAlloc */ CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags); @@ -4286,16 +5270,18 @@ CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags); * ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, the memory * can also be accessed from the device using the host pointer \p p. * The device pointer returned by ::cuMemHostGetDevicePointer() may or may not - * match the original host pointer \p p and depends on the devices visible to the - * application. If all devices visible to the application have a non-zero value for the - * device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() - * will match the original pointer \p p. If any device visible to the application - * has a zero value for the device attribute, the device pointer returned by + * match the original host pointer \p p and depends on the devices visible to + * the application. If all devices visible to the application have a non-zero + * value for the device attribute, the device pointer returned by + * ::cuMemHostGetDevicePointer() will match the original pointer \p p. If any + * device visible to the application has a zero value for the device attribute, + * the device pointer returned by * ::cuMemHostGetDevicePointer() will not match the original host pointer \p p, - * but it will be suitable for use on all devices provided Unified Virtual Addressing - * is enabled. In such systems, it is valid to access the memory using either pointer - * on devices that have a non-zero value for the device attribute. Note however that - * such devices should access the memory using only of the two pointers and not both. + * but it will be suitable for use on all devices provided Unified Virtual + * Addressing is enabled. In such systems, it is valid to access the memory + * using either pointer on devices that have a non-zero value for the device + * attribute. Note however that such devices should access the memory using only + * of the two pointers and not both. * * \p Flags provides for future releases. For now, it must be set to 0. * @@ -4315,14 +5301,17 @@ CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaHostGetDevicePointer */ -CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags); +CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, + unsigned int Flags); #endif /* __CUDA_API_VERSION >= 3020 */ /** @@ -4345,14 +5334,18 @@ CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned * ::CUDA_ERROR_INVALID_VALUE * \notefnerr * - * \sa ::cuMemAllocHost, ::cuMemHostAlloc + * \sa + * ::cuMemAllocHost, + * ::cuMemHostAlloc, + * ::cudaHostGetFlags */ CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p); #if __CUDA_API_VERSION >= 6000 /** - * \brief Allocates memory that will be automatically managed by the Unified Memory system + * \brief Allocates memory that will be automatically managed by the Unified + * Memory system * * Allocates \p bytesize bytes of managed memory on the device and returns in * \p *dptr a pointer to the allocated memory. If the device doesn't support @@ -4361,79 +5354,97 @@ CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p); * ::CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY. The allocated memory is suitably * aligned for any kind of variable. The memory is not cleared. If \p bytesize * is 0, ::cuMemAllocManaged returns ::CUDA_ERROR_INVALID_VALUE. The pointer - * is valid on the CPU and on all GPUs in the system that support managed memory. - * All accesses to this pointer must obey the Unified Memory programming model. + * is valid on the CPU and on all GPUs in the system that support managed + * memory. All accesses to this pointer must obey the Unified Memory programming + * model. * * \p flags specifies the default stream association for this allocation. * \p flags must be one of ::CU_MEM_ATTACH_GLOBAL or ::CU_MEM_ATTACH_HOST. If * ::CU_MEM_ATTACH_GLOBAL is specified, then this memory is accessible from * any stream on any device. If ::CU_MEM_ATTACH_HOST is specified, then the * allocation should not be accessed from devices that have a zero value for the - * device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS; an explicit call to + * device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS; an explicit + * call to * ::cuStreamAttachMemAsync will be required to enable access on such devices. * * If the association is later changed via ::cuStreamAttachMemAsync to - * a single stream, the default association as specifed during ::cuMemAllocManaged - * is restored when that stream is destroyed. For __managed__ variables, the - * default association is always ::CU_MEM_ATTACH_GLOBAL. Note that destroying a - * stream is an asynchronous operation, and as a result, the change to default - * association won't happen until all work in the stream has completed. + * a single stream, the default association as specifed during + * ::cuMemAllocManaged is restored when that stream is destroyed. For + * __managed__ variables, the default association is always + * ::CU_MEM_ATTACH_GLOBAL. Note that destroying a stream is an asynchronous + * operation, and as a result, the change to default association won't happen + * until all work in the stream has completed. * - * Memory allocated with ::cuMemAllocManaged should be released with ::cuMemFree. + * Memory allocated with ::cuMemAllocManaged should be released with + * ::cuMemFree. * - * Device memory oversubscription is possible for GPUs that have a non-zero value for the - * device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Managed memory on - * such GPUs may be evicted from device memory to host memory at any time by the Unified + * Device memory oversubscription is possible for GPUs that have a non-zero + * value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Managed memory on such GPUs + * may be evicted from device memory to host memory at any time by the Unified * Memory driver in order to make room for other allocations. * - * In a multi-GPU system where all GPUs have a non-zero value for the device attribute - * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, managed memory may not be populated when this - * API returns and instead may be populated on access. In such systems, managed memory can - * migrate to any processor's memory at any time. The Unified Memory driver will employ heuristics to - * maintain data locality and prevent excessive page faults to the extent possible. The application - * can also guide the driver about memory usage patterns via ::cuMemAdvise. The application - * can also explicitly migrate memory to a desired processor's memory via + * In a multi-GPU system where all GPUs have a non-zero value for the device + * attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, managed memory may not be + * populated when this API returns and instead may be populated on access. In + * such systems, managed memory can migrate to any processor's memory at any + * time. The Unified Memory driver will employ heuristics to maintain data + * locality and prevent excessive page faults to the extent possible. The + * application can also guide the driver about memory usage patterns via + * ::cuMemAdvise. The application can also explicitly migrate memory to a + * desired processor's memory via * ::cuMemPrefetchAsync. * - * In a multi-GPU system where all of the GPUs have a zero value for the device attribute - * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS and all the GPUs have peer-to-peer support - * with each other, the physical storage for managed memory is created on the GPU which is active - * at the time ::cuMemAllocManaged is called. All other GPUs will reference the data at reduced - * bandwidth via peer mappings over the PCIe bus. The Unified Memory driver does not migrate - * memory among such GPUs. + * In a multi-GPU system where all of the GPUs have a zero value for the device + * attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS and all the GPUs have + * peer-to-peer support with each other, the physical storage for managed memory + * is created on the GPU which is active at the time ::cuMemAllocManaged is + * called. All other GPUs will reference the data at reduced bandwidth via peer + * mappings over the PCIe bus. The Unified Memory driver does not migrate memory + * among such GPUs. * - * In a multi-GPU system where not all GPUs have peer-to-peer support with each other and - * where the value of the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS - * is zero for at least one of those GPUs, the location chosen for physical storage of managed - * memory is system-dependent. - * - On Linux, the location chosen will be device memory as long as the current set of active - * contexts are on devices that either have peer-to-peer support with each other or have a - * non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. - * If there is an active context on a GPU that does not have a non-zero value for that device - * attribute and it does not have peer-to-peer support with the other devices that have active - * contexts on them, then the location for physical storage will be 'zero-copy' or host memory. - * Note that this means that managed memory that is located in device memory is migrated to - * host memory if a new context is created on a GPU that doesn't have a non-zero value for - * the device attribute and does not support peer-to-peer with at least one of the other devices - * that has an active context. This in turn implies that context creation may fail if there is - * insufficient host memory to migrate all managed allocations. - * - On Windows, the physical storage is always created in 'zero-copy' or host memory. - * All GPUs will reference the data at reduced bandwidth over the PCIe bus. In these - * circumstances, use of the environment variable CUDA_VISIBLE_DEVICES is recommended to - * restrict CUDA to only use those GPUs that have peer-to-peer support. - * Alternatively, users can also set CUDA_MANAGED_FORCE_DEVICE_ALLOC to a - * non-zero value to force the driver to always use device memory for physical storage. - * When this environment variable is set to a non-zero value, all contexts created in - * that process on devices that support managed memory have to be peer-to-peer compatible - * with each other. Context creation will fail if a context is created on a device that - * supports managed memory and is not peer-to-peer compatible with any of the other - * managed memory supporting devices on which contexts were previously created, even if - * those contexts have been destroyed. These environment variables are described - * in the CUDA programming guide under the "CUDA environment variables" section. + * In a multi-GPU system where not all GPUs have peer-to-peer support with each + * other and where the value of the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS is zero for at least one of + * those GPUs, the location chosen for physical storage of managed memory is + * system-dependent. + * - On Linux, the location chosen will be device memory as long as the current + * set of active contexts are on devices that either have peer-to-peer support + * with each other or have a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If there is an active + * context on a GPU that does not have a non-zero value for that device + * attribute and it does not have peer-to-peer support with the other devices + * that have active contexts on them, then the location for physical storage + * will be 'zero-copy' or host memory. Note that this means that managed memory + * that is located in device memory is migrated to host memory if a new context + * is created on a GPU that doesn't have a non-zero value for the device + * attribute and does not support peer-to-peer with at least one of the other + * devices that has an active context. This in turn implies that context + * creation may fail if there is insufficient host memory to migrate all managed + * allocations. + * - On Windows, the physical storage is always created in 'zero-copy' or host + * memory. All GPUs will reference the data at reduced bandwidth over the PCIe + * bus. In these circumstances, use of the environment variable + * CUDA_VISIBLE_DEVICES is recommended to restrict CUDA to only use those GPUs + * that have peer-to-peer support. Alternatively, users can also set + * CUDA_MANAGED_FORCE_DEVICE_ALLOC to a non-zero value to force the driver to + * always use device memory for physical storage. When this environment variable + * is set to a non-zero value, all contexts created in that process on devices + * that support managed memory have to be peer-to-peer compatible with each + * other. Context creation will fail if a context is created on a device that + * supports managed memory and is not peer-to-peer compatible with any of the + * other managed memory supporting devices on which contexts were previously + * created, even if those contexts have been destroyed. These environment + * variables are described in the CUDA programming guide under the "CUDA + * environment variables" section. + * - On ARM, managed memory is not available on discrete gpu with Drive PX-2. * * \param dptr - Returned device pointer * \param bytesize - Requested allocation size in bytes - * \param flags - Must be one of ::CU_MEM_ATTACH_GLOBAL or ::CU_MEM_ATTACH_HOST + * \param flags - Must be one of ::CU_MEM_ATTACH_GLOBAL or + * ::CU_MEM_ATTACH_HOST * * \return * ::CUDA_SUCCESS, @@ -4449,15 +5460,18 @@ CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, - * ::cuDeviceGetAttribute, ::cuStreamAttachMemAsync + * ::cuDeviceGetAttribute, ::cuStreamAttachMemAsync, + * ::cudaMallocManaged */ -CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned int flags); +CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, + unsigned int flags); #endif /* __CUDA_API_VERSION >= 6000 */ @@ -4470,11 +5484,12 @@ CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned * * \param dev - Returned device handle * - * \param pciBusId - String in one of the following forms: + * \param pciBusId - String in one of the following forms: * [domain]:[bus]:[device].[function] * [domain]:[bus]:[device] * [bus]:[device].[function] - * where \p domain, \p bus, \p device, and \p function are all hexadecimal values + * where \p domain, \p bus, \p device, and \p function are all hexadecimal + * values * * \return * ::CUDA_SUCCESS, @@ -4484,7 +5499,11 @@ CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned * ::CUDA_ERROR_INVALID_DEVICE * \notefnerr * - * \sa ::cuDeviceGet, ::cuDeviceGetAttribute, ::cuDeviceGetPCIBusId + * \sa + * ::cuDeviceGet, + * ::cuDeviceGetAttribute, + * ::cuDeviceGetPCIBusId, + * ::cudaDeviceGetByPCIBusId */ CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId); @@ -4495,10 +5514,10 @@ CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId); * string pointed to by \p pciBusId. \p len specifies the maximum length of the * string that may be returned. * - * \param pciBusId - Returned identifier string for the device in the following format - * [domain]:[bus]:[device].[function] - * where \p domain, \p bus, \p device, and \p function are all hexadecimal values. - * pciBusId should be large enough to store 13 characters including the NULL-terminator. + * \param pciBusId - Returned identifier string for the device in the following + * format [domain]:[bus]:[device].[function] where \p domain, \p bus, \p device, + * and \p function are all hexadecimal values. pciBusId should be large enough + * to store 13 characters including the NULL-terminator. * * \param len - Maximum length of string to store in \p name * @@ -4512,65 +5531,73 @@ CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId); * ::CUDA_ERROR_INVALID_DEVICE * \notefnerr * - * \sa ::cuDeviceGet, ::cuDeviceGetAttribute, ::cuDeviceGetByPCIBusId + * \sa + * ::cuDeviceGet, + * ::cuDeviceGetAttribute, + * ::cuDeviceGetByPCIBusId, + * ::cudaDeviceGetPCIBusId */ CUresult CUDAAPI cuDeviceGetPCIBusId(char *pciBusId, int len, CUdevice dev); /** * \brief Gets an interprocess handle for a previously allocated event * - * Takes as input a previously allocated event. This event must have been - * created with the ::CU_EVENT_INTERPROCESS and ::CU_EVENT_DISABLE_TIMING + * Takes as input a previously allocated event. This event must have been + * created with the ::CU_EVENT_INTERPROCESS and ::CU_EVENT_DISABLE_TIMING * flags set. This opaque handle may be copied into other processes and * opened with ::cuIpcOpenEventHandle to allow efficient hardware * synchronization between GPU work in different processes. * - * After the event has been opened in the importing process, - * ::cuEventRecord, ::cuEventSynchronize, ::cuStreamWaitEvent and - * ::cuEventQuery may be used in either process. Performing operations - * on the imported event after the exported event has been freed + * After the event has been opened in the importing process, + * ::cuEventRecord, ::cuEventSynchronize, ::cuStreamWaitEvent and + * ::cuEventQuery may be used in either process. Performing operations + * on the imported event after the exported event has been freed * with ::cuEventDestroy will result in undefined behavior. * - * IPC functionality is restricted to devices with support for unified - * addressing on Linux operating systems. + * IPC functionality is restricted to devices with support for unified + * addressing on Linux and Windows operating systems. + * IPC functionality on Windows is restricted to GPUs in TCC mode * * \param pHandle - Pointer to a user allocated CUipcEventHandle * in which to return the opaque event handle - * \param event - Event allocated with ::CU_EVENT_INTERPROCESS and + * \param event - Event allocated with ::CU_EVENT_INTERPROCESS and * ::CU_EVENT_DISABLE_TIMING flags. * * \return * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_HANDLE, * ::CUDA_ERROR_OUT_OF_MEMORY, - * ::CUDA_ERROR_MAP_FAILED + * ::CUDA_ERROR_MAP_FAILED, + * ::CUDA_ERROR_INVALID_VALUE * - * \sa - * ::cuEventCreate, - * ::cuEventDestroy, + * \sa + * ::cuEventCreate, + * ::cuEventDestroy, * ::cuEventSynchronize, * ::cuEventQuery, * ::cuStreamWaitEvent, * ::cuIpcOpenEventHandle, * ::cuIpcGetMemHandle, * ::cuIpcOpenMemHandle, - * ::cuIpcCloseMemHandle + * ::cuIpcCloseMemHandle, + * ::cudaIpcGetEventHandle */ CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event); /** * \brief Opens an interprocess event handle for use in the current process * - * Opens an interprocess event handle exported from another process with - * ::cuIpcGetEventHandle. This function returns a ::CUevent that behaves like - * a locally created event with the ::CU_EVENT_DISABLE_TIMING flag specified. + * Opens an interprocess event handle exported from another process with + * ::cuIpcGetEventHandle. This function returns a ::CUevent that behaves like + * a locally created event with the ::CU_EVENT_DISABLE_TIMING flag specified. * This event must be freed with ::cuEventDestroy. * - * Performing operations on the imported event after the exported event has + * Performing operations on the imported event after the exported event has * been freed with ::cuEventDestroy will result in undefined behavior. * - * IPC functionality is restricted to devices with support for unified - * addressing on Linux operating systems. + * IPC functionality is restricted to devices with support for unified + * addressing on Linux and Windows operating systems. + * IPC functionality on Windows is restricted to GPUs in TCC mode * * \param phEvent - Returns the imported event * \param handle - Interprocess handle to open @@ -4580,55 +5607,61 @@ CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event); * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_MAP_FAILED, * ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED, - * ::CUDA_ERROR_INVALID_HANDLE + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_INVALID_VALUE * * \sa - * ::cuEventCreate, - * ::cuEventDestroy, + * ::cuEventCreate, + * ::cuEventDestroy, * ::cuEventSynchronize, * ::cuEventQuery, * ::cuStreamWaitEvent, * ::cuIpcGetEventHandle, * ::cuIpcGetMemHandle, * ::cuIpcOpenMemHandle, - * ::cuIpcCloseMemHandle + * ::cuIpcCloseMemHandle, + * ::cudaIpcOpenEventHandle */ -CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent, CUipcEventHandle handle); +CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent, + CUipcEventHandle handle); /** * \brief Gets an interprocess memory handle for an existing device memory * allocation * - * Takes a pointer to the base of an existing device memory allocation created - * with ::cuMemAlloc and exports it for use in another process. This is a + * Takes a pointer to the base of an existing device memory allocation created + * with ::cuMemAlloc and exports it for use in another process. This is a * lightweight operation and may be called multiple times on an allocation - * without adverse effects. + * without adverse effects. * * If a region of memory is freed with ::cuMemFree and a subsequent call * to ::cuMemAlloc returns memory with the same device address, * ::cuIpcGetMemHandle will return a unique handle for the - * new memory. + * new memory. * - * IPC functionality is restricted to devices with support for unified - * addressing on Linux operating systems. + * IPC functionality is restricted to devices with support for unified + * addressing on Linux and Windows operating systems. + * IPC functionality on Windows is restricted to GPUs in TCC mode * * \param pHandle - Pointer to user allocated ::CUipcMemHandle to return * the handle in. - * \param dptr - Base pointer to previously allocated device memory + * \param dptr - Base pointer to previously allocated device memory * * \returns * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_HANDLE, * ::CUDA_ERROR_OUT_OF_MEMORY, * ::CUDA_ERROR_MAP_FAILED, - * + * ::CUDA_ERROR_INVALID_VALUE + * * \sa * ::cuMemAlloc, * ::cuMemFree, * ::cuIpcGetEventHandle, * ::cuIpcOpenEventHandle, * ::cuIpcOpenMemHandle, - * ::cuIpcCloseMemHandle + * ::cuIpcCloseMemHandle, + * ::cudaIpcGetMemHandle */ CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr); @@ -4637,14 +5670,17 @@ CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr); * and returns a device pointer usable in the local process. * * Maps memory exported from another process with ::cuIpcGetMemHandle into - * the current device address space. For contexts on different devices + * the current device address space. For contexts on different devices * ::cuIpcOpenMemHandle can attempt to enable peer access between the - * devices as if the user called ::cuCtxEnablePeerAccess. This behavior is - * controlled by the ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS flag. + * devices as if the user called ::cuCtxEnablePeerAccess. This behavior is + * controlled by the ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS flag. * ::cuDeviceCanAccessPeer can determine if a mapping is possible. * + * ::cuIpcOpenMemHandle can open handles to devices that may not be visible + * in the process calling the API. + * * Contexts that may open ::CUipcMemHandles are restricted in the following way. - * ::CUipcMemHandles from each ::CUdevice in a given process may only be opened + * ::CUipcMemHandles from each ::CUdevice in a given process may only be opened * by one ::CUcontext per ::CUdevice per other process. * * Memory returned from ::cuIpcOpenMemHandle must be freed with @@ -4654,22 +5690,26 @@ CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr); * ::cuIpcCloseMemHandle in the importing context will result in undefined * behavior. * - * IPC functionality is restricted to devices with support for unified - * addressing on Linux operating systems. - * + * IPC functionality is restricted to devices with support for unified + * addressing on Linux and Windows operating systems. + * IPC functionality on Windows is restricted to GPUs in TCC mode + * * \param pdptr - Returned device pointer * \param handle - ::CUipcMemHandle to open - * \param Flags - Flags for this operation. Must be specified as ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS + * \param Flags - Flags for this operation. Must be specified as + * ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS * * \returns * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_MAP_FAILED, * ::CUDA_ERROR_INVALID_HANDLE, - * ::CUDA_ERROR_TOO_MANY_PEERS + * ::CUDA_ERROR_TOO_MANY_PEERS, + * ::CUDA_ERROR_INVALID_VALUE * - * \note No guarantees are made about the address returned in \p *pdptr. - * In particular, multiple processes may not receive the same address for the same \p handle. + * \note No guarantees are made about the address returned in \p *pdptr. + * In particular, multiple processes may not receive the same address for the + * same \p handle. * * \sa * ::cuMemAlloc, @@ -4680,12 +5720,14 @@ CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr); * ::cuIpcCloseMemHandle, * ::cuCtxEnablePeerAccess, * ::cuDeviceCanAccessPeer, + * ::cudaIpcOpenMemHandle */ -CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int Flags); +CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, + unsigned int Flags); /** * \brief Close memory mapped with ::cuIpcOpenMemHandle - * + * * Unmaps memory returnd by ::cuIpcOpenMemHandle. The original allocation * in the exporting process as well as imported mappings in other processes * will be unaffected. @@ -4693,17 +5735,18 @@ CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, u * Any resources used to enable peer access will be freed if this is the * last mapping using them. * - * IPC functionality is restricted to devices with support for unified - * addressing on Linux operating systems. + * IPC functionality is restricted to devices with support for unified + * addressing on Linux and Windows operating systems. + * IPC functionality on Windows is restricted to GPUs in TCC mode * * \param dptr - Device pointer returned by ::cuIpcOpenMemHandle - * + * * \returns * ::CUDA_SUCCESS, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_MAP_FAILED, * ::CUDA_ERROR_INVALID_HANDLE, - * + * ::CUDA_ERROR_INVALID_VALUE * \sa * ::cuMemAlloc, * ::cuMemFree, @@ -4711,6 +5754,7 @@ CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, u * ::cuIpcOpenEventHandle, * ::cuIpcGetMemHandle, * ::cuIpcOpenMemHandle, + * ::cudaIpcCloseMemHandle */ CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr); @@ -4722,14 +5766,14 @@ CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr); * * Page-locks the memory range specified by \p p and \p bytesize and maps it * for the device(s) as specified by \p Flags. This memory range also is added - * to the same tracking mechanism as ::cuMemHostAlloc to automatically accelerate - * calls to functions such as ::cuMemcpyHtoD(). Since the memory can be accessed - * directly by the device, it can be read or written with much higher bandwidth - * than pageable memory that has not been registered. Page-locking excessive - * amounts of memory may degrade system performance, since it reduces the amount - * of memory available to the system for paging. As a result, this function is - * best used sparingly to register staging areas for data exchange between - * host and device. + * to the same tracking mechanism as ::cuMemHostAlloc to automatically + * accelerate calls to functions such as ::cuMemcpyHtoD(). Since the memory can + * be accessed directly by the device, it can be read or written with much + * higher bandwidth than pageable memory that has not been registered. + * Page-locking excessive amounts of memory may degrade system performance, + * since it reduces the amount of memory available to the system for paging. As + * a result, this function is best used sparingly to register staging areas for + * data exchange between host and device. * * This function has limited support on Mac OS X. OS 10.7 or higher is required. * @@ -4742,8 +5786,7 @@ CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr); * * - ::CU_MEMHOSTREGISTER_DEVICEMAP: Maps the allocation into the CUDA address * space. The device pointer to the memory may be obtained by calling - * ::cuMemHostGetDevicePointer(). This feature is available only on GPUs - * with compute capability greater than or equal to 1.1. + * ::cuMemHostGetDevicePointer(). * * - ::CU_MEMHOSTREGISTER_IOMEMORY: The pointer is treated as pointing to some * I/O memory space, e.g. the PCI Express resource of a 3rd party device. @@ -4763,18 +5806,20 @@ CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr); * ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, the memory * can also be accessed from the device using the host pointer \p p. * The device pointer returned by ::cuMemHostGetDevicePointer() may or may not - * match the original host pointer \p ptr and depends on the devices visible to the - * application. If all devices visible to the application have a non-zero value for the - * device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() - * will match the original pointer \p ptr. If any device visible to the application - * has a zero value for the device attribute, the device pointer returned by - * ::cuMemHostGetDevicePointer() will not match the original host pointer \p ptr, - * but it will be suitable for use on all devices provided Unified Virtual Addressing - * is enabled. In such systems, it is valid to access the memory using either pointer - * on devices that have a non-zero value for the device attribute. Note however that - * such devices should access the memory using only of the two pointers and not both. + * match the original host pointer \p ptr and depends on the devices visible to + * the application. If all devices visible to the application have a non-zero + * value for the device attribute, the device pointer returned by + * ::cuMemHostGetDevicePointer() will match the original pointer \p ptr. If any + * device visible to the application has a zero value for the device attribute, + * the device pointer returned by + * ::cuMemHostGetDevicePointer() will not match the original host pointer \p + * ptr, but it will be suitable for use on all devices provided Unified Virtual + * Addressing is enabled. In such systems, it is valid to access the memory + * using either pointer on devices that have a non-zero value for the device + * attribute. Note however that such devices should access the memory using only + * of the two pointers and not both. * - * The memory page-locked by this function must be unregistered with + * The memory page-locked by this function must be unregistered with * ::cuMemHostUnregister(). * * \param p - Host pointer to memory to page-lock @@ -4793,9 +5838,14 @@ CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr); * ::CUDA_ERROR_NOT_SUPPORTED * \notefnerr * - * \sa ::cuMemHostUnregister, ::cuMemHostGetFlags, ::cuMemHostGetDevicePointer + * \sa + * ::cuMemHostUnregister, + * ::cuMemHostGetFlags, + * ::cuMemHostGetDevicePointer, + * ::cudaHostRegister */ -CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags); +CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, + unsigned int Flags); /** * \brief Unregisters a memory range that was registered with cuMemHostRegister. @@ -4817,19 +5867,21 @@ CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags) * ::CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED, * \notefnerr * - * \sa ::cuMemHostRegister + * \sa + * ::cuMemHostRegister, + * ::cudaHostUnregister */ CUresult CUDAAPI cuMemHostUnregister(void *p); /** * \brief Copies memory * - * Copies data between two pointers. - * \p dst and \p src are base pointers of the destination and source, respectively. - * \p ByteCount specifies the number of bytes to copy. - * Note that this function infers the type of the transfer (host to host, host to - * device, device to device, or device to host) from the pointer values. This - * function is only allowed in contexts which support unified addressing. + * Copies data between two pointers. + * \p dst and \p src are base pointers of the destination and source, + * respectively. \p ByteCount specifies the number of bytes to copy. Note that + * this function infers the type of the transfer (host to host, host to device, + * device to device, or device to host) from the pointer values. This function + * is only allowed in contexts which support unified addressing. * * \param dst - Destination unified virtual address space pointer * \param src - Source unified virtual address space pointer @@ -4853,7 +5905,10 @@ CUresult CUDAAPI cuMemHostUnregister(void *p); * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy, + * ::cudaMemcpyToSymbol, + * ::cudaMemcpyFromSymbol */ CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount); @@ -4861,9 +5916,9 @@ CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount); * \brief Copies device memory between two contexts * * Copies from device memory in one context to device memory in another - * context. \p dstDevice is the base device pointer of the destination memory - * and \p dstContext is the destination context. \p srcDevice is the base - * device pointer of the source memory and \p srcContext is the source pointer. + * context. \p dstDevice is the base device pointer of the destination memory + * and \p dstContext is the destination context. \p srcDevice is the base + * device pointer of the source memory and \p srcContext is the source pointer. * \p ByteCount specifies the number of bytes to copy. * * \param dstDevice - Destination device pointer @@ -4881,10 +5936,14 @@ CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount); * \notefnerr * \note_sync * - * \sa ::cuMemcpyDtoD, ::cuMemcpy3DPeer, ::cuMemcpyDtoDAsync, ::cuMemcpyPeerAsync, - * ::cuMemcpy3DPeerAsync + * \sa ::cuMemcpyDtoD, ::cuMemcpy3DPeer, ::cuMemcpyDtoDAsync, + * ::cuMemcpyPeerAsync, + * ::cuMemcpy3DPeerAsync, + * ::cudaMemcpyPeer */ -CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount); +CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount); #endif /* __CUDA_API_VERSION >= 4000 */ @@ -4913,14 +5972,18 @@ CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdev * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy, + * ::cudaMemcpyToSymbol */ -CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount); +CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, + size_t ByteCount); /** * \brief Copies memory from Device to Host @@ -4946,14 +6009,18 @@ CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy, + * ::cudaMemcpyFromSymbol */ -CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount); +CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount); /** * \brief Copies memory from Device to Device @@ -4984,9 +6051,13 @@ CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteC * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy, + * ::cudaMemcpyToSymbol, + * ::cudaMemcpyFromSymbol */ -CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount); +CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + size_t ByteCount); /** * \brief Copies memory from Device to Array @@ -5019,9 +6090,11 @@ CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpyToArray */ -CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount); +CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, + CUdeviceptr srcDevice, size_t ByteCount); /** * \brief Copies memory from Array to Device @@ -5051,22 +6124,25 @@ CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr sr * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpyFromArray */ -CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount); +CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, + size_t srcOffset, size_t ByteCount); /** * \brief Copies memory from Host to Array * * Copies from host memory to a 1D CUDA array. \p dstArray and \p dstOffset * specify the CUDA array handle and starting offset in bytes of the destination - * data. \p pSrc specifies the base address of the source. \p ByteCount specifies - * the number of bytes to copy. + * data. \p pSrc specifies the base address of the source. \p ByteCount + * specifies the number of bytes to copy. * * \param dstArray - Destination array * \param dstOffset - Offset in bytes of destination array @@ -5086,14 +6162,17 @@ CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t sr * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpyToArray */ -CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount); +CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount); /** * \brief Copies memory from Array to Host @@ -5126,9 +6205,11 @@ CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void *sr * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpyFromArray */ -CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount); +CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, + size_t ByteCount); /** * \brief Copies memory from Array to Array @@ -5160,14 +6241,18 @@ CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpyArrayToArray */ -CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount); +CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, + CUarray srcArray, size_t srcOffset, + size_t ByteCount); /** * \brief Copies memory for 2D arrays @@ -5210,9 +6295,9 @@ CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArr * * \par * If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::srcArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::srcArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5237,9 +6322,9 @@ CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArr * * \par * If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::dstArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::dstArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5321,12 +6406,16 @@ CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArr * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy2D, + * ::cudaMemcpy2DToArray, + * ::cudaMemcpy2DFromArray */ CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy); @@ -5369,9 +6458,9 @@ CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy); * * \par * If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::srcArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::srcArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5391,9 +6480,9 @@ CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy); * * \par * If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::dstArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::dstArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5480,12 +6569,16 @@ CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy2D, + * ::cudaMemcpy2DToArray, + * ::cudaMemcpy2DFromArray */ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); @@ -5505,7 +6598,8 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); CUdeviceptr srcDevice; CUarray srcArray; unsigned int srcPitch; // ignored when src is array - unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1 + unsigned int srcHeight; // ignored when src is array; may be 0 + if Depth==1 unsigned int dstXInBytes, dstY, dstZ; unsigned int dstLOD; @@ -5514,7 +6608,8 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); CUdeviceptr dstDevice; CUarray dstArray; unsigned int dstPitch; // ignored when dst is array - unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1 + unsigned int dstHeight; // ignored when dst is array; may be 0 + if Depth==1 unsigned int WidthInBytes; unsigned int Height; @@ -5536,9 +6631,9 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); * * \par * If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::srcArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::srcArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5560,9 +6655,9 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); * * \par * If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::dstArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::dstArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -5586,7 +6681,8 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); * \par * For host pointers, the starting address is * \code - void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes); + void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + + srcXInBytes); * \endcode * * \par @@ -5605,7 +6701,8 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); * \par * For host pointers, the base address is * \code - void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes); + void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + + dstXInBytes); * \endcode * * \par @@ -5648,12 +6745,14 @@ CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMemcpy3D */ CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy); #endif /* __CUDA_API_VERSION >= 3020 */ @@ -5678,19 +6777,20 @@ CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy); * \note_sync * * \sa ::cuMemcpyDtoD, ::cuMemcpyPeer, ::cuMemcpyDtoDAsync, ::cuMemcpyPeerAsync, - * ::cuMemcpy3DPeerAsync + * ::cuMemcpy3DPeerAsync, + * ::cudaMemcpy3DPeer */ CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy); /** * \brief Copies memory asynchronously * - * Copies data between two pointers. - * \p dst and \p src are base pointers of the destination and source, respectively. - * \p ByteCount specifies the number of bytes to copy. - * Note that this function infers the type of the transfer (host to host, host to - * device, device to device, or device to host) from the pointer values. This - * function is only allowed in contexts which support unified addressing. + * Copies data between two pointers. + * \p dst and \p src are base pointers of the destination and source, + * respectively. \p ByteCount specifies the number of bytes to copy. Note that + * this function infers the type of the transfer (host to host, host to device, + * device to device, or device to host) from the pointer values. This function + * is only allowed in contexts which support unified addressing. * * \param dst - Destination unified virtual address space pointer * \param src - Source unified virtual address space pointer @@ -5702,7 +6802,8 @@ CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy); * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5718,17 +6819,21 @@ CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy); * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyAsync, + * ::cudaMemcpyToSymbolAsync, + * ::cudaMemcpyFromSymbolAsync */ -CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, + size_t ByteCount, CUstream hStream); /** * \brief Copies device memory between two contexts asynchronously. * * Copies from device memory in one context to device memory in another - * context. \p dstDevice is the base device pointer of the destination memory - * and \p dstContext is the destination context. \p srcDevice is the base - * device pointer of the source memory and \p srcContext is the source pointer. + * context. \p dstDevice is the base device pointer of the destination memory + * and \p dstContext is the destination context. \p srcDevice is the base + * device pointer of the source memory and \p srcContext is the source pointer. * \p ByteCount specifies the number of bytes to copy. * * \param dstDevice - Destination device pointer @@ -5743,15 +6848,19 @@ CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCoun * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream * - * \sa ::cuMemcpyDtoD, ::cuMemcpyPeer, ::cuMemcpy3DPeer, ::cuMemcpyDtoDAsync, - * ::cuMemcpy3DPeerAsync + * \sa ::cuMemcpyDtoD, ::cuMemcpyPeer, ::cuMemcpy3DPeer, ::cuMemcpyDtoDAsync, + * ::cuMemcpy3DPeerAsync, + * ::cudaMemcpyPeerAsync */ -CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount, CUstream hStream); #endif /* __CUDA_API_VERSION >= 4000 */ #if __CUDA_API_VERSION >= 3020 @@ -5772,7 +6881,8 @@ CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5781,16 +6891,20 @@ CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyAsync, + * ::cudaMemcpyToSymbolAsync */ -CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, + size_t ByteCount, CUstream hStream); /** * \brief Copies memory from Device to Host @@ -5809,7 +6923,8 @@ CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, s * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5818,16 +6933,20 @@ CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, s * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyAsync, + * ::cudaMemcpyFromSymbolAsync */ -CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount, CUstream hStream); /** * \brief Copies memory from Device to Device @@ -5846,7 +6965,8 @@ CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5862,9 +6982,13 @@ CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyAsync, + * ::cudaMemcpyToSymbolAsync, + * ::cudaMemcpyFromSymbolAsync */ -CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + size_t ByteCount, CUstream hStream); /** * \brief Copies memory from Host to Array @@ -5885,7 +7009,8 @@ CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5894,16 +7019,20 @@ CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyToArrayAsync */ -CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount, + CUstream hStream); /** * \brief Copies memory from Array to Host @@ -5924,7 +7053,8 @@ CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const voi * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -5940,9 +7070,12 @@ CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const voi * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpyFromArrayAsync */ -CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, + size_t srcOffset, size_t ByteCount, + CUstream hStream); /** * \brief Copies memory for 2D arrays @@ -5988,9 +7121,9 @@ CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOf * * \par * If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::srcArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::srcArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -6005,9 +7138,9 @@ CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOf * * \par * If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::dstArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::dstArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -6089,7 +7222,8 @@ CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOf * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -6098,14 +7232,18 @@ CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOf * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpy2DAsync, + * ::cudaMemcpy2DToArrayAsync, + * ::cudaMemcpy2DFromArrayAsync */ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); @@ -6125,7 +7263,8 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); CUdeviceptr srcDevice; CUarray srcArray; unsigned int srcPitch; // ignored when src is array - unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1 + unsigned int srcHeight; // ignored when src is array; may be 0 + if Depth==1 unsigned int dstXInBytes, dstY, dstZ; unsigned int dstLOD; @@ -6134,7 +7273,8 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); CUdeviceptr dstDevice; CUarray dstArray; unsigned int dstPitch; // ignored when dst is array - unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1 + unsigned int dstHeight; // ignored when dst is array; may be 0 + if Depth==1 unsigned int WidthInBytes; unsigned int Height; @@ -6156,9 +7296,9 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * * \par * If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::srcArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::srcArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -6180,9 +7320,9 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * * \par * If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch - * specify the (unified virtual address space) base address of the source data - * and the bytes per row to apply. ::dstArray is ignored. - * This value may be used only if unified addressing is supported in the calling + * specify the (unified virtual address space) base address of the source data + * and the bytes per row to apply. ::dstArray is ignored. + * This value may be used only if unified addressing is supported in the calling * context. * * \par @@ -6206,7 +7346,8 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * \par * For host pointers, the starting address is * \code - void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes); + void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + + srcXInBytes); * \endcode * * \par @@ -6225,7 +7366,8 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * \par * For host pointers, the base address is * \code - void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes); + void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + + dstXInBytes); * \endcode * * \par @@ -6261,7 +7403,8 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * \note_async * \note_null_stream @@ -6270,14 +7413,16 @@ CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemcpy3DAsync */ CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream); #endif /* __CUDA_API_VERSION >= 3020 */ @@ -6304,9 +7449,11 @@ CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream); * \note_null_stream * * \sa ::cuMemcpyDtoD, ::cuMemcpyPeer, ::cuMemcpyDtoDAsync, ::cuMemcpyPeerAsync, - * ::cuMemcpy3DPeerAsync + * ::cuMemcpy3DPeerAsync, + * ::cudaMemcpy3DPeerAsync */ -CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream); +CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, + CUstream hStream); #endif /* __CUDA_API_VERSION >= 4000 */ #if __CUDA_API_VERSION >= 3020 @@ -6333,14 +7480,16 @@ CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream h * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset */ CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N); @@ -6367,16 +7516,19 @@ CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset */ -CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N); +CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, + size_t N); /** * \brief Initializes device memory @@ -6401,14 +7553,16 @@ CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N) * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32Async + * ::cuMemsetD32Async, + * ::cudaMemset */ CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N); @@ -6440,16 +7594,19 @@ CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2D */ -CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height); +CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, size_t Height); /** * \brief Initializes device memory @@ -6480,16 +7637,19 @@ CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned c * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2D */ -CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height); +CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, + unsigned short us, size_t Width, size_t Height); /** * \brief Initializes device memory @@ -6520,16 +7680,19 @@ CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2D */ -CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height); +CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, + unsigned int ui, size_t Width, size_t Height); /** * \brief Sets device memory @@ -6556,16 +7719,19 @@ CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemsetAsync */ -CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream); +CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, + size_t N, CUstream hStream); /** * \brief Sets device memory @@ -6592,16 +7758,19 @@ CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemsetAsync */ -CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream); +CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, + size_t N, CUstream hStream); /** * \brief Sets device memory @@ -6628,15 +7797,19 @@ CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, - * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, ::cuMemsetD32 + * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, + * ::cuMemsetD32, + * ::cudaMemsetAsync */ -CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream); +CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, + size_t N, CUstream hStream); /** * \brief Sets device memory @@ -6668,23 +7841,27 @@ CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2DAsync */ -CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream); +CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, + size_t Height, CUstream hStream); /** * \brief Sets device memory * * Sets the 2D memory range of \p Width 16-bit values to the specified value * \p us. \p Height specifies the number of rows to set, and \p dstPitch - * specifies the number of bytes between each row. The \p dstDevice pointer + * specifies the number of bytes between each row. The \p dstDevice pointer * and \p dstPitch offset must be two byte aligned. This function performs * fastest when the pitch is one that has been passed back by * ::cuMemAllocPitch(). @@ -6710,16 +7887,20 @@ CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsig * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D32, ::cuMemsetD2D32Async, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2DAsync */ -CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, 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); /** * \brief Sets device memory @@ -6752,16 +7933,20 @@ CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsi * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D8Async, * ::cuMemsetD2D16, ::cuMemsetD2D16Async, ::cuMemsetD2D32, * ::cuMemsetD8, ::cuMemsetD8Async, ::cuMemsetD16, ::cuMemsetD16Async, - * ::cuMemsetD32, ::cuMemsetD32Async + * ::cuMemsetD32, ::cuMemsetD32Async, + * ::cudaMemset2DAsync */ -CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, 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); /** * \brief Creates a 1D or 2D CUDA array @@ -6857,14 +8042,17 @@ CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsi * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMallocArray */ -CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pAllocateArray); +CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, + const CUDA_ARRAY_DESCRIPTOR *pAllocateArray); /** * \brief Get a 1D or 2D CUDA array descriptor @@ -6890,17 +8078,19 @@ CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pA * ::cuArrayDestroy, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaArrayGetInfo */ -CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray); +CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, + CUarray hArray); #endif /* __CUDA_API_VERSION >= 3020 */ - /** * \brief Destroys a CUDA array * @@ -6914,19 +8104,22 @@ CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, C * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_HANDLE, - * ::CUDA_ERROR_ARRAY_IS_MAPPED + * ::CUDA_ERROR_ARRAY_IS_MAPPED, + * ::CUDA_ERROR_CONTEXT_IS_DESTROYED * \notefnerr * * \sa ::cuArray3DCreate, ::cuArray3DGetDescriptor, ::cuArrayCreate, * ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaFreeArray */ CUresult CUDAAPI cuArrayDestroy(CUarray hArray); @@ -6951,26 +8144,40 @@ CUresult CUDAAPI cuArrayDestroy(CUarray hArray); * where: * * - \p Width, \p Height, and \p Depth are the width, height, and depth of the - * CUDA array (in elements); the following types of CUDA arrays can be allocated: - * - A 1D array is allocated if \p Height and \p Depth extents are both zero. + * CUDA array (in elements); the following types of CUDA arrays can be + allocated: + * - A 1D array is allocated if \p Height and \p Depth extents are both + zero. * - A 2D array is allocated if only \p Depth extent is zero. * - A 3D array is allocated if all three extents are non-zero. - * - A 1D layered CUDA array is allocated if only \p Height is zero and the - * ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The number + * - A 1D layered CUDA array is allocated if only \p Height is zero and the + * ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The + number * of layers is determined by the depth extent. - * - A 2D layered CUDA array is allocated if all three extents are non-zero and - * the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number + * - A 2D layered CUDA array is allocated if all three extents are non-zero + and + * the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The + number * of layers is determined by the depth extent. - * - A cubemap CUDA array is allocated if all three extents are non-zero and the - * ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p Height, and - * \p Depth must be six. A cubemap is a special type of 2D layered CUDA array, - * where the six layers represent the six faces of a cube. The order of the six + * - A cubemap CUDA array is allocated if all three extents are non-zero and + the + * ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p + Height, and + * \p Depth must be six. A cubemap is a special type of 2D layered CUDA + array, + * where the six layers represent the six faces of a cube. The order of + the six * layers in memory is the same as that listed in ::CUarray_cubemap_face. - * - A cubemap layered CUDA array is allocated if all three extents are non-zero, - * and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are set. - * \p Width must be equal to \p Height, and \p Depth must be a multiple of six. - * A cubemap layered CUDA array is a special type of 2D layered CUDA array that - * consists of a collection of cubemaps. The first six layers represent the first + * - A cubemap layered CUDA array is allocated if all three extents are + non-zero, + * and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are + set. + * \p Width must be equal to \p Height, and \p Depth must be a multiple of + six. + * A cubemap layered CUDA array is a special type of 2D layered CUDA array + that + * consists of a collection of cubemaps. The first six layers represent + the first * cubemap, the next six layers form the second cubemap, and so on. * * - ::Format specifies the format of the elements; ::CUarray_format is @@ -6991,32 +8198,44 @@ CUresult CUDAAPI cuArrayDestroy(CUarray hArray); * - \p NumChannels specifies the number of packed components per CUDA array * element; it may be 1, 2, or 4; * - * - ::Flags may be set to - * - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA arrays. If this flag is set, + * - ::Flags may be set to + * - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA arrays. If this + flag is set, * \p Depth specifies the number of layers, not the depth of a 3D array. - * - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to the CUDA array. - * If this flag is not set, ::cuSurfRefSetArray will fail when attempting to bind the CUDA array + * - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to + the CUDA array. + * If this flag is not set, ::cuSurfRefSetArray will fail when attempting to + bind the CUDA array * to a surface reference. - * - ::CUDA_ARRAY3D_CUBEMAP to enable creation of cubemaps. If this flag is set, \p Width must be - * equal to \p Height, and \p Depth must be six. If the ::CUDA_ARRAY3D_LAYERED flag is also set, + * - ::CUDA_ARRAY3D_CUBEMAP to enable creation of cubemaps. If this flag is + set, \p Width must be + * equal to \p Height, and \p Depth must be six. If the + ::CUDA_ARRAY3D_LAYERED flag is also set, * then \p Depth must be a multiple of six. - * - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA array will be used for texture gather. + * - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA array will be + used for texture gather. * Texture gather can only be performed on 2D CUDA arrays. * - * \p Width, \p Height and \p Depth must meet certain size requirements as listed in the following table. - * All values are specified in elements. Note that for brevity's sake, the full name of the device attribute - * is not specified. For ex., TEXTURE1D_WIDTH refers to the device attribute + * \p Width, \p Height and \p Depth must meet certain size requirements as + listed in the following table. + * All values are specified in elements. Note that for brevity's sake, the full + name of the device attribute + * is not specified. For ex., TEXTURE1D_WIDTH refers to the device attribute * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH. * - * Note that 2D CUDA arrays have different size requirements if the ::CUDA_ARRAY3D_TEXTURE_GATHER flag - * is set. \p Width and \p Height must not be greater than ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH - * and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT respectively, in that case. + * Note that 2D CUDA arrays have different size requirements if the + ::CUDA_ARRAY3D_TEXTURE_GATHER flag + * is set. \p Width and \p Height must not be greater than + ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH + * and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT respectively, in + that case. * * <table> * <tr><td><b>CUDA array type</b></td> - * <td><b>Valid extents that must always be met<br>{(width range in elements), (height range), + * <td><b>Valid extents that must always be met<br>{(width range in elements), + (height range), * (depth range)}</b></td> - * <td><b>Valid extents with CUDA_ARRAY3D_SURFACE_LDST set<br> + * <td><b>Valid extents with CUDA_ARRAY3D_SURFACE_LDST set<br> * {(width range in elements), (height range), (depth range)}</b></td></tr> * <tr><td>1D</td> * <td><small>{ (1,TEXTURE1D_WIDTH), 0, 0 }</small></td> @@ -7026,28 +8245,31 @@ CUresult CUDAAPI cuArrayDestroy(CUarray hArray); * <td><small>{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }</small></td></tr> * <tr><td>3D</td> * <td><small>{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } - * <br>OR<br>{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), + * <br>OR<br>{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), * (1,TEXTURE3D_DEPTH_ALTERNATE) }</small></td> - * <td><small>{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), + * <td><small>{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), * (1,SURFACE3D_DEPTH) }</small></td></tr> * <tr><td>1D Layered</td> - * <td><small>{ (1,TEXTURE1D_LAYERED_WIDTH), 0, + * <td><small>{ (1,TEXTURE1D_LAYERED_WIDTH), 0, * (1,TEXTURE1D_LAYERED_LAYERS) }</small></td> - * <td><small>{ (1,SURFACE1D_LAYERED_WIDTH), 0, + * <td><small>{ (1,SURFACE1D_LAYERED_WIDTH), 0, * (1,SURFACE1D_LAYERED_LAYERS) }</small></td></tr> * <tr><td>2D Layered</td> - * <td><small>{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), + * <td><small>{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), * (1,TEXTURE2D_LAYERED_LAYERS) }</small></td> - * <td><small>{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), + * <td><small>{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), * (1,SURFACE2D_LAYERED_LAYERS) }</small></td></tr> * <tr><td>Cubemap</td> - * <td><small>{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }</small></td> - * <td><small>{ (1,SURFACECUBEMAP_WIDTH), + * <td><small>{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 + }</small></td> + * <td><small>{ (1,SURFACECUBEMAP_WIDTH), * (1,SURFACECUBEMAP_WIDTH), 6 }</small></td></tr> * <tr><td>Cubemap Layered</td> - * <td><small>{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), + * <td><small>{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), + (1,TEXTURECUBEMAP_LAYERED_WIDTH), * (1,TEXTURECUBEMAP_LAYERED_LAYERS) }</small></td> - * <td><small>{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), + * <td><small>{ (1,SURFACECUBEMAP_LAYERED_WIDTH), + (1,SURFACECUBEMAP_LAYERED_WIDTH), * (1,SURFACECUBEMAP_LAYERED_LAYERS) }</small></td></tr> * </table> * @@ -7101,14 +8323,17 @@ CUresult CUDAAPI cuArrayDestroy(CUarray hArray); * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaMalloc3DArray */ -CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray); +CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, + const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray); /** * \brief Get a 3D CUDA array descriptor @@ -7130,21 +8355,25 @@ CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE, - * ::CUDA_ERROR_INVALID_HANDLE + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_CONTEXT_IS_DESTROYED * \notefnerr * * \sa ::cuArray3DCreate, ::cuArrayCreate, * ::cuArrayDestroy, ::cuArrayGetDescriptor, ::cuMemAlloc, ::cuMemAllocHost, * ::cuMemAllocPitch, ::cuMemcpy2D, ::cuMemcpy2DAsync, ::cuMemcpy2DUnaligned, * ::cuMemcpy3D, ::cuMemcpy3DAsync, ::cuMemcpyAtoA, ::cuMemcpyAtoD, - * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, ::cuMemcpyDtoDAsync, + * ::cuMemcpyAtoH, ::cuMemcpyAtoHAsync, ::cuMemcpyDtoA, ::cuMemcpyDtoD, + * ::cuMemcpyDtoDAsync, * ::cuMemcpyDtoH, ::cuMemcpyDtoHAsync, ::cuMemcpyHtoA, ::cuMemcpyHtoAAsync, * ::cuMemcpyHtoD, ::cuMemcpyHtoDAsync, ::cuMemFree, ::cuMemFreeHost, * ::cuMemGetAddressRange, ::cuMemGetInfo, ::cuMemHostAlloc, * ::cuMemHostGetDevicePointer, ::cuMemsetD2D8, ::cuMemsetD2D16, - * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32 + * ::cuMemsetD2D32, ::cuMemsetD8, ::cuMemsetD16, ::cuMemsetD32, + * ::cudaArrayGetInfo */ -CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray); +CUresult CUDAAPI cuArray3DGetDescriptor( + CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray); #endif /* __CUDA_API_VERSION >= 3020 */ #if __CUDA_API_VERSION >= 5000 @@ -7152,9 +8381,12 @@ CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescripto /** * \brief Creates a CUDA mipmapped array * - * Creates a CUDA mipmapped array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure - * \p pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array in \p *pHandle. - * \p numMipmapLevels specifies the number of mipmap levels to be allocated. This value is + * Creates a CUDA mipmapped array according to the ::CUDA_ARRAY3D_DESCRIPTOR + structure + * \p pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array + in \p *pHandle. + * \p numMipmapLevels specifies the number of mipmap levels to be allocated. + This value is * clamped to the range [1, 1 + floor(log2(max(width, height, depth)))]. * * The ::CUDA_ARRAY3D_DESCRIPTOR is defined as: @@ -7172,26 +8404,41 @@ CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescripto * where: * * - \p Width, \p Height, and \p Depth are the width, height, and depth of the - * CUDA array (in elements); the following types of CUDA arrays can be allocated: - * - A 1D mipmapped array is allocated if \p Height and \p Depth extents are both zero. + * CUDA array (in elements); the following types of CUDA arrays can be + allocated: + * - A 1D mipmapped array is allocated if \p Height and \p Depth extents are + both zero. * - A 2D mipmapped array is allocated if only \p Depth extent is zero. * - A 3D mipmapped array is allocated if all three extents are non-zero. - * - A 1D layered CUDA mipmapped array is allocated if only \p Height is zero and the - * ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The number + * - A 1D layered CUDA mipmapped array is allocated if only \p Height is + zero and the + * ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The + number * of layers is determined by the depth extent. - * - A 2D layered CUDA mipmapped array is allocated if all three extents are non-zero and - * the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number + * - A 2D layered CUDA mipmapped array is allocated if all three extents are + non-zero and + * the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The + number * of layers is determined by the depth extent. - * - A cubemap CUDA mipmapped array is allocated if all three extents are non-zero and the - * ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p Height, and - * \p Depth must be six. A cubemap is a special type of 2D layered CUDA array, - * where the six layers represent the six faces of a cube. The order of the six + * - A cubemap CUDA mipmapped array is allocated if all three extents are + non-zero and the + * ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p + Height, and + * \p Depth must be six. A cubemap is a special type of 2D layered CUDA + array, + * where the six layers represent the six faces of a cube. The order of + the six * layers in memory is the same as that listed in ::CUarray_cubemap_face. - * - A cubemap layered CUDA mipmapped array is allocated if all three extents are non-zero, - * and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are set. - * \p Width must be equal to \p Height, and \p Depth must be a multiple of six. - * A cubemap layered CUDA array is a special type of 2D layered CUDA array that - * consists of a collection of cubemaps. The first six layers represent the first + * - A cubemap layered CUDA mipmapped array is allocated if all three + extents are non-zero, + * and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are + set. + * \p Width must be equal to \p Height, and \p Depth must be a multiple of + six. + * A cubemap layered CUDA array is a special type of 2D layered CUDA array + that + * consists of a collection of cubemaps. The first six layers represent + the first * cubemap, the next six layers form the second cubemap, and so on. * * - ::Format specifies the format of the elements; ::CUarray_format is @@ -7212,46 +8459,74 @@ CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescripto * - \p NumChannels specifies the number of packed components per CUDA array * element; it may be 1, 2, or 4; * - * - ::Flags may be set to - * - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA mipmapped arrays. If this flag is set, + * - ::Flags may be set to + * - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA mipmapped + arrays. If this flag is set, * \p Depth specifies the number of layers, not the depth of a 3D array. - * - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to individual mipmap levels of - * the CUDA mipmapped array. If this flag is not set, ::cuSurfRefSetArray will fail when attempting to + * - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to + individual mipmap levels of + * the CUDA mipmapped array. If this flag is not set, ::cuSurfRefSetArray + will fail when attempting to * bind a mipmap level of the CUDA mipmapped array to a surface reference. - * - ::CUDA_ARRAY3D_CUBEMAP to enable creation of mipmapped cubemaps. If this flag is set, \p Width must be - * equal to \p Height, and \p Depth must be six. If the ::CUDA_ARRAY3D_LAYERED flag is also set, + * - ::CUDA_ARRAY3D_CUBEMAP to enable creation of mipmapped cubemaps. If this + flag is set, \p Width must be + * equal to \p Height, and \p Depth must be six. If the + ::CUDA_ARRAY3D_LAYERED flag is also set, * then \p Depth must be a multiple of six. - * - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA mipmapped array will be used for texture gather. + * - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA mipmapped array + will be used for texture gather. * Texture gather can only be performed on 2D CUDA mipmapped arrays. * - * \p Width, \p Height and \p Depth must meet certain size requirements as listed in the following table. - * All values are specified in elements. Note that for brevity's sake, the full name of the device attribute - * is not specified. For ex., TEXTURE1D_MIPMAPPED_WIDTH refers to the device attribute + * \p Width, \p Height and \p Depth must meet certain size requirements as + listed in the following table. + * All values are specified in elements. Note that for brevity's sake, the full + name of the device attribute + * is not specified. For ex., TEXTURE1D_MIPMAPPED_WIDTH refers to the device + attribute * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH. * * <table> * <tr><td><b>CUDA array type</b></td> - * <td><b>Valid extents that must always be met<br>{(width range in elements), (height range), - * (depth range)}</b></td></tr> + * <td><b>Valid extents that must always be met<br>{(width range in elements), + (height range), + * (depth range)}</b></td> + * <td><b>Valid extents with CUDA_ARRAY3D_SURFACE_LDST set<br> + * {(width range in elements), (height range), (depth range)}</b></td></tr> * <tr><td>1D</td> - * <td><small>{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 }</small></td></tr> + * <td><small>{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 }</small></td> + * <td><small>{ (1,SURFACE1D_WIDTH), 0, 0 }</small></td></tr> * <tr><td>2D</td> - * <td><small>{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_HEIGHT), 0 }</small></td></tr> + * <td><small>{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_HEIGHT), 0 + }</small></td> + * <td><small>{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }</small></td></tr> * <tr><td>3D</td> * <td><small>{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } - * <br>OR<br>{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), - * (1,TEXTURE3D_DEPTH_ALTERNATE) }</small></td></tr> + * <br>OR<br>{ (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), + * (1,TEXTURE3D_DEPTH_ALTERNATE) }</small></td> + * <td><small>{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), + * (1,SURFACE3D_DEPTH) }</small></td></tr> * <tr><td>1D Layered</td> - * <td><small>{ (1,TEXTURE1D_LAYERED_WIDTH), 0, - * (1,TEXTURE1D_LAYERED_LAYERS) }</small></td></tr> + * <td><small>{ (1,TEXTURE1D_LAYERED_WIDTH), 0, + * (1,TEXTURE1D_LAYERED_LAYERS) }</small></td> + * <td><small>{ (1,SURFACE1D_LAYERED_WIDTH), 0, + * (1,SURFACE1D_LAYERED_LAYERS) }</small></td></tr> * <tr><td>2D Layered</td> - * <td><small>{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), - * (1,TEXTURE2D_LAYERED_LAYERS) }</small></td></tr> + * <td><small>{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), + * (1,TEXTURE2D_LAYERED_LAYERS) }</small></td> + * <td><small>{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), + * (1,SURFACE2D_LAYERED_LAYERS) }</small></td></tr> * <tr><td>Cubemap</td> - * <td><small>{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }</small></td></tr> + * <td><small>{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 + }</small></td> + * <td><small>{ (1,SURFACECUBEMAP_WIDTH), + * (1,SURFACECUBEMAP_WIDTH), 6 }</small></td></tr> * <tr><td>Cubemap Layered</td> - * <td><small>{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), - * (1,TEXTURECUBEMAP_LAYERED_LAYERS) }</small></td></tr> + * <td><small>{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), + (1,TEXTURECUBEMAP_LAYERED_WIDTH), + * (1,TEXTURECUBEMAP_LAYERED_LAYERS) }</small></td> + * <td><small>{ (1,SURFACECUBEMAP_LAYERED_WIDTH), + (1,SURFACECUBEMAP_LAYERED_WIDTH), + * (1,SURFACECUBEMAP_LAYERED_LAYERS) }</small></td></tr> * </table> * * @@ -7269,9 +8544,16 @@ CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescripto * ::CUDA_ERROR_UNKNOWN * \notefnerr * - * \sa ::cuMipmappedArrayDestroy, ::cuMipmappedArrayGetLevel, ::cuArrayCreate, + * \sa + * ::cuMipmappedArrayDestroy, + * ::cuMipmappedArrayGetLevel, + * ::cuArrayCreate, + * ::cudaMallocMipmappedArray */ -CUresult CUDAAPI cuMipmappedArrayCreate(CUmipmappedArray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels); +CUresult CUDAAPI +cuMipmappedArrayCreate(CUmipmappedArray *pHandle, + const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, + unsigned int numMipmapLevels); /** * \brief Gets a mipmap level of a CUDA mipmapped array @@ -7279,7 +8561,8 @@ CUresult CUDAAPI cuMipmappedArrayCreate(CUmipmappedArray *pHandle, const CUDA_AR * Returns in \p *pLevelArray a CUDA array that represents a single mipmap level * of the CUDA mipmapped array \p hMipmappedArray. * - * If \p level is greater than the maximum number of levels in this mipmapped array, + * If \p level is greater than the maximum number of levels in this mipmapped + * array, * ::CUDA_ERROR_INVALID_VALUE is returned. * * \param pLevelArray - Returned mipmap level CUDA array @@ -7295,9 +8578,15 @@ CUresult CUDAAPI cuMipmappedArrayCreate(CUmipmappedArray *pHandle, const CUDA_AR * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * - * \sa ::cuMipmappedArrayCreate, ::cuMipmappedArrayDestroy, ::cuArrayCreate, + * \sa + * ::cuMipmappedArrayCreate, + * ::cuMipmappedArrayDestroy, + * ::cuArrayCreate, + * ::cudaGetMipmappedArrayLevel */ -CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level); +CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, + CUmipmappedArray hMipmappedArray, + unsigned int level); /** * \brief Destroys a CUDA mipmapped array @@ -7312,10 +8601,15 @@ CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, CUmipmappedArray * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_HANDLE, - * ::CUDA_ERROR_ARRAY_IS_MAPPED + * ::CUDA_ERROR_ARRAY_IS_MAPPED, + * ::CUDA_ERROR_CONTEXT_IS_DESTROYED * \notefnerr * - * \sa ::cuMipmappedArrayCreate, ::cuMipmappedArrayGetLevel, ::cuArrayCreate, + * \sa + * ::cuMipmappedArrayCreate, + * ::cuMipmappedArrayGetLevel, + * ::cuArrayCreate, + * ::cudaFreeMipmappedArray */ CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray); @@ -7329,90 +8623,90 @@ CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray); * ___MANBRIEF___ unified addressing functions of the low-level CUDA driver * API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the unified addressing functions of the + * This section describes the unified addressing functions of the * low-level CUDA driver application programming interface. * * @{ * * \section CUDA_UNIFIED_overview Overview * - * CUDA devices can share a unified address space with the host. + * CUDA devices can share a unified address space with the host. * For these devices there is no distinction between a device - * pointer and a host pointer -- the same pointer value may be - * used to access memory from the host program and from a kernel + * pointer and a host pointer -- the same pointer value may be + * used to access memory from the host program and from a kernel * running on the device (with exceptions enumerated below). * * \section CUDA_UNIFIED_support Supported Platforms - * - * Whether or not a device supports unified addressing may be - * queried by calling ::cuDeviceGetAttribute() with the device + * + * Whether or not a device supports unified addressing may be + * queried by calling ::cuDeviceGetAttribute() with the device * attribute ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING. * - * Unified addressing is automatically enabled in 64-bit processes - * on devices with compute capability greater than or equal to 2.0. + * Unified addressing is automatically enabled in 64-bit processes * * \section CUDA_UNIFIED_lookup Looking Up Information from Pointer Values * - * It is possible to look up information about the memory which backs a + * It is possible to look up information about the memory which backs a * pointer value. For instance, one may want to know if a pointer points - * to host or device memory. As another example, in the case of device - * memory, one may want to know on which CUDA device the memory - * resides. These properties may be queried using the function + * to host or device memory. As another example, in the case of device + * memory, one may want to know on which CUDA device the memory + * resides. These properties may be queried using the function * ::cuPointerGetAttribute() * * Since pointers are unique, it is not necessary to specify information - * about the pointers specified to the various copy functions in the + * about the pointers specified to the various copy functions in the * CUDA API. The function ::cuMemcpy() may be used to perform a copy * between two pointers, ignoring whether they point to host or device * memory (making ::cuMemcpyHtoD(), ::cuMemcpyDtoD(), and ::cuMemcpyDtoH() - * unnecessary for devices supporting unified addressing). For + * unnecessary for devices supporting unified addressing). For * multidimensional copies, the memory type ::CU_MEMORYTYPE_UNIFIED may be * used to specify that the CUDA driver should infer the location of the * pointer from its value. * - * \section CUDA_UNIFIED_automaphost Automatic Mapping of Host Allocated Host Memory + * \section CUDA_UNIFIED_automaphost Automatic Mapping of Host Allocated Host + * Memory * * All host memory allocated in all contexts using ::cuMemAllocHost() and * ::cuMemHostAlloc() is always directly accessible from all contexts on - * all devices that support unified addressing. This is the case regardless + * all devices that support unified addressing. This is the case regardless * of whether or not the flags ::CU_MEMHOSTALLOC_PORTABLE and * ::CU_MEMHOSTALLOC_DEVICEMAP are specified. * - * The pointer value through which allocated host memory may be accessed - * in kernels on all devices that support unified addressing is the same + * The pointer value through which allocated host memory may be accessed + * in kernels on all devices that support unified addressing is the same * as the pointer value through which that memory is accessed on the host, - * so it is not necessary to call ::cuMemHostGetDevicePointer() to get the device - * pointer for these allocations. - * + * so it is not necessary to call ::cuMemHostGetDevicePointer() to get the + * device pointer for these allocations. + * * Note that this is not the case for memory allocated using the flag * ::CU_MEMHOSTALLOC_WRITECOMBINED, as discussed below. * * \section CUDA_UNIFIED_autopeerregister Automatic Registration of Peer Memory * - * Upon enabling direct access from a context that supports unified addressing - * to another peer context that supports unified addressing using - * ::cuCtxEnablePeerAccess() all memory allocated in the peer context using - * ::cuMemAlloc() and ::cuMemAllocPitch() will immediately be accessible + * Upon enabling direct access from a context that supports unified addressing + * to another peer context that supports unified addressing using + * ::cuCtxEnablePeerAccess() all memory allocated in the peer context using + * ::cuMemAlloc() and ::cuMemAllocPitch() will immediately be accessible * by the current context. The device pointer value through * which any peer memory may be accessed in the current context * is the same pointer value through which that memory may be * accessed in the peer context. * * \section CUDA_UNIFIED_exceptions Exceptions, Disjoint Addressing - * + * * Not all memory may be accessed on devices through the same pointer * value through which they are accessed on the host. These exceptions * are host memory registered using ::cuMemHostRegister() and host memory - * allocated using the flag ::CU_MEMHOSTALLOC_WRITECOMBINED. For these + * allocated using the flag ::CU_MEMHOSTALLOC_WRITECOMBINED. For these * exceptions, there exists a distinct host and device address for the * memory. The device address is guaranteed to not overlap any valid host - * pointer range and is guaranteed to have the same value across all - * contexts that support unified addressing. - * - * This device address may be queried using ::cuMemHostGetDevicePointer() - * when a context using unified addressing is current. Either the host - * or the unified device pointer value may be used to refer to this memory - * through ::cuMemcpy() and similar functions using the + * pointer range and is guaranteed to have the same value across all + * contexts that support unified addressing. + * + * This device address may be queried using ::cuMemHostGetDevicePointer() + * when a context using unified addressing is current. Either the host + * or the unified device pointer value may be used to refer to this memory + * through ::cuMemcpy() and similar functions using the * ::CU_MEMORYTYPE_UNIFIED memory type. * */ @@ -7420,69 +8714,69 @@ CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray); #if __CUDA_API_VERSION >= 4000 /** * \brief Returns information about a pointer - * + * * The supported attributes are: - * - * - ::CU_POINTER_ATTRIBUTE_CONTEXT: - * - * Returns in \p *data the ::CUcontext in which \p ptr was allocated or - * registered. - * The type of \p data must be ::CUcontext *. - * + * + * - ::CU_POINTER_ATTRIBUTE_CONTEXT: + * + * Returns in \p *data the ::CUcontext in which \p ptr was allocated or + * registered. + * The type of \p data must be ::CUcontext *. + * * If \p ptr was not allocated by, mapped by, or registered with - * a ::CUcontext which uses unified virtual addressing then + * a ::CUcontext which uses unified virtual addressing then * ::CUDA_ERROR_INVALID_VALUE is returned. - * - * - ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE: - * - * Returns in \p *data the physical memory type of the memory that + * + * - ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE: + * + * Returns in \p *data the physical memory type of the memory that * \p ptr addresses as a ::CUmemorytype enumerated value. * The type of \p data must be unsigned int. - * - * If \p ptr addresses device memory then \p *data is set to - * ::CU_MEMORYTYPE_DEVICE. The particular ::CUdevice on which the - * memory resides is the ::CUdevice of the ::CUcontext returned by the + * + * If \p ptr addresses device memory then \p *data is set to + * ::CU_MEMORYTYPE_DEVICE. The particular ::CUdevice on which the + * memory resides is the ::CUdevice of the ::CUcontext returned by the * ::CU_POINTER_ATTRIBUTE_CONTEXT attribute of \p ptr. - * - * If \p ptr addresses host memory then \p *data is set to + * + * If \p ptr addresses host memory then \p *data is set to * ::CU_MEMORYTYPE_HOST. - * + * * If \p ptr was not allocated by, mapped by, or registered with - * a ::CUcontext which uses unified virtual addressing then + * a ::CUcontext which uses unified virtual addressing then * ::CUDA_ERROR_INVALID_VALUE is returned. * - * If the current ::CUcontext does not support unified virtual + * If the current ::CUcontext does not support unified virtual * addressing then ::CUDA_ERROR_INVALID_CONTEXT is returned. - * + * * - ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER: - * + * * Returns in \p *data the device pointer value through which - * \p ptr may be accessed by kernels running in the current + * \p ptr may be accessed by kernels running in the current * ::CUcontext. * The type of \p data must be CUdeviceptr *. - * + * * If there exists no device pointer value through which * kernels running in the current ::CUcontext may access * \p ptr then ::CUDA_ERROR_INVALID_VALUE is returned. - * - * If there is no current ::CUcontext then + * + * If there is no current ::CUcontext then * ::CUDA_ERROR_INVALID_CONTEXT is returned. - * - * Except in the exceptional disjoint addressing cases discussed - * below, the value returned in \p *data will equal the input + * + * Except in the exceptional disjoint addressing cases discussed + * below, the value returned in \p *data will equal the input * value \p ptr. - * + * * - ::CU_POINTER_ATTRIBUTE_HOST_POINTER: - * - * Returns in \p *data the host pointer value through which + * + * Returns in \p *data the host pointer value through which * \p ptr may be accessed by by the host program. * The type of \p data must be void **. * If there exists no host pointer value through which - * the host program may directly access \p ptr then + * the host program may directly access \p ptr then * ::CUDA_ERROR_INVALID_VALUE is returned. - * - * Except in the exceptional disjoint addressing cases discussed - * below, the value returned in \p *data will equal the input + * + * Except in the exceptional disjoint addressing cases discussed + * below, the value returned in \p *data will equal the input * value \p ptr. * * - ::CU_POINTER_ATTRIBUTE_P2P_TOKENS: @@ -7498,47 +8792,53 @@ CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray); * Querying this attribute has a side effect of setting the attribute * ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS for the region of memory that * \p ptr points to. - * + * * - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: * - * A boolean attribute which when set, ensures that synchronous memory operations - * initiated on the region of memory that \p ptr points to will always synchronize. - * See further documentation in the section titled "API synchronization behavior" - * to learn more about cases when synchronous memory operations can - * exhibit asynchronous behavior. + * A boolean attribute which when set, ensures that synchronous memory + * operations initiated on the region of memory that \p ptr points to will + * always synchronize. See further documentation in the section titled "API + * synchronization behavior" to learn more about cases when synchronous memory + * operations can exhibit asynchronous behavior. * * - ::CU_POINTER_ATTRIBUTE_BUFFER_ID: * - * Returns in \p *data a buffer ID which is guaranteed to be unique within the process. - * \p data must point to an unsigned long long. + * Returns in \p *data a buffer ID which is guaranteed to be unique within + * the process. \p data must point to an unsigned long long. * - * \p ptr must be a pointer to memory obtained from a CUDA memory allocation API. - * Every memory allocation from any of the CUDA memory allocation APIs will - * have a unique ID over a process lifetime. Subsequent allocations do not reuse IDs - * from previous freed allocations. IDs are only unique within a single process. + * \p ptr must be a pointer to memory obtained from a CUDA memory + * allocation API. Every memory allocation from any of the CUDA memory + * allocation APIs will have a unique ID over a process lifetime. Subsequent + * allocations do not reuse IDs from previous freed allocations. IDs are only + * unique within a single process. * * * - ::CU_POINTER_ATTRIBUTE_IS_MANAGED: * - * Returns in \p *data a boolean that indicates whether the pointer points to - * managed memory or not. + * Returns in \p *data a boolean that indicates whether the pointer points + * to managed memory or not. + * + * - ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL: + * + * Returns in \p *data an integer representing a device ordinal of a device + * against which the memory was allocated or registered. * * \par * * Note that for most allocations in the unified virtual address space - * the host and device pointer for accessing the allocation will be the + * the host and device pointer for accessing the allocation will be the * same. The exceptions to this are - * - user memory registered using ::cuMemHostRegister - * - host memory allocated using ::cuMemHostAlloc with the + * - user memory registered using ::cuMemHostRegister + * - host memory allocated using ::cuMemHostAlloc with the * ::CU_MEMHOSTALLOC_WRITECOMBINED flag - * For these types of allocation there will exist separate, disjoint host - * and device addresses for accessing the allocation. In particular - * - The host address will correspond to an invalid unmapped device address - * (which will result in an exception if accessed from the device) - * - The device address will correspond to an invalid unmapped host address + * For these types of allocation there will exist separate, disjoint host + * and device addresses for accessing the allocation. In particular + * - The host address will correspond to an invalid unmapped device address + * (which will result in an exception if accessed from the device) + * - The device address will correspond to an invalid unmapped host address * (which will result in an exception if accessed from the host). - * For these types of allocations, querying ::CU_POINTER_ATTRIBUTE_HOST_POINTER - * and ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER may be used to retrieve the host + * For these types of allocations, querying ::CU_POINTER_ATTRIBUTE_HOST_POINTER + * and ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER may be used to retrieve the host * and device addresses from either address. * * \param data - Returned pointer attribute value @@ -7554,64 +8854,73 @@ CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray); * ::CUDA_ERROR_INVALID_DEVICE * \notefnerr * - * \sa cuPointerSetAttribute, + * \sa + * ::cuPointerSetAttribute, * ::cuMemAlloc, * ::cuMemFree, * ::cuMemAllocHost, * ::cuMemFreeHost, * ::cuMemHostAlloc, * ::cuMemHostRegister, - * ::cuMemHostUnregister + * ::cuMemHostUnregister, + * ::cudaPointerGetAttributes */ -CUresult CUDAAPI cuPointerGetAttribute(void *data, CUpointer_attribute attribute, CUdeviceptr ptr); +CUresult CUDAAPI cuPointerGetAttribute(void *data, + CUpointer_attribute attribute, + CUdeviceptr ptr); #endif /* __CUDA_API_VERSION >= 4000 */ #if __CUDA_API_VERSION >= 8000 /** * \brief Prefetches memory to the specified destination device * - * Prefetches memory to the specified destination device. \p devPtr is the - * base device pointer of the memory to be prefetched and \p dstDevice is the - * destination device. \p count specifies the number of bytes to copy. \p hStream - * is the stream in which the operation is enqueued. The memory range must refer - * to managed memory allocated via ::cuMemAllocManaged or declared via __managed__ variables. + * Prefetches memory to the specified destination device. \p devPtr is the + * base device pointer of the memory to be prefetched and \p dstDevice is the + * destination device. \p count specifies the number of bytes to copy. \p + * hStream is the stream in which the operation is enqueued. The memory range + * must refer to managed memory allocated via ::cuMemAllocManaged or declared + * via __managed__ variables. * - * Passing in CU_DEVICE_CPU for \p dstDevice will prefetch the data to host memory. If - * \p dstDevice is a GPU, then the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS - * must be non-zero. Additionally, \p hStream must be associated with a device that has a - * non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. + * Passing in CU_DEVICE_CPU for \p dstDevice will prefetch the data to host + * memory. If \p dstDevice is a GPU, then the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero. + * Additionally, \p hStream must be associated with a device that has a non-zero + * value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. * - * The start address and end address of the memory range will be rounded down and rounded up - * respectively to be aligned to CPU page size before the prefetch operation is enqueued - * in the stream. + * The start address and end address of the memory range will be rounded down + * and rounded up respectively to be aligned to CPU page size before the + * prefetch operation is enqueued in the stream. * - * If no physical memory has been allocated for this region, then this memory region - * will be populated and mapped on the destination device. If there's insufficient - * memory to prefetch the desired region, the Unified Memory driver may evict pages from other - * ::cuMemAllocManaged allocations to host memory in order to make room. Device memory - * allocated using ::cuMemAlloc or ::cuArrayCreate will not be evicted. + * If no physical memory has been allocated for this region, then this memory + * region will be populated and mapped on the destination device. If there's + * insufficient memory to prefetch the desired region, the Unified Memory driver + * may evict pages from other + * ::cuMemAllocManaged allocations to host memory in order to make room. Device + * memory allocated using ::cuMemAlloc or ::cuArrayCreate will not be evicted. * - * By default, any mappings to the previous location of the migrated pages are removed and - * mappings for the new location are only setup on \p dstDevice. The exact behavior however - * also depends on the settings applied to this memory range via ::cuMemAdvise as described - * below: + * By default, any mappings to the previous location of the migrated pages are + * removed and mappings for the new location are only setup on \p dstDevice. The + * exact behavior however also depends on the settings applied to this memory + * range via ::cuMemAdvise as described below: * - * If ::CU_MEM_ADVISE_SET_READ_MOSTLY was set on any subset of this memory range, - * then that subset will create a read-only copy of the pages on \p dstDevice. + * If ::CU_MEM_ADVISE_SET_READ_MOSTLY was set on any subset of this memory + * range, then that subset will create a read-only copy of the pages on \p + * dstDevice. * - * If ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION was called on any subset of this memory - * range, then the pages will be migrated to \p dstDevice even if \p dstDevice is not the - * preferred location of any pages in the memory range. + * If ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION was called on any subset of this + * memory range, then the pages will be migrated to \p dstDevice even if \p + * dstDevice is not the preferred location of any pages in the memory range. * - * If ::CU_MEM_ADVISE_SET_ACCESSED_BY was called on any subset of this memory range, - * then mappings to those pages from all the appropriate processors are updated to - * refer to the new location if establishing such a mapping is possible. Otherwise, - * those mappings are cleared. + * If ::CU_MEM_ADVISE_SET_ACCESSED_BY was called on any subset of this memory + * range, then mappings to those pages from all the appropriate processors are + * updated to refer to the new location if establishing such a mapping is + * possible. Otherwise, those mappings are cleared. * - * Note that this API is not required for functionality and only serves to improve performance - * by allowing the application to migrate data to a suitable location before it is accessed. - * Memory accesses to this range are always coherent and are allowed even when the data is - * actively being migrated. + * Note that this API is not required for functionality and only serves to + * improve performance by allowing the application to migrate data to a suitable + * location before it is accessed. Memory accesses to this range are always + * coherent and are allowed even when the data is actively being migrated. * * Note that this function is asynchronous with respect to the host and all work * on other devices. @@ -7630,77 +8939,134 @@ CUresult CUDAAPI cuPointerGetAttribute(void *data, CUpointer_attribute attribute * \note_null_stream * * \sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync, - * ::cuMemcpy3DPeerAsync, ::cuMemAdvise + * ::cuMemcpy3DPeerAsync, ::cuMemAdvise, + * ::cudaMemPrefetchAsync */ -CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream); +CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, + CUdevice dstDevice, CUstream hStream); /** * \brief Advise about the usage of a given memory range * - * Advise the Unified Memory subsystem about the usage pattern for the memory range - * starting at \p devPtr with a size of \p count bytes. The start address and end address of the memory - * range will be rounded down and rounded up respectively to be aligned to CPU page size before the - * advice is applied. The memory range must refer to managed memory allocated via ::cuMemAllocManaged - * or declared via __managed__ variables. + * Advise the Unified Memory subsystem about the usage pattern for the memory + * range starting at \p devPtr with a size of \p count bytes. The start address + * and end address of the memory range will be rounded down and rounded up + * respectively to be aligned to CPU page size before the advice is applied. The + * memory range must refer to managed memory allocated via ::cuMemAllocManaged + * or declared via __managed__ variables. The memory range could also refer to + * system-allocated pageable memory provided it represents a valid, + * host-accessible region of memory and all additional constraints imposed by \p + * advice as outlined below are also satisfied. Specifying an invalid + * system-allocated pageable memory range results in an error being returned. * * The \p advice parameter can take the following values: - * - ::CU_MEM_ADVISE_SET_READ_MOSTLY: This implies that the data is mostly going to be read - * from and only occasionally written to. Any read accesses from any processor to this region will create a - * read-only copy of at least the accessed pages in that processor's memory. Additionally, if ::cuMemPrefetchAsync - * is called on this region, it will create a read-only copy of the data on the destination processor. - * If any processor writes to this region, all copies of the corresponding page will be invalidated - * except for the one where the write occurred. The \p device argument is ignored for this advice. - * Note that for a page to be read-duplicated, the accessing processor must either be the CPU or a GPU - * that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. - * Also, if a context is created on a device that does not have the device attribute - * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS set, then read-duplication will not occur until - * all such contexts are destroyed. - * - ::CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY and also prevents the - * Unified Memory driver from attempting heuristic read-duplication on the memory range. Any read-duplicated - * copies of the data will be collapsed into a single copy. The location for the collapsed - * copy will be the preferred location if the page has a preferred location and one of the read-duplicated - * copies was resident at that location. Otherwise, the location chosen is arbitrary. - * - ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred location for the - * data to be the memory belonging to \p device. Passing in CU_DEVICE_CPU for \p device sets the - * preferred location as host memory. If \p device is a GPU, then it must have a non-zero value for the - * device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Setting the preferred location - * does not cause data to migrate to that location immediately. Instead, it guides the migration policy - * when a fault occurs on that memory region. If the data is already in its preferred location and the - * faulting processor can establish a mapping without requiring the data to be migrated, then - * data migration will be avoided. On the other hand, if the data is not in its preferred location - * or if a direct mapping cannot be established, then it will be migrated to the processor accessing - * it. It is important to note that setting the preferred location does not prevent data prefetching - * done using ::cuMemPrefetchAsync. - * Having a preferred location can override the page thrash detection and resolution logic in the Unified - * Memory driver. Normally, if a page is detected to be constantly thrashing between for example host and device - * memory, the page may eventually be pinned to host memory by the Unified Memory driver. But - * if the preferred location is set as device memory, then the page will continue to thrash indefinitely. - * If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the - * policies associated with that advice will override the policies of this advice. - * - ::CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: Undoes the effect of ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION - * and changes the preferred location to none. - * - ::CU_MEM_ADVISE_SET_ACCESSED_BY: This advice implies that the data will be accessed by \p device. - * Passing in ::CU_DEVICE_CPU for \p device will set the advice for the CPU. If \p device is a GPU, then - * the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero. - * This advice does not cause data migration and has no impact on the location of the data per se. Instead, - * it causes the data to always be mapped in the specified processor's page tables, as long as the - * location of the data permits a mapping to be established. If the data gets migrated for any reason, - * the mappings are updated accordingly. - * This advice is recommended in scenarios where data locality is not important, but avoiding faults is. - * Consider for example a system containing multiple GPUs with peer-to-peer access enabled, where the - * data located on one GPU is occasionally accessed by peer GPUs. In such scenarios, migrating data - * over to the other GPUs is not as important because the accesses are infrequent and the overhead of - * migration may be too high. But preventing faults can still help improve performance, and so having - * a mapping set up in advance is useful. Note that on CPU access of this data, the data may be migrated - * to host memory because the CPU typically cannot access device memory directly. Any GPU that had the - * ::CU_MEM_ADVISE_SET_ACCESSED_BY flag set for this data will now have its mapping updated to point to the - * page in host memory. - * If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the - * policies associated with that advice will override the policies of this advice. Additionally, if the - * preferred location of this memory region or any subset of it is also \p device, then the policies - * associated with ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION will override the policies of this advice. - * - ::CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of ::CU_MEM_ADVISE_SET_ACCESSED_BY. Any mappings to - * the data from \p device may be removed at any time causing accesses to result in non-fatal page faults. + * - ::CU_MEM_ADVISE_SET_READ_MOSTLY: This implies that the data is mostly going + * to be read from and only occasionally written to. Any read accesses from any + * processor to this region will create a read-only copy of at least the + * accessed pages in that processor's memory. Additionally, if + * ::cuMemPrefetchAsync is called on this region, it will create a read-only + * copy of the data on the destination processor. If any processor writes to + * this region, all copies of the corresponding page will be invalidated except + * for the one where the write occurred. The \p device argument is ignored for + * this advice. Note that for a page to be read-duplicated, the accessing + * processor must either be the CPU or a GPU that has a non-zero value for the + * device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Also, if a + * context is created on a device that does not have the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS set, then read-duplication + * will not occur until all such contexts are destroyed. If the memory region + * refers to valid system-allocated pageable memory, then the accessing device + * must have a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS for a read-only copy to be + * created on that device. Note however that if the accessing device also has a + * non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then + * setting this advice will not create a read-only copy when that device + * accesses this memory region. + * + * - ::CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of + * ::CU_MEM_ADVISE_SET_READ_MOSTLY and also prevents the Unified Memory driver + * from attempting heuristic read-duplication on the memory range. Any + * read-duplicated copies of the data will be collapsed into a single copy. The + * location for the collapsed copy will be the preferred location if the page + * has a preferred location and one of the read-duplicated copies was resident + * at that location. Otherwise, the location chosen is arbitrary. + * + * - ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred + * location for the data to be the memory belonging to \p device. Passing in + * CU_DEVICE_CPU for \p device sets the preferred location as host memory. If \p + * device is a GPU, then it must have a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Setting the preferred + * location does not cause data to migrate to that location immediately. + * Instead, it guides the migration policy when a fault occurs on that memory + * region. If the data is already in its preferred location and the faulting + * processor can establish a mapping without requiring the data to be migrated, + * then data migration will be avoided. On the other hand, if the data is not in + * its preferred location or if a direct mapping cannot be established, then it + * will be migrated to the processor accessing it. It is important to note that + * setting the preferred location does not prevent data prefetching done using + * ::cuMemPrefetchAsync. Having a preferred location can override the page + * thrash detection and resolution logic in the Unified Memory driver. Normally, + * if a page is detected to be constantly thrashing between for example host and + * device memory, the page may eventually be pinned to host memory by the + * Unified Memory driver. But if the preferred location is set as device memory, + * then the page will continue to thrash indefinitely. If + * ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any + * subset of it, then the policies associated with that advice will override the + * policies of this advice, unless read accesses from \p device will not result + * in a read-only copy being created on that device as outlined in description + * for the advice ::CU_MEM_ADVISE_SET_READ_MOSTLY. If the memory region refers + * to valid system-allocated pageable memory, then \p device must have a + * non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has + * a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this + * call has no effect. Note however that this behavior may change in the future. + * + * - ::CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: Undoes the effect of + * ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION and changes the preferred location to + * none. + * + * - ::CU_MEM_ADVISE_SET_ACCESSED_BY: This advice implies that the data will be + * accessed by \p device. Passing in ::CU_DEVICE_CPU for \p device will set the + * advice for the CPU. If \p device is a GPU, then the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero. This advice + * does not cause data migration and has no impact on the location of the data + * per se. Instead, it causes the data to always be mapped in the specified + * processor's page tables, as long as the location of the data permits a + * mapping to be established. If the data gets migrated for any reason, the + * mappings are updated accordingly. This advice is recommended in scenarios + * where data locality is not important, but avoiding faults is. Consider for + * example a system containing multiple GPUs with peer-to-peer access enabled, + * where the data located on one GPU is occasionally accessed by peer GPUs. In + * such scenarios, migrating data over to the other GPUs is not as important + * because the accesses are infrequent and the overhead of migration may be too + * high. But preventing faults can still help improve performance, and so having + * a mapping set up in advance is useful. Note that on CPU access of this data, + * the data may be migrated to host memory because the CPU typically cannot + * access device memory directly. Any GPU that had the + * ::CU_MEM_ADVISE_SET_ACCESSED_BY flag set for this data will now have its + * mapping updated to point to the page in host memory. If + * ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any + * subset of it, then the policies associated with that advice will override the + * policies of this advice. Additionally, if the preferred location of this + * memory region or any subset of it is also \p device, then the policies + * associated with ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION will override the + * policies of this advice. If the memory region refers to valid + * system-allocated pageable memory, then \p device must have a non-zero value + * for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. + * Additionally, if \p device has a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this + * call has no effect. + * + * - ::CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of + * ::CU_MEM_ADVISE_SET_ACCESSED_BY. Any mappings to the data from \p device may + * be removed at any time causing accesses to result in non-fatal page faults. + * If the memory region refers to valid system-allocated pageable memory, then + * \p device must have a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has + * a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this + * call has no effect. * * \param devPtr - Pointer to memory to set the advice for * \param count - Size in bytes of the memory range @@ -7716,46 +9082,59 @@ CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice d * \note_null_stream * * \sa ::cuMemcpy, ::cuMemcpyPeer, ::cuMemcpyAsync, - * ::cuMemcpy3DPeerAsync, ::cuMemPrefetchAsync + * ::cuMemcpy3DPeerAsync, ::cuMemPrefetchAsync, + * ::cudaMemAdvise */ -CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUdevice device); +CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, + CUmem_advise advice, CUdevice device); /** * \brief Query an attribute of a given memory range - * - * Query an attribute about the memory range starting at \p devPtr with a size of \p count bytes. The - * memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via + * + * Query an attribute about the memory range starting at \p devPtr with a size + * of \p count bytes. The memory range must refer to managed memory allocated + * via ::cuMemAllocManaged or declared via * __managed__ variables. * * The \p attribute parameter can take the following values: - * - ::CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: If this attribute is specified, \p data will be interpreted - * as a 32-bit integer, and \p dataSize must be 4. The result returned will be 1 if all pages in the given - * memory range have read-duplication enabled, or 0 otherwise. - * - ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: If this attribute is specified, \p data will be - * interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be a GPU device - * id if all pages in the memory range have that GPU as their preferred location, or it will be CU_DEVICE_CPU - * if all pages in the memory range have the CPU as their preferred location, or it will be CU_DEVICE_INVALID - * if either all the pages don't have the same preferred location or some of the pages don't have a - * preferred location at all. Note that the actual location of the pages in the memory range at the time of - * the query may be different from the preferred location. - * - ::CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: If this attribute is specified, \p data will be interpreted - * as an array of 32-bit integers, and \p dataSize must be a non-zero multiple of 4. The result returned - * will be a list of device ids that had ::CU_MEM_ADVISE_SET_ACCESSED_BY set for that entire memory range. - * If any device does not have that advice set for the entire memory range, that device will not be included. - * If \p data is larger than the number of devices that have that advice set for that memory range, - * CU_DEVICE_INVALID will be returned in all the extra space provided. For ex., if \p dataSize is 12 - * (i.e. \p data has 3 elements) and only device 0 has the advice set, then the result returned will be - * { 0, CU_DEVICE_INVALID, CU_DEVICE_INVALID }. If \p data is smaller than the number of devices that have - * that advice set, then only as many devices will be returned as can fit in the array. There is no - * guarantee on which specific devices will be returned, however. - * - ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: If this attribute is specified, \p data will be - * interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be the last location - * to which all pages in the memory range were prefetched explicitly via ::cuMemPrefetchAsync. This will either be - * a GPU id or CU_DEVICE_CPU depending on whether the last location for prefetch was a GPU or the CPU - * respectively. If any page in the memory range was never explicitly prefetched or if all pages were not - * prefetched to the same location, CU_DEVICE_INVALID will be returned. Note that this simply returns the - * last location that the applicaton requested to prefetch the memory range to. It gives no indication as to - * whether the prefetch operation to that location has completed or even begun. + * - ::CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: If this attribute is specified, \p + * data will be interpreted as a 32-bit integer, and \p dataSize must be 4. The + * result returned will be 1 if all pages in the given memory range have + * read-duplication enabled, or 0 otherwise. + * - ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: If this attribute is + * specified, \p data will be interpreted as a 32-bit integer, and \p dataSize + * must be 4. The result returned will be a GPU device id if all pages in the + * memory range have that GPU as their preferred location, or it will be + * CU_DEVICE_CPU if all pages in the memory range have the CPU as their + * preferred location, or it will be CU_DEVICE_INVALID if either all the pages + * don't have the same preferred location or some of the pages don't have a + * preferred location at all. Note that the actual location of the pages in the + * memory range at the time of the query may be different from the preferred + * location. + * - ::CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: If this attribute is specified, \p + * data will be interpreted as an array of 32-bit integers, and \p dataSize must + * be a non-zero multiple of 4. The result returned will be a list of device ids + * that had ::CU_MEM_ADVISE_SET_ACCESSED_BY set for that entire memory range. If + * any device does not have that advice set for the entire memory range, that + * device will not be included. If \p data is larger than the number of devices + * that have that advice set for that memory range, CU_DEVICE_INVALID will be + * returned in all the extra space provided. For ex., if \p dataSize is 12 (i.e. + * \p data has 3 elements) and only device 0 has the advice set, then the result + * returned will be { 0, CU_DEVICE_INVALID, CU_DEVICE_INVALID }. If \p data is + * smaller than the number of devices that have that advice set, then only as + * many devices will be returned as can fit in the array. There is no guarantee + * on which specific devices will be returned, however. + * - ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: If this attribute is + * specified, \p data will be interpreted as a 32-bit integer, and \p dataSize + * must be 4. The result returned will be the last location to which all pages + * in the memory range were prefetched explicitly via ::cuMemPrefetchAsync. This + * will either be a GPU id or CU_DEVICE_CPU depending on whether the last + * location for prefetch was a GPU or the CPU respectively. If any page in the + * memory range was never explicitly prefetched or if all pages were not + * prefetched to the same location, CU_DEVICE_INVALID will be returned. Note + * that this simply returns the last location that the applicaton requested to + * prefetch the memory range to. It gives no indication as to whether the + * prefetch operation to that location has completed or even begun. * * \param data - A pointers to a memory location where the result * of each attribute query will be written to. @@ -7773,21 +9152,26 @@ CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advi * \note_null_stream * * \sa ::cuMemRangeGetAttributes, ::cuMemPrefetchAsync, - * ::cuMemAdvise + * ::cuMemAdvise, + * ::cudaMemRangeGetAttribute */ -CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, CUmem_range_attribute attribute, CUdeviceptr devPtr, size_t count); +CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, + CUmem_range_attribute attribute, + CUdeviceptr devPtr, size_t count); /** * \brief Query attributes of a given memory range. * - * Query attributes of the memory range starting at \p devPtr with a size of \p count bytes. The - * memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via - * __managed__ variables. The \p attributes array will be interpreted to have \p numAttributes - * entries. The \p dataSizes array will also be interpreted to have \p numAttributes entries. - * The results of the query will be stored in \p data. + * Query attributes of the memory range starting at \p devPtr with a size of \p + * count bytes. The memory range must refer to managed memory allocated via + * ::cuMemAllocManaged or declared via + * __managed__ variables. The \p attributes array will be interpreted to have \p + * numAttributes entries. The \p dataSizes array will also be interpreted to + * have \p numAttributes entries. The results of the query will be stored in \p + * data. * - * The list of supported attributes are given below. Please refer to ::cuMemRangeGetAttribute for - * attribute descriptions and restrictions. + * The list of supported attributes are given below. Please refer to + * ::cuMemRangeGetAttribute for attribute descriptions and restrictions. * * - ::CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY * - ::CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION @@ -7795,13 +9179,12 @@ CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, CUmem_range * - ::CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION * * \param data - A two-dimensional array containing pointers to memory - * locations where the result of each attribute query will be written to. - * \param dataSizes - Array containing the sizes of each result - * \param attributes - An array of attributes to query - * (numAttributes and the number of attributes in this array should match) - * \param numAttributes - Number of attributes to query - * \param devPtr - Start of the range to query - * \param count - Size of the range to query + * locations where the result of each attribute query + * will be written to. \param dataSizes - Array containing the sizes of each + * result \param attributes - An array of attributes to query (numAttributes + * and the number of attributes in this array should match) \param numAttributes + * - Number of attributes to query \param devPtr - Start of the range to + * query \param count - Size of the range to query * * \return * ::CUDA_SUCCESS, @@ -7812,9 +9195,13 @@ CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, CUmem_range * \notefnerr * * \sa ::cuMemRangeGetAttribute, ::cuMemAdvise - * ::cuMemPrefetchAsync + * ::cuMemPrefetchAsync, + * ::cudaMemRangeGetAttributes */ -CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, CUmem_range_attribute *attributes, size_t numAttributes, 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); #endif /* __CUDA_API_VERSION >= 8000 */ #if __CUDA_API_VERSION >= 6000 @@ -7826,18 +9213,19 @@ CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, CUmem_r * - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: * * A boolean attribute that can either be set (1) or unset (0). When set, - * the region of memory that \p ptr points to is guaranteed to always synchronize - * memory operations that are synchronous. If there are some previously initiated - * synchronous memory operations that are pending when this attribute is set, the - * function does not return until those memory operations are complete. - * See further documentation in the section titled "API synchronization behavior" - * to learn more about cases when synchronous memory operations can - * exhibit asynchronous behavior. - * \p value will be considered as a pointer to an unsigned integer to which this attribute is to be set. + * the region of memory that \p ptr points to is guaranteed to always + * synchronize memory operations that are synchronous. If there are some + * previously initiated synchronous memory operations that are pending when this + * attribute is set, the function does not return until those memory operations + * are complete. See further documentation in the section titled "API + * synchronization behavior" to learn more about cases when synchronous memory + * operations can exhibit asynchronous behavior. \p value will be considered as + * a pointer to an unsigned integer to which this attribute is to be set. * * \param value - Pointer to memory containing the value to be set * \param attribute - Pointer attribute to set - * \param ptr - Pointer to a memory region allocated using CUDA memory allocation APIs + * \param ptr - Pointer to a memory region allocated using CUDA memory + * allocation APIs * * \return * ::CUDA_SUCCESS, @@ -7858,14 +9246,17 @@ CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, CUmem_r * ::cuMemHostRegister, * ::cuMemHostUnregister */ -CUresult CUDAAPI cuPointerSetAttribute(const void *value, CUpointer_attribute attribute, CUdeviceptr ptr); +CUresult CUDAAPI cuPointerSetAttribute(const void *value, + CUpointer_attribute attribute, + CUdeviceptr ptr); #endif /* __CUDA_API_VERSION >= 6000 */ #if __CUDA_API_VERSION >= 7000 /** * \brief Returns information about a pointer. * - * The supported attributes are (refer to ::cuPointerGetAttribute for attribute descriptions and restrictions): + * The supported attributes are (refer to ::cuPointerGetAttribute for attribute + * descriptions and restrictions): * * - ::CU_POINTER_ATTRIBUTE_CONTEXT * - ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE @@ -7874,20 +9265,22 @@ CUresult CUDAAPI cuPointerSetAttribute(const void *value, CUpointer_attribute at * - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS * - ::CU_POINTER_ATTRIBUTE_BUFFER_ID * - ::CU_POINTER_ATTRIBUTE_IS_MANAGED + * - ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL * * \param numAttributes - Number of attributes to query * \param attributes - An array of attributes to query - * (numAttributes and the number of attributes in this array should match) - * \param data - A two-dimensional array containing pointers to memory - * locations where the result of each attribute query will be written to. - * \param ptr - Pointer to query + * (numAttributes and the number of attributes in this + * array should match) \param data - A two-dimensional array containing + * pointers to memory locations where the result of each attribute query will be + * written to. \param ptr - Pointer to query * - * Unlike ::cuPointerGetAttribute, this function will not return an error when the \p ptr - * encountered is not a valid CUDA pointer. Instead, the attributes are assigned default NULL values - * and CUDA_SUCCESS is returned. + * Unlike ::cuPointerGetAttribute, this function will not return an error when + * the \p ptr encountered is not a valid CUDA pointer. Instead, the attributes + * are assigned default NULL values and CUDA_SUCCESS is returned. * - * If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses UVA - * (Unified Virtual Addressing), ::CUDA_ERROR_INVALID_CONTEXT is returned. + * If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext + * which uses UVA (Unified Virtual Addressing), ::CUDA_ERROR_INVALID_CONTEXT is + * returned. * * \return * ::CUDA_SUCCESS, @@ -7897,10 +9290,14 @@ CUresult CUDAAPI cuPointerSetAttribute(const void *value, CUpointer_attribute at * ::CUDA_ERROR_INVALID_DEVICE * \notefnerr * - * \sa ::cuPointerGetAttribute, - * ::cuPointerSetAttribute + * \sa + * ::cuPointerGetAttribute, + * ::cuPointerSetAttribute, + * ::cudaPointerGetAttributes */ -CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attribute *attributes, void **data, CUdeviceptr ptr); +CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, + CUpointer_attribute *attributes, + void **data, CUdeviceptr ptr); #endif /* __CUDA_API_VERSION >= 7000 */ /** @} */ /* END CUDA_UNIFIED */ @@ -7923,9 +9320,10 @@ CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, CUpointer_at * Creates a stream and returns a handle in \p phStream. The \p Flags argument * determines behaviors of the stream. Valid values for \p Flags are: * - ::CU_STREAM_DEFAULT: Default stream creation flag. - * - ::CU_STREAM_NON_BLOCKING: Specifies that work running in the created - * stream may run concurrently with work in stream 0 (the NULL stream), and that - * the created stream should perform no implicit synchronization with stream 0. + * - ::CU_STREAM_NON_BLOCKING: Specifies that work running in the created + * stream may run concurrently with work in stream 0 (the NULL stream), and + * that the created stream should perform no implicit synchronization with + * stream 0. * * \param phStream - Returned newly created stream * \param Flags - Parameters for stream creation @@ -7946,29 +9344,32 @@ CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, CUpointer_at * ::cuStreamWaitEvent, * ::cuStreamQuery, * ::cuStreamSynchronize, - * ::cuStreamAddCallback + * ::cuStreamAddCallback, + * ::cudaStreamCreate, + * ::cudaStreamCreateWithFlags */ CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags); /** * \brief Create a stream with the given priority * - * Creates a stream with the specified priority and returns a handle in \p phStream. - * This API alters the scheduler priority of work in the stream. Work in a higher - * priority stream may preempt work already executing in a low priority stream. + * Creates a stream with the specified priority and returns a handle in \p + * phStream. This API alters the scheduler priority of work in the stream. Work + * in a higher priority stream may preempt work already executing in a low + * priority stream. * - * \p priority follows a convention where lower numbers represent higher priorities. - * '0' represents default priority. The range of meaningful numerical priorities can - * be queried using ::cuCtxGetStreamPriorityRange. If the specified priority is - * outside the numerical range returned by ::cuCtxGetStreamPriorityRange, - * it will automatically be clamped to the lowest or the highest number in the range. + * \p priority follows a convention where lower numbers represent higher + * priorities. '0' represents default priority. The range of meaningful + * numerical priorities can be queried using ::cuCtxGetStreamPriorityRange. If + * the specified priority is outside the numerical range returned by + * ::cuCtxGetStreamPriorityRange, it will automatically be clamped to the lowest + * or the highest number in the range. * * \param phStream - Returned newly created stream - * \param flags - Flags for stream creation. See ::cuStreamCreate for a list of - * valid flags - * \param priority - Stream priority. Lower numbers represent higher priorities. - * See ::cuCtxGetStreamPriorityRange for more information about - * meaningful stream priorities that can be passed. + * \param flags - Flags for stream creation. See ::cuStreamCreate for a + * list of valid flags \param priority - Stream priority. Lower numbers + * represent higher priorities. See ::cuCtxGetStreamPriorityRange for more + * information about meaningful stream priorities that can be passed. * * \return * ::CUDA_SUCCESS, @@ -7979,12 +9380,12 @@ CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags); * ::CUDA_ERROR_OUT_OF_MEMORY * \notefnerr * - * \note Stream priorities are supported only on Quadro and Tesla GPUs + * \note Stream priorities are supported only on GPUs * with compute capability 3.5 or higher. * * \note In the current implementation, only compute kernels launched in - * priority streams are affected by the stream's priority. Stream priorities have - * no effect on host-to-device and device-to-host memory operations. + * priority streams are affected by the stream's priority. Stream priorities + * have no effect on host-to-device and device-to-host memory operations. * * \sa ::cuStreamDestroy, * ::cuStreamCreate, @@ -7994,23 +9395,25 @@ CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags); * ::cuStreamWaitEvent, * ::cuStreamQuery, * ::cuStreamSynchronize, - * ::cuStreamAddCallback + * ::cuStreamAddCallback, + * ::cudaStreamCreateWithPriority */ -CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, unsigned int flags, int priority); - +CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, + unsigned int flags, int priority); /** * \brief Query the priority of a given stream * - * Query the priority of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority - * and return the priority in \p priority. Note that if the stream was created with a - * priority outside the numerical range returned by ::cuCtxGetStreamPriorityRange, - * this function returns the clamped priority. - * See ::cuStreamCreateWithPriority for details about priority clamping. + * Query the priority of a stream created using ::cuStreamCreate or + * ::cuStreamCreateWithPriority and return the priority in \p priority. Note + * that if the stream was created with a priority outside the numerical range + * returned by ::cuCtxGetStreamPriorityRange, this function returns the clamped + * priority. See ::cuStreamCreateWithPriority for details about priority + * clamping. * * \param hStream - Handle to the stream to be queried - * \param priority - Pointer to a signed integer in which the stream's priority is returned - * \return + * \param priority - Pointer to a signed integer in which the stream's + * priority is returned \return * ::CUDA_SUCCESS, * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, @@ -8024,22 +9427,22 @@ CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, unsigned int fla * ::cuStreamCreate, * ::cuStreamCreateWithPriority, * ::cuCtxGetStreamPriorityRange, - * ::cuStreamGetFlags + * ::cuStreamGetFlags, + * ::cudaStreamGetPriority */ CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority); /** * \brief Query the flags of a given stream * - * Query the flags of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority - * and return the flags in \p flags. + * Query the flags of a stream created using ::cuStreamCreate or + * ::cuStreamCreateWithPriority and return the flags in \p flags. * * \param hStream - Handle to the stream to be queried - * \param flags - Pointer to an unsigned integer in which the stream's flags are returned - * The value returned in \p flags is a logical 'OR' of all flags that - * were used while creating this stream. See ::cuStreamCreate for the list - * of valid flags - * \return + * \param flags - Pointer to an unsigned integer in which the stream's + * flags are returned The value returned in \p flags is a logical 'OR' of all + * flags that were used while creating this stream. See ::cuStreamCreate for the + * list of valid flags \return * ::CUDA_SUCCESS, * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, @@ -8051,28 +9454,70 @@ CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority); * * \sa ::cuStreamDestroy, * ::cuStreamCreate, - * ::cuStreamGetPriority + * ::cuStreamGetPriority, + * ::cudaStreamGetFlags */ CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags); +#if __CUDA_API_VERSION >= 9020 /** - * \brief Make a compute stream wait on an event + * \brief Query the context associated with a stream + * + * Returns the CUDA context that the stream is associated with. + * + * The stream handle \p hStream can refer to any of the following: + * <ul> + * <li>a stream created via any of the CUDA driver APIs such as + * ::cuStreamCreate and ::cuStreamCreateWithPriority, or their runtime API + * equivalents such as + * ::cudaStreamCreate, ::cudaStreamCreateWithFlags and + * ::cudaStreamCreateWithPriority. The returned context is the context that was + * active in the calling thread when the stream was created. Passing an invalid + * handle will result in undefined behavior.</li> <li>any of the special streams + * such as the NULL stream, ::CU_STREAM_LEGACY and + * ::CU_STREAM_PER_THREAD. The runtime API equivalents of these are also + * accepted, which are NULL, ::cudaStreamLegacy and ::cudaStreamPerThread + * respectively. Specifying any of the special handles will return the context + * current to the calling thread. If no context is current to the calling + * thread, + * ::CUDA_ERROR_INVALID_CONTEXT is returned.</li> + * </ul> + * + * \param hStream - Handle to the stream to be queried + * \param pctx - Returned context associated with the stream * - * Makes all future work submitted to \p hStream wait until \p hEvent - * reports completion before beginning execution. This synchronization - * will be performed efficiently on the device. The event \p hEvent may - * be from a different context than \p hStream, in which case this function - * will perform cross-device synchronization. + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_HANDLE, + * \notefnerr * - * The stream \p hStream will wait only for the completion of the most recent - * host call to ::cuEventRecord() on \p hEvent. Once this call has returned, - * any functions (including ::cuEventRecord() and ::cuEventDestroy()) may be - * called on \p hEvent again, and subsequent calls will not have any - * effect on \p hStream. + * \sa ::cuStreamDestroy, + * ::cuStreamCreateWithPriority, + * ::cuStreamGetPriority, + * ::cuStreamGetFlags, + * ::cuStreamWaitEvent, + * ::cuStreamQuery, + * ::cuStreamSynchronize, + * ::cuStreamAddCallback, + * ::cudaStreamCreate, + * ::cudaStreamCreateWithFlags + */ +CUresult CUDAAPI cuStreamGetCtx(CUstream hStream, CUcontext *pctx); + +#endif /* __CUDA_API_VERSION >= 9020 */ + +/** + * \brief Make a compute stream wait on an event * - * If ::cuEventRecord() has not been called on \p hEvent, this call acts as if - * the record has already completed, and so is a functional no-op. + * Makes all future work submitted to \p hStream wait for all work captured in + * \p hEvent. See ::cuEventRecord() for details on what is captured by an + * event. The synchronization will be performed efficiently on the device when + * applicable. \p hEvent may be from a different context or device than \p + * hStream. * * \param hStream - Stream to wait * \param hEvent - Event to wait on (may not be NULL) @@ -8092,15 +9537,23 @@ CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags); * ::cuStreamQuery, * ::cuStreamSynchronize, * ::cuStreamAddCallback, - * ::cuStreamDestroy + * ::cuStreamDestroy, + * ::cudaStreamWaitEvent */ -CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags); +CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, + unsigned int Flags); /** * \brief Add a callback to a compute stream * + * \note This function is slated for eventual deprecation and removal. If + * you do not require the callback to execute in case of a device error, + * consider using ::cuLaunchHostFunc. Additionally, this function is not + * supported with ::cuStreamBeginCapture and ::cuStreamEndCapture, unlike + * ::cuLaunchHostFunc. + * * Adds a callback to be called on the host after all currently enqueued - * items in the stream have completed. For each + * items in the stream have completed. For each * cuStreamAddCallback call, the callback will be executed exactly once. * The callback will block later work in the stream until it is finished. * @@ -8114,11 +9567,6 @@ CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned in * that are not mandated to run earlier. Callbacks without a mandated order * (in independent streams) execute in undefined order and may be serialized. * - * This API requires compute capability 1.1 or greater. See - * ::cuDeviceGetAttribute or ::cuDeviceGetProperties to query compute - * capability. Attempting to use this API with earlier compute versions will - * return ::CUDA_ERROR_NOT_SUPPORTED. - * * For the purposes of Unified Memory, callback execution makes a number of * guarantees: * <ul> @@ -8130,10 +9578,11 @@ CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned in * the callback. It thus synchronizes streams which have been "joined" * prior to the callback.</li> * <li>Adding device work to any stream does not have the effect of making - * the stream active until all preceding callbacks have executed. Thus, for + * the stream active until all preceding host functions and stream callbacks + * have executed. Thus, for * example, a callback might use global attached memory even if work has - * been added to another stream, if it has been properly ordered with an - * event.</li> + * been added to another stream, if the work has been ordered behind the + * callback with an event.</li> * <li>Completion of a callback does not cause a stream to become * active except as described above. The callback stream will remain idle * if no device work follows the callback, and will remain idle across @@ -8143,9 +9592,9 @@ CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned in * </ul> * * \param hStream - Stream to add callback to - * \param callback - The function to call once preceding stream operations are complete - * \param userData - User specified data to be passed to the callback function - * \param flags - Reserved for future use, must be 0 + * \param callback - The function to call once preceding stream operations are + * complete \param userData - User specified data to be passed to the callback + * function \param flags - Reserved for future use, must be 0 * * \return * ::CUDA_SUCCESS, @@ -8163,9 +9612,235 @@ CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned in * ::cuStreamWaitEvent, * ::cuStreamDestroy, * ::cuMemAllocManaged, - * ::cuStreamAttachMemAsync + * ::cuStreamAttachMemAsync, + * ::cuStreamLaunchHostFunc, + * ::cudaStreamAddCallback */ -CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags); +CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, + CUstreamCallback callback, void *userData, + unsigned int flags); + +#if __CUDA_API_VERSION >= 10000 + +/** + * \brief Begins graph capture on a stream + * + * Begin graph capture on \p hStream. When a stream is in capture mode, all + * operations pushed into the stream will not be executed, but will instead be + * captured into a graph, which will be returned via ::cuStreamEndCapture. + * Capture may not be initiated if \p stream is CU_STREAM_LEGACY. Capture must + * be ended on the same stream in which it was initiated, and it may only be + * initiated if the stream is not already in capture mode. The capture mode may + * be queried via ::cuStreamIsCapturing. A unique id representing the capture + * sequence may be queried via ::cuStreamGetCaptureInfo. + * + * If \p mode is not ::CU_STREAM_CAPTURE_MODE_RELAXED, ::cuStreamEndCapture must + * be called on this stream from the same thread. + * + * \param hStream - Stream in which to initiate capture + * \param mode - Controls the interaction of this capture sequence with other + * API calls that are potentially unsafe. For more details see + * ::cuThreadExchangeStreamCaptureMode. + * + * \note Kernels captured using this API must not use texture and surface + * references. Reading or writing through any texture or surface reference is + * undefined behavior. This restriction does not apply to texture and surface + * objects. + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \notefnerr + * + * \sa + * ::cuStreamCreate, + * ::cuStreamIsCapturing, + * ::cuStreamEndCapture, + * ::cuThreadExchangeStreamCaptureMode + */ +CUresult CUDAAPI cuStreamBeginCapture(CUstream hStream, + CUstreamCaptureMode mode); + +#endif /* __CUDA_API_VERSION >= 10000 */ +#if __CUDA_API_VERSION >= 10010 + +/** + * \brief Swaps the stream capture interaction mode for a thread + * + * Sets the calling thread's stream capture interaction mode to the value + contained + * in \p *mode, and overwrites \p *mode with the previous mode for the thread. + To + * facilitate deterministic behavior across function or module boundaries, + callers + * are encouraged to use this API in a push-pop fashion: \code + CUstreamCaptureMode mode = desiredMode; + cuThreadExchangeStreamCaptureMode(&mode); + ... + cuThreadExchangeStreamCaptureMode(&mode); // restore previous mode + * \endcode + * + * During stream capture (see ::cuStreamBeginCapture), some actions, such as a + call + * to ::cudaMalloc, may be unsafe. In the case of ::cudaMalloc, the operation is + * not enqueued asynchronously to a stream, and is not observed by stream + capture. + * Therefore, if the sequence of operations captured via ::cuStreamBeginCapture + * depended on the allocation being replayed whenever the graph is launched, the + * captured graph would be invalid. + * + * Therefore, stream capture places restrictions on API calls that can be made + within + * or concurrently to a ::cuStreamBeginCapture-::cuStreamEndCapture sequence. + This + * behavior can be controlled via this API and flags to ::cuStreamBeginCapture. + * + * A thread's mode is one of the following: + * - \p CU_STREAM_CAPTURE_MODE_GLOBAL: This is the default mode. If the local + thread has + * an ongoing capture sequence that was not initiated with + * \p CU_STREAM_CAPTURE_MODE_RELAXED at \p cuStreamBeginCapture, or if any + other thread + * has a concurrent capture sequence initiated with \p + CU_STREAM_CAPTURE_MODE_GLOBAL, + * this thread is prohibited from potentially unsafe API calls. + * - \p CU_STREAM_CAPTURE_MODE_THREAD_LOCAL: If the local thread has an ongoing + capture + * sequence not initiated with \p CU_STREAM_CAPTURE_MODE_RELAXED, it is + prohibited + * from potentially unsafe API calls. Concurrent capture sequences in other + threads + * are ignored. + * - \p CU_STREAM_CAPTURE_MODE_RELAXED: The local thread is not prohibited from + potentially + * unsafe API calls. Note that the thread is still prohibited from API calls + which + * necessarily conflict with stream capture, for example, attempting + ::cuEventQuery + * on an event that was last recorded inside a capture sequence. + * + * \param mode - Pointer to mode value to swap with the current mode + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \notefnerr + * + * \sa + * ::cuStreamBeginCapture + */ +CUresult CUDAAPI cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode *mode); + +#endif /* __CUDA_API_VERSION >= 10010 */ +#if __CUDA_API_VERSION >= 10000 + +/** + * \brief Ends capture on a stream, returning the captured graph + * + * End capture on \p hStream, returning the captured graph via \p phGraph. + * Capture must have been initiated on \p hStream via a call to + * ::cuStreamBeginCapture. If capture was invalidated, due to a violation of the + * rules of stream capture, then a NULL graph will be returned. + * + * If the \p mode argument to ::cuStreamBeginCapture was not + * ::CU_STREAM_CAPTURE_MODE_RELAXED, this call must be from the same thread as + * ::cuStreamBeginCapture. + * + * \param hStream - Stream to query + * \param phGraph - The captured graph + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD + * \notefnerr + * + * \sa + * ::cuStreamCreate, + * ::cuStreamBeginCapture, + * ::cuStreamIsCapturing + */ +CUresult CUDAAPI cuStreamEndCapture(CUstream hStream, CUgraph *phGraph); + +/** + * \brief Returns a stream's capture status + * + * Return the capture status of \p hStream via \p captureStatus. After a + * successful call, \p *captureStatus will contain one of the following: + * - ::CU_STREAM_CAPTURE_STATUS_NONE: The stream is not capturing. + * - ::CU_STREAM_CAPTURE_STATUS_ACTIVE: The stream is capturing. + * - ::CU_STREAM_CAPTURE_STATUS_INVALIDATED: The stream was capturing but an + * error has invalidated the capture sequence. The capture sequence must be + * terminated with ::cuStreamEndCapture on the stream where it was initiated in + * order to continue using \p hStream. + * + * Note that, if this is called on ::CU_STREAM_LEGACY (the "null stream") while + * a blocking stream in the same context is capturing, it will return + * ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT and \p *captureStatus is unspecified + * after the call. The blocking stream capture is not invalidated. + * + * When a blocking stream is capturing, the legacy stream is in an + * unusable state until the blocking stream capture is terminated. The legacy + * stream is not supported for stream capture, but attempted use would have an + * implicit dependency on the capturing stream(s). + * + * \param hStream - Stream to query + * \param captureStatus - Returns the stream's capture status + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT + * \notefnerr + * + * \sa + * ::cuStreamCreate, + * ::cuStreamBeginCapture, + * ::cuStreamEndCapture + */ +CUresult CUDAAPI cuStreamIsCapturing(CUstream hStream, + CUstreamCaptureStatus *captureStatus); + +#endif /* __CUDA_API_VERSION >= 10000 */ + +#if __CUDA_API_VERSION >= 10010 + +/** + * \brief Query capture status of a stream + * + * Query the capture status of a stream and and get an id for + * the capture sequence, which is unique over the lifetime of the process. + * + * If called on ::CU_STREAM_LEGACY (the "null stream") while a stream not + * created with ::CU_STREAM_NON_BLOCKING is capturing, returns + * ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT. + * + * A valid id is returned only if both of the following are true: + * - the call returns CUDA_SUCCESS + * - captureStatus is set to ::CU_STREAM_CAPTURE_STATUS_ACTIVE + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT + * \notefnerr + * + * \sa + * ::cuStreamBeginCapture, + * ::cuStreamIsCapturing + */ +CUresult CUDAAPI cuStreamGetCaptureInfo(CUstream hStream, + CUstreamCaptureStatus *captureStatus, + cuuint64_t *id); + +#endif /* __CUDA_API_VERSION >= 10010 */ #if __CUDA_API_VERSION >= 6000 @@ -8178,53 +9853,66 @@ CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback * only take effect when, previous work in stream has completed. Any * previous association is automatically replaced. * - * \p dptr must point to an address within managed memory space declared - * using the __managed__ keyword or allocated with ::cuMemAllocManaged. + * \p dptr must point to one of the following types of memories: + * - managed memory declared using the __managed__ keyword or allocated with + * ::cuMemAllocManaged. + * - a valid host-accessible region of system-allocated pageable memory. This + * type of memory may only be specified if the device associated with the + * stream reports a non-zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. * - * \p length must be zero, to indicate that the entire allocation's - * stream association is being changed. Currently, it's not possible - * to change stream association for a portion of an allocation. + * For managed allocations, \p length must be either zero or the entire + * allocation's size. Both indicate that the entire allocation's stream + * association is being changed. Currently, it is not possible to change stream + * association for a portion of a managed allocation. + * + * For pageable host allocations, \p length must be non-zero. * * The stream association is specified using \p flags which must be * one of ::CUmemAttach_flags. * If the ::CU_MEM_ATTACH_GLOBAL flag is specified, the memory can be accessed * by any stream on any device. * If the ::CU_MEM_ATTACH_HOST flag is specified, the program makes a guarantee - * that it won't access the memory on the device from any stream on a device that - * has a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. - * If the ::CU_MEM_ATTACH_SINGLE flag is specified and \p hStream is associated with - * a device that has a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, - * the program makes a guarantee that it will only access the memory on the device - * from \p hStream. It is illegal to attach singly to the NULL stream, because the - * NULL stream is a virtual global stream and not a specific stream. An error will - * be returned in this case. + * that it won't access the memory on the device from any stream on a device + * that has a zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If the + * ::CU_MEM_ATTACH_SINGLE flag is specified and \p hStream is associated with a + * device that has a zero value for the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, the program makes a + * guarantee that it will only access the memory on the device from \p hStream. + * It is illegal to attach singly to the NULL stream, because the NULL stream is + * a virtual global stream and not a specific stream. An error will be returned + * in this case. * - * When memory is associated with a single stream, the Unified Memory system will - * allow CPU access to this memory region so long as all operations in \p hStream - * have completed, regardless of whether other streams are active. In effect, - * this constrains exclusive ownership of the managed memory region by + * When memory is associated with a single stream, the Unified Memory system + * will allow CPU access to this memory region so long as all operations in \p + * hStream have completed, regardless of whether other streams are active. In + * effect, this constrains exclusive ownership of the managed memory region by * an active GPU to per-stream activity instead of whole-GPU activity. * * Accessing memory on the device from streams that are not associated with * it will produce undefined results. No error checking is performed by the * Unified Memory system to ensure that kernels launched into other streams - * do not access this region. + * do not access this region. * * It is a program's responsibility to order calls to ::cuStreamAttachMemAsync * via events, synchronization or other means to ensure legal access to memory * at all times. Data visibility and coherency will be changed appropriately * for all kernels which follow a stream-association change. * - * If \p hStream is destroyed while data is associated with it, the association is - * removed and the association reverts to the default visibility of the allocation - * as specified at ::cuMemAllocManaged. For __managed__ variables, the default - * association is always ::CU_MEM_ATTACH_GLOBAL. Note that destroying a stream is an - * asynchronous operation, and as a result, the change to default association won't - * happen until all work in the stream has completed. + * If \p hStream is destroyed while data is associated with it, the association + * is removed and the association reverts to the default visibility of the + * allocation as specified at ::cuMemAllocManaged. For __managed__ variables, + * the default association is always ::CU_MEM_ATTACH_GLOBAL. Note that + * destroying a stream is an asynchronous operation, and as a result, the change + * to default association won't happen until all work in the stream has + * completed. * * \param hStream - Stream in which to enqueue the attach operation - * \param dptr - Pointer to memory (must be a pointer to managed memory) - * \param length - Length of memory (must be zero) + * \param dptr - Pointer to memory (must be a pointer to managed memory or + * to a valid host-accessible region of system-allocated + * pageable memory) + * \param length - Length of memory * \param flags - Must be one of ::CUmemAttach_flags * * \return @@ -8242,9 +9930,11 @@ CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback * ::cuStreamSynchronize, * ::cuStreamWaitEvent, * ::cuStreamDestroy, - * ::cuMemAllocManaged + * ::cuMemAllocManaged, + * ::cudaStreamAttachMemAsync */ -CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags); +CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, + size_t length, unsigned int flags); #endif /* __CUDA_API_VERSION >= 6000 */ @@ -8273,7 +9963,8 @@ CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size * ::cuStreamWaitEvent, * ::cuStreamDestroy, * ::cuStreamSynchronize, - * ::cuStreamAddCallback + * ::cuStreamAddCallback, + * ::cudaStreamQuery */ CUresult CUDAAPI cuStreamQuery(CUstream hStream); @@ -8281,7 +9972,7 @@ CUresult CUDAAPI cuStreamQuery(CUstream hStream); * \brief Wait until a stream's tasks are completed * * Waits until the device has completed all operations in the stream specified - * by \p hStream. If the context was created with the + * by \p hStream. If the context was created with the * ::CU_CTX_SCHED_BLOCKING_SYNC flag, the CPU thread will block until the * stream is finished with all of its tasks. * @@ -8293,6 +9984,7 @@ CUresult CUDAAPI cuStreamQuery(CUstream hStream); * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_HANDLE + * \note_null_stream * \notefnerr * @@ -8300,7 +9992,8 @@ CUresult CUDAAPI cuStreamQuery(CUstream hStream); * ::cuStreamDestroy, * ::cuStreamWaitEvent, * ::cuStreamQuery, - * ::cuStreamAddCallback + * ::cuStreamAddCallback, + * ::cudaStreamSynchronize */ CUresult CUDAAPI cuStreamSynchronize(CUstream hStream); @@ -8308,11 +10001,11 @@ CUresult CUDAAPI cuStreamSynchronize(CUstream hStream); /** * \brief Destroys a stream * - * Destroys the stream specified by \p hStream. + * Destroys the stream specified by \p hStream. * * In case the device is still doing work in the stream \p hStream - * when ::cuStreamDestroy() is called, the function will return immediately - * and the resources associated with \p hStream will be released automatically + * when ::cuStreamDestroy() is called, the function will return immediately + * and the resources associated with \p hStream will be released automatically * once the device has completed all work in \p hStream. * * \param hStream - Stream to destroy @@ -8322,21 +10015,22 @@ CUresult CUDAAPI cuStreamSynchronize(CUstream hStream); * ::CUDA_ERROR_DEINITIALIZED, * ::CUDA_ERROR_NOT_INITIALIZED, * ::CUDA_ERROR_INVALID_CONTEXT, - * ::CUDA_ERROR_INVALID_VALUE + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE * \notefnerr * * \sa ::cuStreamCreate, * ::cuStreamWaitEvent, * ::cuStreamQuery, * ::cuStreamSynchronize, - * ::cuStreamAddCallback + * ::cuStreamAddCallback, + * ::cudaStreamDestroy */ CUresult CUDAAPI cuStreamDestroy(CUstream hStream); #endif /* __CUDA_API_VERSION >= 4000 */ /** @} */ /* END CUDA_STREAM */ - /** * \defgroup CUDA_EVENT Event Management * @@ -8352,13 +10046,13 @@ CUresult CUDAAPI cuStreamDestroy(CUstream hStream); /** * \brief Creates an event * - * Creates an event *phEvent with the flags specified via \p Flags. Valid flags - * include: + * Creates an event *phEvent for the current context with the flags specified + * via \p Flags. Valid flags include: * - ::CU_EVENT_DEFAULT: Default event creation flag. - * - ::CU_EVENT_BLOCKING_SYNC: Specifies that the created event should use blocking - * synchronization. A CPU thread that uses ::cuEventSynchronize() to wait on - * an event created with this flag will block until the event has actually - * been recorded. + * - ::CU_EVENT_BLOCKING_SYNC: Specifies that the created event should use + * blocking synchronization. A CPU thread that uses ::cuEventSynchronize() to + * wait on an event created with this flag will block until the event has + * actually been recorded. * - ::CU_EVENT_DISABLE_TIMING: Specifies that the created event does not need * to record timing data. Events created with this flag specified and * the ::CU_EVENT_BLOCKING_SYNC flag not specified will provide the best @@ -8384,23 +10078,29 @@ CUresult CUDAAPI cuStreamDestroy(CUstream hStream); * ::cuEventQuery, * ::cuEventSynchronize, * ::cuEventDestroy, - * ::cuEventElapsedTime + * ::cuEventElapsedTime, + * ::cudaEventCreate, + * ::cudaEventCreateWithFlags */ CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags); /** * \brief Records an event * - * Records an event. See note on NULL stream behavior. Since operation is - * asynchronous, ::cuEventQuery or ::cuEventSynchronize() must be used - * to determine when the event has actually been recorded. - * - * If ::cuEventRecord() has previously been called on \p hEvent, then this - * call will overwrite any existing state in \p hEvent. Any subsequent calls - * which examine the status of \p hEvent will only examine the completion of - * this most recent call to ::cuEventRecord(). + * Captures in \p hEvent the contents of \p hStream at the time of this call. + * \p hEvent and \p hStream must be from the same context. + * Calls such as ::cuEventQuery() or ::cuStreamWaitEvent() will then + * examine or wait for completion of the work that was captured. Uses of + * \p hStream after this call do not modify \p hEvent. See note on default + * stream behavior for what is captured in the default case. * - * It is necessary that \p hEvent and \p hStream be created on the same context. + * ::cuEventRecord() can be called multiple times on the same event and + * will overwrite the previously captured state. Other APIs such as + * ::cuStreamWaitEvent() use the most recently captured state at the time + * of the API call, and are not affected by later calls to + * ::cuEventRecord(). Before the first call to ::cuEventRecord(), an + * event represents an empty set of work, so for example ::cuEventQuery() + * would return ::CUDA_SUCCESS. * * \param hEvent - Event to record * \param hStream - Stream to record event for @@ -8420,21 +10120,19 @@ CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags); * ::cuEventSynchronize, * ::cuStreamWaitEvent, * ::cuEventDestroy, - * ::cuEventElapsedTime + * ::cuEventElapsedTime, + * ::cudaEventRecord */ CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream); /** * \brief Queries an event's status * - * Query the status of all device work preceding the most recent - * call to ::cuEventRecord() (in the appropriate compute streams, - * as specified by the arguments to ::cuEventRecord()). + * Queries the status of all work currently captured by \p hEvent. See + * ::cuEventRecord() for details on what is captured by an event. * - * If this work has successfully been completed by the device, or if - * ::cuEventRecord() has not been called on \p hEvent, then ::CUDA_SUCCESS is - * returned. If this work has not yet been completed by the device then - * ::CUDA_ERROR_NOT_READY is returned. + * Returns ::CUDA_SUCCESS if all captured work has been completed, or + * ::CUDA_ERROR_NOT_READY if any captured work is incomplete. * * For the purposes of Unified Memory, a return value of ::CUDA_SUCCESS * is equivalent to having called ::cuEventSynchronize(). @@ -8454,19 +10152,16 @@ CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream); * ::cuEventRecord, * ::cuEventSynchronize, * ::cuEventDestroy, - * ::cuEventElapsedTime + * ::cuEventElapsedTime, + * ::cudaEventQuery */ CUresult CUDAAPI cuEventQuery(CUevent hEvent); /** * \brief Waits for an event to complete * - * Wait until the completion of all device work preceding the most recent - * call to ::cuEventRecord() (in the appropriate compute streams, as specified - * by the arguments to ::cuEventRecord()). - * - * If ::cuEventRecord() has not been called on \p hEvent, ::CUDA_SUCCESS is - * returned immediately. + * Waits until the completion of all work currently captured in \p hEvent. + * See ::cuEventRecord() for details on what is captured by an event. * * Waiting for an event that was created with the ::CU_EVENT_BLOCKING_SYNC * flag will cause the calling CPU thread to block until the event has @@ -8488,7 +10183,8 @@ CUresult CUDAAPI cuEventQuery(CUevent hEvent); * ::cuEventRecord, * ::cuEventQuery, * ::cuEventDestroy, - * ::cuEventElapsedTime + * ::cuEventElapsedTime, + * ::cudaEventSynchronize */ CUresult CUDAAPI cuEventSynchronize(CUevent hEvent); @@ -8498,10 +10194,10 @@ CUresult CUDAAPI cuEventSynchronize(CUevent hEvent); * * Destroys the event specified by \p hEvent. * - * In case \p hEvent has been recorded but has not yet been completed - * when ::cuEventDestroy() is called, the function will return immediately and - * the resources associated with \p hEvent will be released automatically once - * the device has completed \p hEvent. + * An event may be destroyed before it is complete (i.e., while + * ::cuEventQuery() would return ::CUDA_ERROR_NOT_READY). In this case, the + * call does not block on completion of the event, and any associated + * resources will automatically be released asynchronously at completion. * * \param hEvent - Event to destroy * @@ -8517,7 +10213,8 @@ CUresult CUDAAPI cuEventSynchronize(CUevent hEvent); * ::cuEventRecord, * ::cuEventQuery, * ::cuEventSynchronize, - * ::cuEventElapsedTime + * ::cuEventElapsedTime, + * ::cudaEventDestroy */ CUresult CUDAAPI cuEventDestroy(CUevent hEvent); #endif /* __CUDA_API_VERSION >= 4000 */ @@ -8561,9 +10258,537 @@ CUresult CUDAAPI cuEventDestroy(CUevent hEvent); * ::cuEventRecord, * ::cuEventQuery, * ::cuEventSynchronize, - * ::cuEventDestroy + * ::cuEventDestroy, + * ::cudaEventElapsedTime + */ +CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, + CUevent hEnd); + +/** @} */ /* END CUDA_EVENT */ + +/** + * \defgroup CUDA_EXTRES_INTEROP External Resource Interoperability + * + * ___MANBRIEF___ External resource interoperability functions of the low-level + * CUDA driver API + * (___CURRENT_FILE___) ___ENDMANBRIEF___ + * + * This section describes the external resource interoperability functions of + * the low-level CUDA driver application programming interface. + * + * @{ + */ + +#if __CUDA_API_VERSION >= 10000 + +/** +* \brief Imports an external memory object +* +* Imports an externally allocated memory object and returns +* a handle to that in \p extMem_out. +* +* The properties of the handle being imported must be described in +* \p memHandleDesc. The ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC structure +* is defined as follows: +* +* \code + typedef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st { + CUexternalMemoryHandleType type; + union { + int fd; + struct { + void *handle; + const void *name; + } win32; + } handle; + unsigned long long size; + unsigned int flags; + } CUDA_EXTERNAL_MEMORY_HANDLE_DESC; +* \endcode +* +* where ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type specifies the type +* of handle being imported. ::CUexternalMemoryHandleType is +* defined as: +* +* \code + 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 + } CUexternalMemoryHandleType; +* \endcode +* +* If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is +* ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD, then +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::fd must be a valid +* file descriptor referencing a memory object. Ownership of +* the file descriptor is transferred to the CUDA driver when the +* handle is imported successfully. Performing any operations on the +* file descriptor after it is imported results in undefined behavior. +* +* If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is +* ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32, then exactly one +* of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be +* NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle +* is not NULL, then it must represent a valid shared NT handle that +* references a memory object. Ownership of this handle is +* not transferred to CUDA after the import operation, so the +* application must release the handle using the appropriate system +* call. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name +* is not NULL, then it must point to a NULL-terminated array of +* UTF-16 characters that refers to a memory object. +* +* If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is +* ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT, then +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle must +* be non-NULL and +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name +* must be NULL. The handle specified must be a globally shared KMT +* handle. This handle does not hold a reference to the underlying +* object, and thus will be invalid when all references to the +* memory object are destroyed. +* +* If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is +* ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP, then exactly one +* of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be +* NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle +* is not NULL, then it must represent a valid shared NT handle that +* is returned by ID3DDevice::CreateSharedHandle when referring to a +* ID3D12Heap object. This handle holds a reference to the underlying +* object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name +* is not NULL, then it must point to a NULL-terminated array of +* UTF-16 characters that refers to a ID3D12Heap object. +* +* If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is +* ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE, then exactly one +* of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be +* NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle +* is not NULL, then it must represent a valid shared NT handle that +* is returned by ID3DDevice::CreateSharedHandle when referring to a +* ID3D12Resource object. This handle holds a reference to the +* underlying object. If +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name +* is not NULL, then it must point to a NULL-terminated array of +* UTF-16 characters that refers to a ID3D12Resource object. +* +* The size of the memory object must be specified in +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::size. +* +* Specifying the flag ::CUDA_EXTERNAL_MEMORY_DEDICATED in +* ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::flags indicates that the +* resource is a dedicated resource. The definition of what a +* dedicated resource is outside the scope of this extension. +* +* \param extMem_out - Returned handle to an external memory object +* \param memHandleDesc - Memory import handle descriptor +* +* \return +* ::CUDA_SUCCESS, +* ::CUDA_ERROR_NOT_INITIALIZED, +* ::CUDA_ERROR_INVALID_HANDLE +* \notefnerr +* +* \note If the Vulkan memory imported into CUDA is mapped on the CPU then the +* application must use vkInvalidateMappedMemoryRanges/vkFlushMappedMemoryRanges +* as well as appropriate Vulkan pipeline barriers to maintain coherence between +* CPU and GPU. For more information on these APIs, please refer to +"Synchronization +* and Cache Control" chapter from Vulkan specification. +* +* \sa ::cuDestroyExternalMemory, +* ::cuExternalMemoryGetMappedBuffer, +* ::cuExternalMemoryGetMappedMipmappedArray +*/ +CUresult CUDAAPI +cuImportExternalMemory(CUexternalMemory *extMem_out, + const CUDA_EXTERNAL_MEMORY_HANDLE_DESC *memHandleDesc); + +/** + * \brief Maps a buffer onto an imported memory object + * + * Maps a buffer onto an imported memory object and returns a device + * pointer in \p devPtr. + * + * The properties of the buffer being mapped must be described in + * \p bufferDesc. The ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC structure is + * defined as follows: + * + * \code + typedef struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st { + unsigned long long offset; + unsigned long long size; + unsigned int flags; + } CUDA_EXTERNAL_MEMORY_BUFFER_DESC; + * \endcode + * + * where ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::offset is the offset in + * the memory object where the buffer's base address is. + * ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::size is the size of the buffer. + * ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::flags must be zero. + * + * The offset and size have to be suitably aligned to match the + * requirements of the external API. Mapping two buffers whose ranges + * overlap may or may not result in the same virtual address being + * returned for the overlapped portion. In such cases, the application + * must ensure that all accesses to that region from the GPU are + * volatile. Otherwise writes made via one address are not guaranteed + * to be visible via the other address, even if they're issued by the + * same thread. It is recommended that applications map the combined + * range instead of mapping separate buffers and then apply the + * appropriate offsets to the returned pointer to derive the + * individual buffers. + * + * The returned pointer \p devPtr must be freed using ::cuMemFree. + * + * \param devPtr - Returned device pointer to buffer + * \param extMem - Handle to external memory object + * \param bufferDesc - Buffer descriptor + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalMemory + * ::cuDestroyExternalMemory, + * ::cuExternalMemoryGetMappedMipmappedArray + */ +CUresult CUDAAPI cuExternalMemoryGetMappedBuffer( + CUdeviceptr *devPtr, CUexternalMemory extMem, + const CUDA_EXTERNAL_MEMORY_BUFFER_DESC *bufferDesc); + +/** + * \brief Maps a CUDA mipmapped array onto an external memory object + * + * Maps a CUDA mipmapped array onto an external object and returns a + * handle to it in \p mipmap. + * + * The properties of the CUDA mipmapped array being mapped must be + * described in \p mipmapDesc. The structure + * ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC is defined as follows: + * + * \code + typedef struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st { + unsigned long long offset; + CUDA_ARRAY3D_DESCRIPTOR arrayDesc; + unsigned int numLevels; + } CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC; + * \endcode + * + * where ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::offset is the + * offset in the memory object where the base level of the mipmap + * chain is. + * ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::arrayDesc describes + * the format, dimensions and type of the base level of the mipmap + * chain. For further details on these parameters, please refer to the + * documentation for ::cuMipmappedArrayCreate. Note that if the mipmapped + * array is bound as a color target in the graphics API, then the flag + * ::CUDA_ARRAY3D_COLOR_ATTACHMENT must be specified in + * ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::arrayDesc::Flags. + * ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::numLevels specifies + * the total number of levels in the mipmap chain. + * + * The returned CUDA mipmapped array must be freed using + ::cuMipmappedArrayDestroy. + * + * \param mipmap - Returned CUDA mipmapped array + * \param extMem - Handle to external memory object + * \param mipmapDesc - CUDA array descriptor + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalMemory + * ::cuDestroyExternalMemory, + * ::cuExternalMemoryGetMappedBuffer + */ +CUresult CUDAAPI cuExternalMemoryGetMappedMipmappedArray( + CUmipmappedArray *mipmap, CUexternalMemory extMem, + const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC *mipmapDesc); + +/** + * \brief Destroys an external memory object. + * + * Destroys the specified external memory object. Any existing buffers + * and CUDA mipmapped arrays mapped onto this object must no longer be + * used and must be explicitly freed using ::cuMemFree and + * ::cuMipmappedArrayDestroy respectively. + * + * \param extMem - External memory object to be destroyed + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalMemory + * ::cuExternalMemoryGetMappedBuffer, + * ::cuExternalMemoryGetMappedMipmappedArray + */ +CUresult CUDAAPI cuDestroyExternalMemory(CUexternalMemory extMem); + +/** + * \brief Imports an external semaphore + * + * Imports an externally allocated synchronization object and returns + * a handle to that in \p extSem_out. + * + * The properties of the handle being imported must be described in + * \p semHandleDesc. The ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC is + * defined as follows: + * + * \code + typedef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st { + CUexternalSemaphoreHandleType type; + union { + int fd; + struct { + void *handle; + const void *name; + } win32; + } handle; + unsigned int flags; + } CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC; + * \endcode + * + * where ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type specifies the type of + * handle being imported. ::CUexternalSemaphoreHandleType is defined + * as: + * + * \code + 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 + } CUexternalSemaphoreHandleType; + * \endcode + * + * If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, then + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::fd must be a valid + * file descriptor referencing a synchronization object. Ownership of + * the file descriptor is transferred to the CUDA driver when the + * handle is imported successfully. Performing any operations on the + * file descriptor after it is imported results in undefined behavior. + * + * If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, then exactly one + * of ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle and + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must not be + * NULL. If + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle + * is not NULL, then it must represent a valid shared NT handle that + * references a synchronization object. Ownership of this handle is + * not transferred to CUDA after the import operation, so the + * application must release the handle using the appropriate system + * call. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name + * is not NULL, then it must name a valid synchronization object. + * + * If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT, then + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle must + * be non-NULL and + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name + * must be NULL. The handle specified must be a globally shared KMT + * handle. This handle does not hold a reference to the underlying + * object, and thus will be invalid when all references to the + * synchronization object are destroyed. + * + * If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, then exactly one + * of ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle and + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must not be + * NULL. If + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle + * is not NULL, then it must represent a valid shared NT handle that + * is returned by ID3DDevice::CreateSharedHandle when referring to a + * ID3D12Fence object. This handle holds a reference to the underlying + * object. If + * ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name + * is not NULL, then it must name a valid synchronization object that + * refers to a valid ID3D12Fence object. + * + * \param extSem_out - Returned handle to an external semaphore + * \param semHandleDesc - Semaphore import handle descriptor + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuDestroyExternalSemaphore, + * ::cuSignalExternalSemaphoresAsync, + * ::cuWaitExternalSemaphoresAsync + */ +CUresult CUDAAPI cuImportExternalSemaphore( + CUexternalSemaphore *extSem_out, + const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC *semHandleDesc); + +/** + * \brief Signals a set of external semaphore objects + * + * Enqueues a signal operation on a set of externally allocated + * semaphore object in the specified stream. The operations will be + * executed when all prior operations in the stream complete. + * + * The exact semantics of signaling a semaphore depends on the type of + * the object. + * + * If the semaphore object is any one of the following types: + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT + * then signaling the semaphore will set it to the signaled state. + * + * If the semaphore object is of the type + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, then the + * semaphore will be set to the value specified in + * ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS::params::fence::value. + * + * \param extSemArray - Set of external semaphores to be signaled + * \param paramsArray - Array of semaphore parameters + * \param numExtSems - Number of semaphores to signal + * \param stream - Stream to enqueue the signal operations in + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalSemaphore, + * ::cuDestroyExternalSemaphore, + * ::cuWaitExternalSemaphoresAsync + */ +CUresult CUDAAPI cuSignalExternalSemaphoresAsync( + const CUexternalSemaphore *extSemArray, + const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *paramsArray, + unsigned int numExtSems, CUstream stream); + +/** + * \brief Waits on a set of external semaphore objects + * + * Enqueues a wait operation on a set of externally allocated + * semaphore object in the specified stream. The operations will be + * executed when all prior operations in the stream complete. + * + * The exact semantics of waiting on a semaphore depends on the type + * of the object. + * + * If the semaphore object is any one of the following types: + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT + * then waiting on the semaphore will wait until the semaphore reaches + * the signaled state. The semaphore will then be reset to the + * unsignaled state. Therefore for every signal operation, there can + * only be one wait operation. + * + * If the semaphore object is of the type + * ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, then waiting on + * the semaphore will wait until the value of the semaphore is + * greater than or equal to + * ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS::params::fence::value. + * + * \param extSemArray - External semaphores to be waited on + * \param paramsArray - Array of semaphore parameters + * \param numExtSems - Number of semaphores to wait on + * \param stream - Stream to enqueue the wait operations in + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalSemaphore, + * ::cuDestroyExternalSemaphore, + * ::cuSignalExternalSemaphoresAsync + */ +CUresult CUDAAPI cuWaitExternalSemaphoresAsync( + const CUexternalSemaphore *extSemArray, + const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *paramsArray, + unsigned int numExtSems, CUstream stream); + +/** + * \brief Destroys an external semaphore + * + * Destroys an external semaphore object and releases any references + * to the underlying resource. Any outstanding signals or waits must + * have completed before the semaphore is destroyed. + * + * \param extSem - External semaphore to be destroyed + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_HANDLE + * \notefnerr + * + * \sa ::cuImportExternalSemaphore, + * ::cuSignalExternalSemaphoresAsync, + * ::cuWaitExternalSemaphoresAsync + */ +CUresult CUDAAPI cuDestroyExternalSemaphore(CUexternalSemaphore extSem); + +#endif /* __CUDA_API_VERSION >= 10000 */ + +/** @} */ /* END CUDA_EXTRES_INTEROP */ + +/** + * \defgroup CUDA_MEMOP Stream memory operations + * + * ___MANBRIEF___ Stream memory operations of the low-level CUDA driver API + * (___CURRENT_FILE___) ___ENDMANBRIEF___ + * + * This section describes the stream memory operations of the low-level CUDA + * driver application programming interface. + * + * The whole set of operations is disabled by default. Users are required + * to explicitly enable them, e.g. on Linux by passing the kernel module + * parameter shown below: + * modprobe nvidia NVreg_EnableStreamMemOPs=1 + * There is currently no way to enable these operations on other operating + * systems. + * + * Users can programmatically query whether the device supports these + * operations with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. + * + * Support for the ::CU_STREAM_WAIT_VALUE_NOR flag can be queried with + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR. + * + * Support for the ::cuStreamWriteValue64() and ::cuStreamWaitValue64() + * functions, as well as for the ::CU_STREAM_MEM_OP_WAIT_VALUE_64 and + * ::CU_STREAM_MEM_OP_WRITE_VALUE_64 flags, can be queried with + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS. + * + * Support for both ::CU_STREAM_WAIT_VALUE_FLUSH and + * ::CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES requires dedicated platform + * hardware features and can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES. + * + * Note that all memory pointers passed as parameters to these operations + * are device pointers. Where necessary a device pointer should be + * obtained, for example with ::cuMemHostGetDevicePointer(). + * + * None of the operations accepts pointers to managed memory buffers + * (::cuMemAllocManaged). + * + * @{ */ -CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUevent hEnd); #if __CUDA_API_VERSION >= 8000 /** @@ -8579,8 +10804,12 @@ CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUeven * should be obtained with ::cuMemHostGetDevicePointer(). This function cannot * be used with managed memory (::cuMemAllocManaged). * - * On Windows, the device must be using TCC, or the operation is not supported. - * See ::cuDeviceGetAttributes(). + * Support for this can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. + * + * Support for CU_STREAM_WAIT_VALUE_NOR can be queried with + * ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR. * * \param stream The stream to synchronize on the memory location. * \param addr The memory location to wait on. @@ -8593,12 +10822,51 @@ CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUeven * ::CUDA_ERROR_NOT_SUPPORTED * \notefnerr * - * \sa ::cuStreamWriteValue32, + * \sa ::cuStreamWaitValue64, + * ::cuStreamWriteValue32, + * ::cuStreamWriteValue64 * ::cuStreamBatchMemOp, * ::cuMemHostRegister, * ::cuStreamWaitEvent */ -CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags); +CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags); + +/** + * \brief Wait on a memory location + * + * Enqueues a synchronization of the stream on the given memory location. Work + * ordered after the operation will block until the given condition on the + * memory is satisfied. By default, the condition is to wait for + * (int64_t)(*addr - value) >= 0, a cyclic greater-or-equal. + * Other condition types can be specified via \p flags. + * + * If the memory was registered via ::cuMemHostRegister(), the device pointer + * should be obtained with ::cuMemHostGetDevicePointer(). + * + * Support for this can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS. + * + * \param stream The stream to synchronize on the memory location. + * \param addr The memory location to wait on. + * \param value The value to compare with the memory location. + * \param flags See ::CUstreamWaitValue_flags. + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_NOT_SUPPORTED + * \notefnerr + * + * \sa ::cuStreamWaitValue32, + * ::cuStreamWriteValue32, + * ::cuStreamWriteValue64, + * ::cuStreamBatchMemOp, + * ::cuMemHostRegister, + * ::cuStreamWaitEvent + */ +CUresult CUDAAPI cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, + cuuint64_t value, unsigned int flags); /** * \brief Write a value to memory @@ -8612,8 +10880,8 @@ CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32 * should be obtained with ::cuMemHostGetDevicePointer(). This function cannot * be used with managed memory (::cuMemAllocManaged). * - * On Windows, the device must be using TCC, or the operation is not supported. - * See ::cuDeviceGetAttribute(). + * Support for this can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. * * \param stream The stream to do the write in. * \param addr The device address to write to. @@ -8626,27 +10894,67 @@ CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32 * ::CUDA_ERROR_NOT_SUPPORTED * \notefnerr * - * \sa ::cuStreamWaitValue32, + * \sa ::cuStreamWriteValue64, + * ::cuStreamWaitValue32, + * ::cuStreamWaitValue64, * ::cuStreamBatchMemOp, * ::cuMemHostRegister, * ::cuEventRecord */ -CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags); +CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags); + +/** + * \brief Write a value to memory + * + * Write a value to memory. Unless the ::CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER + * flag is passed, the write is preceded by a system-wide memory fence, + * equivalent to a __threadfence_system() but scoped to the stream + * rather than a CUDA thread. + * + * If the memory was registered via ::cuMemHostRegister(), the device pointer + * should be obtained with ::cuMemHostGetDevicePointer(). + * + * Support for this can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS. + * + * \param stream The stream to do the write in. + * \param addr The device address to write to. + * \param value The value to write. + * \param flags See ::CUstreamWriteValue_flags. + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_NOT_SUPPORTED + * \notefnerr + * + * \sa ::cuStreamWriteValue32, + * ::cuStreamWaitValue32, + * ::cuStreamWaitValue64, + * ::cuStreamBatchMemOp, + * ::cuMemHostRegister, + * ::cuEventRecord + */ +CUresult CUDAAPI cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, + cuuint64_t value, unsigned int flags); /** * \brief Batch operations to synchronize the stream via memory operations * - * This is a batch version of ::cuStreamWaitValue32() and ::cuStreamWriteValue32(). - * Batching operations may avoid some performance overhead in both the API call - * and the device execution versus adding them to the stream in separate API - * calls. The operations are enqueued in the order they appear in the array. + * This is a batch version of ::cuStreamWaitValue32() and + * ::cuStreamWriteValue32(). Batching operations may avoid some performance + * overhead in both the API call and the device execution versus adding them to + * the stream in separate API calls. The operations are enqueued in the order + * they appear in the array. * * See ::CUstreamBatchMemOpType for the full set of supported operations, and - * ::cuStreamWaitValue32() and ::cuStreamWriteValue32() for details of specific - * operations. + * ::cuStreamWaitValue32(), ::cuStreamWaitValue64(), ::cuStreamWriteValue32(), + * and ::cuStreamWriteValue64() for details of specific operations. * - * On Windows, the device must be using TCC, or this call is not supported. See - * ::cuDeviceGetAttribute(). + * Basic support for this can be queried with ::cuDeviceGetAttribute() and + * ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. See related APIs for details + * on querying support for specific operations. * * \param stream The stream to enqueue the operations in. * \param count The number of operations in the array. Must be less than 256. @@ -8660,13 +10968,17 @@ CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint3 * \notefnerr * * \sa ::cuStreamWaitValue32, + * ::cuStreamWaitValue64, * ::cuStreamWriteValue32, + * ::cuStreamWriteValue64, * ::cuMemHostRegister */ -CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags); +CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, + CUstreamBatchMemOpParams *paramArray, + unsigned int flags); #endif /* __CUDA_API_VERSION >= 8000 */ -/** @} */ /* END CUDA_EVENT */ +/** @} */ /* END CUDA_MEMOP */ /** * \defgroup CUDA_EXEC Execution Control @@ -8710,8 +11022,12 @@ CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstrea * would return the value 13. Note that this will return a value of 10 for * legacy cubins that do not have a properly-encoded binary architecture * version. - * - ::CU_FUNC_CACHE_MODE_CA: The attribute to indicate whether the function has + * - ::CU_FUNC_CACHE_MODE_CA: The attribute to indicate whether the function has * been compiled with user specified option "-Xptxas --dlcm=ca" set . + * - ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: The maximum size in + * bytes of dynamically-allocated shared memory. + * - ::CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: Preferred shared + * memory-L1 cache split ratio in percent of total shared memory. * * \param pi - Returned attribute value * \param attrib - Attribute requested @@ -8729,9 +11045,63 @@ CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstrea * \sa ::cuCtxGetCacheConfig, * ::cuCtxSetCacheConfig, * ::cuFuncSetCacheConfig, - * ::cuLaunchKernel + * ::cuLaunchKernel, + * ::cudaFuncGetAttributes + * ::cudaFuncSetAttribute + */ +CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, + CUfunction hfunc); + +#if __CUDA_API_VERSION >= 9000 + +/** + * \brief Sets information about a function + * + * This call sets the value of a specified attribute \p attrib on the kernel + * given by \p hfunc to an integer value specified by \p val This function + * returns CUDA_SUCCESS if the new value of the attribute could be successfully + * set. If the set fails, this call will return an error. Not all attributes can + * have values set. Attempting to set a value on a read-only attribute will + * result in an error (CUDA_ERROR_INVALID_VALUE) + * + * Supported attributes for the cuFuncSetAttribute call are: + * - ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: This maximum size in + * bytes of dynamically-allocated shared memory. The value should contain the + * requested maximum size of dynamically-allocated shared memory. The sum of + * this value and the function attribute ::CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES + * cannot exceed the device attribute + * ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN. The maximal size of + * requestable dynamic shared memory may differ by GPU architecture. + * - ::CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: On devices where the + * L1 cache and shared memory use the same hardware resources, this sets the + * shared memory carveout preference, in percent of the total shared memory. See + * ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR This is only a + * hint, and the driver can choose a different ratio if required to execute the + * function. + * + * \param hfunc - Function to query attribute of + * \param attrib - Attribute requested + * \param value - The value to set + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_INVALID_VALUE + * \notefnerr + * + * \sa ::cuCtxGetCacheConfig, + * ::cuCtxSetCacheConfig, + * ::cuFuncSetCacheConfig, + * ::cuLaunchKernel, + * ::cudaFuncGetAttributes + * ::cudaFuncSetAttribute */ -CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunction hfunc); +CUresult CUDAAPI cuFuncSetAttribute(CUfunction hfunc, + CUfunction_attribute attrib, int value); +#endif // __CUDA_API_VERSION >= 9000 /** * \brief Sets the preferred cache configuration for a device function @@ -8753,8 +11123,10 @@ CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunc * * * The supported cache configurations are: - * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache + * - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 + * (default) + * - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 + * cache * - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory * - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory * @@ -8772,7 +11144,8 @@ CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunc * \sa ::cuCtxGetCacheConfig, * ::cuCtxSetCacheConfig, * ::cuFuncGetAttribute, - * ::cuLaunchKernel + * ::cuLaunchKernel, + * ::cudaFuncSetCacheConfig */ CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config); @@ -8780,33 +11153,33 @@ CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config); /** * \brief Sets the shared memory configuration for a device function. * - * On devices with configurable shared memory banks, this function will + * On devices with configurable shared memory banks, this function will * force all subsequent launches of the specified device function to have * the given shared memory bank size configuration. On any given launch of the * function, the shared memory configuration of the device will be temporarily * changed if needed to suit the function's preferred configuration. Changes in - * shared memory configuration between subsequent launches of functions, + * shared memory configuration between subsequent launches of functions, * may introduce a device side synchronization point. * - * Any per-function setting of shared memory bank size set via + * Any per-function setting of shared memory bank size set via * ::cuFuncSetSharedMemConfig will override the context wide setting set with * ::cuCtxSetSharedMemConfig. * * Changing the shared memory bank size will not increase shared memory usage - * or affect occupancy of kernels, but may have major effects on performance. - * Larger bank sizes will allow for greater potential bandwidth to shared memory, - * but will change what kinds of accesses to shared memory will result in bank - * conflicts. + * or affect occupancy of kernels, but may have major effects on performance. + * Larger bank sizes will allow for greater potential bandwidth to shared + * memory, but will change what kinds of accesses to shared memory will result + * in bank conflicts. * * This function will do nothing on devices with fixed shared memory bank size. * * The supported bank configurations are: - * - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: use the context's shared memory + * - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: use the context's shared memory * configuration when launching this function. * - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: set shared memory bank width to * be natively four bytes when launching this function. - * - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width to - * be natively eight bytes when launching this function. + * - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width + * to be natively eight bytes when launching this function. * * \param hfunc - kernel to be given a shared memory config * \param config - requested shared memory configuration @@ -8824,9 +11197,11 @@ CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config); * ::cuCtxGetSharedMemConfig, * ::cuCtxSetSharedMemConfig, * ::cuFuncGetAttribute, - * ::cuLaunchKernel + * ::cuLaunchKernel, + * ::cudaFuncSetSharedMemConfig */ -CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config); +CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, + CUsharedconfig config); #endif #if __CUDA_API_VERSION >= 4000 @@ -8938,20 +11313,361 @@ CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig confi * \sa ::cuCtxGetCacheConfig, * ::cuCtxSetCacheConfig, * ::cuFuncSetCacheConfig, - * ::cuFuncGetAttribute + * ::cuFuncGetAttribute, + * ::cudaLaunchKernel */ -CUresult CUDAAPI cuLaunchKernel(CUfunction f, - unsigned int gridDimX, - unsigned int gridDimY, - unsigned int gridDimZ, - unsigned int blockDimX, - unsigned int blockDimY, +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); + unsigned int sharedMemBytes, CUstream hStream, + void **kernelParams, void **extra); #endif /* __CUDA_API_VERSION >= 4000 */ +#if __CUDA_API_VERSION >= 9000 +/** + * \brief Launches a CUDA function where thread blocks can cooperate and + * synchronize as they execute + * + * Invokes the kernel \p f on a \p gridDimX x \p gridDimY x \p gridDimZ + * grid of blocks. Each block contains \p blockDimX x \p blockDimY x + * \p blockDimZ threads. + * + * \p sharedMemBytes sets the amount of dynamic shared memory that will be + * available to each thread block. + * + * The device on which this kernel is invoked must have a non-zero value for + * the device attribute ::CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH. + * + * The total number of blocks launched cannot exceed the maximum number of + * blocks per multiprocessor as returned by + * ::cuOccupancyMaxActiveBlocksPerMultiprocessor (or + * ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of + * multiprocessors as specified by the device attribute + * ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT. + * + * The kernel cannot make use of CUDA dynamic parallelism. + * + * Kernel parameters must be specified via \p kernelParams. If \p f + * has N parameters, then \p kernelParams needs to be an array of N + * pointers. Each of \p kernelParams[0] through \p kernelParams[N-1] + * must point to a region of memory from which the actual kernel + * parameter will be copied. The number of kernel parameters and their + * offsets and sizes do not need to be specified as that information is + * retrieved directly from the kernel's image. + * + * Calling ::cuLaunchCooperativeKernel() sets persistent function state that is + * the same as function state set through ::cuLaunchKernel API + * + * When the kernel \p f is launched via ::cuLaunchCooperativeKernel(), the + * previous block shape, shared size and parameter info associated with \p f is + * overwritten. + * + * Note that to use ::cuLaunchCooperativeKernel(), the kernel \p f must either + * have been compiled with toolchain version 3.2 or later so that it will + * contain kernel parameter information, or have no kernel parameters. + * If either of these conditions is not met, then ::cuLaunchCooperativeKernel() + * will return ::CUDA_ERROR_INVALID_IMAGE. + * + * \param f - Kernel to launch + * \param gridDimX - Width of grid in blocks + * \param gridDimY - Height of grid in blocks + * \param gridDimZ - Depth of grid in blocks + * \param blockDimX - X dimension of each thread block + * \param blockDimY - Y dimension of each thread block + * \param blockDimZ - Z dimension of each thread block + * \param sharedMemBytes - Dynamic shared-memory size per thread block in bytes + * \param hStream - Stream identifier + * \param kernelParams - Array of pointers to kernel parameters + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_INVALID_IMAGE, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_LAUNCH_FAILED, + * ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, + * ::CUDA_ERROR_LAUNCH_TIMEOUT, + * ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, + * ::CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE, + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * \note_null_stream + * \notefnerr + * + * \sa ::cuCtxGetCacheConfig, + * ::cuCtxSetCacheConfig, + * ::cuFuncSetCacheConfig, + * ::cuFuncGetAttribute, + * ::cuLaunchCooperativeKernelMultiDevice, + * ::cudaLaunchCooperativeKernel + */ +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); + +/** + * \brief Launches CUDA functions on multiple devices where thread blocks can + cooperate and synchronize as they execute + * + * Invokes kernels as specified in the \p launchParamsList array where each + element + * of the array specifies all the parameters required to perform a single kernel + launch. + * These kernels can cooperate and synchronize as they execute. The size of the + array is + * specified by \p numDevices. + * + * No two kernels can be launched on the same device. All the devices targeted + by this + * multi-device launch must be identical. All devices must have a non-zero value + for the + * device attribute ::CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH. + * + * All kernels launched must be identical with respect to the compiled code. + Note that + * any __device__, __constant__ or __managed__ variables present in the module + that owns + * the kernel launched on each device, are independently instantiated on every + device. + * It is the application's responsiblity to ensure these variables are + initialized and + * used appropriately. + * + * The size of the grids as specified in blocks, the size of the blocks + themselves + * and the amount of shared memory used by each thread block must also match + across + * all launched kernels. + * + * The streams used to launch these kernels must have been created via either + ::cuStreamCreate + * or ::cuStreamCreateWithPriority. The NULL stream or ::CU_STREAM_LEGACY or + ::CU_STREAM_PER_THREAD + * cannot be used. + * + * The total number of blocks launched per kernel cannot exceed the maximum + number of blocks + * per multiprocessor as returned by + ::cuOccupancyMaxActiveBlocksPerMultiprocessor (or + * ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of + multiprocessors + * as specified by the device attribute + ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT. Since the + * total number of blocks launched per device has to match across all devices, + the maximum + * number of blocks that can be launched per device will be limited by the + device with the + * least number of multiprocessors. + * + * The kernels cannot make use of CUDA dynamic parallelism. + * + * The ::CUDA_LAUNCH_PARAMS structure is defined as: + * \code + 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; + * \endcode + * where: + * - ::CUDA_LAUNCH_PARAMS::function specifies the kernel to be launched. All + functions must + * be identical with respect to the compiled code. + * - ::CUDA_LAUNCH_PARAMS::gridDimX is the width of the grid in blocks. This + must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::gridDimY is the height of the grid in blocks. This + must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::gridDimZ is the depth of the grid in blocks. This + must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::blockDimX is the X dimension of each thread block. + This must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::blockDimX is the Y dimension of each thread block. + This must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::blockDimZ is the Z dimension of each thread block. + This must match across + * all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::sharedMemBytes is the dynamic shared-memory size per + thread block in bytes. + * This must match across all kernels launched. + * - ::CUDA_LAUNCH_PARAMS::hStream is the handle to the stream to perform the + launch in. This cannot + * be the NULL stream or ::CU_STREAM_LEGACY or ::CU_STREAM_PER_THREAD. The + CUDA context associated + * with this stream must match that associated with + ::CUDA_LAUNCH_PARAMS::function. + * - ::CUDA_LAUNCH_PARAMS::kernelParams is an array of pointers to kernel + parameters. If + * ::CUDA_LAUNCH_PARAMS::function has N parameters, then + ::CUDA_LAUNCH_PARAMS::kernelParams + * needs to be an array of N pointers. Each of + ::CUDA_LAUNCH_PARAMS::kernelParams[0] through + * ::CUDA_LAUNCH_PARAMS::kernelParams[N-1] must point to a region of memory + from which the actual + * kernel parameter will be copied. The number of kernel parameters and their + offsets and sizes + * do not need to be specified as that information is retrieved directly from + the kernel's image. + * + * By default, the kernel won't begin execution on any GPU until all prior work + in all the specified + * streams has completed. This behavior can be overridden by specifying the flag + * ::CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC. When this flag is + specified, each kernel + * will only wait for prior work in the stream corresponding to that GPU to + complete before it begins + * execution. + * + * Similarly, by default, any subsequent work pushed in any of the specified + streams will not begin + * execution until the kernels on all GPUs have completed. This behavior can be + overridden by specifying + * the flag ::CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC. When + this flag is specified, + * any subsequent work pushed in any of the specified streams will only wait for + the kernel launched + * on the GPU corresponding to that stream to complete before it begins + execution. + * + * Calling ::cuLaunchCooperativeKernelMultiDevice() sets persistent function + state that is + * the same as function state set through ::cuLaunchKernel API when called + individually for each + * element in \p launchParamsList. + * + * When kernels are launched via ::cuLaunchCooperativeKernelMultiDevice(), the + previous + * block shape, shared size and parameter info associated with each + ::CUDA_LAUNCH_PARAMS::function + * in \p launchParamsList is overwritten. + * + * Note that to use ::cuLaunchCooperativeKernelMultiDevice(), the kernels must + either have + * been compiled with toolchain version 3.2 or later so that it will + * contain kernel parameter information, or have no kernel parameters. + * If either of these conditions is not met, then + ::cuLaunchCooperativeKernelMultiDevice() will + * return ::CUDA_ERROR_INVALID_IMAGE. + * + * \param launchParamsList - List of launch parameters, one per device + * \param numDevices - Size of the \p launchParamsList array + * \param flags - Flags to control launch behavior + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_INVALID_IMAGE, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_LAUNCH_FAILED, + * ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, + * ::CUDA_ERROR_LAUNCH_TIMEOUT, + * ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, + * ::CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE, + * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED + * \note_null_stream + * \notefnerr + * + * \sa ::cuCtxGetCacheConfig, + * ::cuCtxSetCacheConfig, + * ::cuFuncSetCacheConfig, + * ::cuFuncGetAttribute, + * ::cuLaunchCooperativeKernel, + * ::cudaLaunchCooperativeKernelMultiDevice + */ +CUresult CUDAAPI cuLaunchCooperativeKernelMultiDevice( + CUDA_LAUNCH_PARAMS *launchParamsList, unsigned int numDevices, + unsigned int flags); + +#endif /* __CUDA_API_VERSION >= 9000 */ + +#if __CUDA_API_VERSION >= 10000 + +/** + * \brief Enqueues a host function call in a stream + * + * Enqueues a host function to run in a stream. The function will be called + * after currently enqueued work and will block work added after it. + * + * The host function must not make any CUDA API calls. Attempting to use a + * CUDA API may result in ::CUDA_ERROR_NOT_PERMITTED, but this is not required. + * The host function must not perform any synchronization that may depend on + * outstanding CUDA work not mandated to run earlier. Host functions without a + * mandated order (such as in independent streams) execute in undefined order + * and may be serialized. + * + * For the purposes of Unified Memory, execution makes a number of guarantees: + * <ul> + * <li>The stream is considered idle for the duration of the function's + * execution. Thus, for example, the function may always use memory attached + * to the stream it was enqueued in.</li> + * <li>The start of execution of the function has the same effect as + * synchronizing an event recorded in the same stream immediately prior to + * the function. It thus synchronizes streams which have been "joined" + * prior to the function.</li> + * <li>Adding device work to any stream does not have the effect of making + * the stream active until all preceding host functions and stream callbacks + * have executed. Thus, for + * example, a function might use global attached memory even if work has + * been added to another stream, if the work has been ordered behind the + * function call with an event.</li> + * <li>Completion of the function does not cause a stream to become + * active except as described above. The stream will remain idle + * if no device work follows the function, and will remain idle across + * consecutive host functions or stream callbacks without device work in + * between. Thus, for example, + * stream synchronization can be done by signaling from a host function at the + * end of the stream.</li> + * </ul> + * + * Note that, in contrast to ::cuStreamAddCallback, the function will not be + * called in the event of an error in the CUDA context. + * + * \param hStream - Stream to enqueue function call in + * \param fn - The function to call once preceding stream operations are + * complete \param userData - User-specified data to be passed to the function + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_CONTEXT, + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_NOT_SUPPORTED + * \note_null_stream + * \notefnerr + * + * \sa ::cuStreamCreate, + * ::cuStreamQuery, + * ::cuStreamSynchronize, + * ::cuStreamWaitEvent, + * ::cuStreamDestroy, + * ::cuMemAllocManaged, + * ::cuStreamAttachMemAsync, + * ::cuStreamAddCallback + */ +CUresult CUDAAPI cuLaunchHostFunc(CUstream hStream, CUhostFn fn, + void *userData); + +#endif /* __CUDA_API_VERSION >= 10000 */ /** @} */ /* END CUDA_EXEC */ @@ -9001,7 +11717,8 @@ CUresult CUDAAPI cuLaunchKernel(CUfunction f, * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z); +__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, + int y, int z); /** * \brief Sets the dynamic shared-memory size for the function @@ -9035,7 +11752,8 @@ CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes); +__CUDA_DEPRECATED CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, + unsigned int bytes); /** * \brief Sets the parameter size for the function @@ -9067,7 +11785,8 @@ CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, unsigned int numbytes); +__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, + unsigned int numbytes); /** * \brief Adds an integer parameter to the function's argument list @@ -9100,7 +11819,8 @@ CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, unsigned int numbytes); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, unsigned int value); +__CUDA_DEPRECATED CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, + unsigned int value); /** * \brief Adds a floating-point parameter to the function's argument list @@ -9133,7 +11853,8 @@ CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, unsigned int value); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, float value); +__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, + float value); /** * \brief Adds arbitrary data to the function's argument list @@ -9168,7 +11889,9 @@ CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, float value); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, void *ptr, unsigned int numbytes); +__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, + void *ptr, + unsigned int numbytes); /** * \brief Launches a CUDA function @@ -9205,7 +11928,7 @@ CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, void *ptr, unsigned i * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuLaunch(CUfunction f); +__CUDA_DEPRECATED CUresult CUDAAPI cuLaunch(CUfunction f); /** * \brief Launches a CUDA function @@ -9244,7 +11967,8 @@ CUresult CUDAAPI cuLaunch(CUfunction f); * ::cuLaunchGridAsync, * ::cuLaunchKernel */ -CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height); +__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, + int grid_height); /** * \brief Launches a CUDA function @@ -9273,10 +11997,11 @@ CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height); * ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, * ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED * - * \note In certain cases where cubins are created with no ABI (i.e., using \p ptxas \p --abi-compile \p no), - * this function may serialize kernel launches. In order to force the CUDA driver to retain - * asynchronous behavior, set the ::CU_CTX_LMEM_RESIZE_TO_MAX flag during context creation (see ::cuCtxCreate). - * + * \note In certain cases where cubins are created with no ABI (i.e., using \p + * ptxas \p --abi-compile \p no), this function may serialize kernel launches. + * In order to force the CUDA driver to retain asynchronous behavior, set the + * ::CU_CTX_LMEM_RESIZE_TO_MAX flag during context creation (see ::cuCtxCreate). + * * \note_null_stream * \notefnerr * @@ -9291,8 +12016,10 @@ CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height); * ::cuLaunchGrid, * ::cuLaunchKernel */ -CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream); - +__CUDA_DEPRECATED CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, + int grid_width, + int grid_height, + CUstream hStream); /** * \brief Adds a texture-reference to the function's argument list @@ -9316,9 +12043,1106 @@ CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height * ::CUDA_ERROR_INVALID_VALUE * \notefnerr */ -CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef); +__CUDA_DEPRECATED CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, + int texunit, + CUtexref hTexRef); /** @} */ /* END CUDA_EXEC_DEPRECATED */ +#if __CUDA_API_VERSION >= 10000 +/** + * \defgroup CUDA_GRAPH Graph Management + * + * ___MANBRIEF___ graph management functions of the low-level CUDA driver API + * (___CURRENT_FILE___) ___ENDMANBRIEF___ + * + * This section describes the graph management functions of the low-level CUDA + * driver application programming interface. + * + * @{ + */ + +/** + * \brief Creates a graph + * + * Creates an empty graph, which is returned via \p phGraph. + * + * \param phGraph - Returns newly created graph + * \param flags - Graph creation flags, must be 0 + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_OUT_OF_MEMORY + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode, + * ::cuGraphInstantiate, + * ::cuGraphDestroy, + * ::cuGraphGetNodes, + * ::cuGraphGetRootNodes, + * ::cuGraphGetEdges, + * ::cuGraphClone + */ +CUresult CUDAAPI cuGraphCreate(CUgraph *phGraph, unsigned int flags); + +/** + * \brief Creates a kernel execution node and adds it to a graph + * + * Creates a new kernel execution node and adds it to \p hGraph with \p + * numDependencies dependencies specified via \p dependencies and arguments + * specified in \p nodeParams. It is possible for \p numDependencies to be 0, in + * which case the node will be placed at the root of the graph. \p dependencies + * may not have any duplicate entries. A handle to the new node will be returned + * in \p phGraphNode. + * + * The CUDA_KERNEL_NODE_PARAMS structure is defined as: + * + * \code + * 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; + * \endcode + * + * When the graph is launched, the node will invoke kernel \p func on a (\p + * gridDimX x \p gridDimY x \p gridDimZ) grid of blocks. Each block contains + * (\p blockDimX x \p blockDimY x \p blockDimZ) threads. + * + * \p sharedMemBytes sets the amount of dynamic shared memory that will be + * available to each thread block. + * + * Kernel parameters to \p func can be specified in one of two ways: + * + * 1) Kernel parameters can be specified via \p kernelParams. If the kernel has + * N parameters, then \p kernelParams needs to be an array of N pointers. Each + * pointer, from \p kernelParams[0] to \p kernelParams[N-1], points to the + * region of memory from which the actual parameter will be copied. The number + * of kernel parameters and their offsets and sizes do not need to be specified + * as that information is retrieved directly from the kernel's image. + * + * 2) Kernel parameters can also be packaged by the application into a single + * buffer that is passed in via \p extra. This places the burden on the + * application of knowing each kernel parameter's size and alignment/padding + * within the buffer. The \p extra parameter exists to allow this function to + * take additional less commonly used arguments. \p extra specifies a list of + * names of extra settings and their corresponding values. Each extra setting + * name is immediately followed by the corresponding value. The list must be + * terminated with either NULL or CU_LAUNCH_PARAM_END. + * + * - ::CU_LAUNCH_PARAM_END, which indicates the end of the \p extra + * array; + * - ::CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next + * value in \p extra will be a pointer to a buffer + * containing all the kernel parameters for launching kernel + * \p func; + * - ::CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next + * value in \p extra will be a pointer to a size_t + * containing the size of the buffer specified with + * ::CU_LAUNCH_PARAM_BUFFER_POINTER; + * + * The error ::CUDA_ERROR_INVALID_VALUE will be returned if kernel parameters + * are specified with both \p kernelParams and \p extra (i.e. both \p + * kernelParams and \p extra are non-NULL). + * + * The \p kernelParams or \p extra array, as well as the argument values it + * points to, are copied during this call. + * + * \note Kernels launched using graphs must not use texture and surface + * references. Reading or writing through any texture or surface reference is + * undefined behavior. This restriction does not apply to texture and surface + * objects. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * \param nodeParams - Parameters for the GPU execution node + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchKernel, + * ::cuGraphKernelNodeGetParams, + * ::cuGraphKernelNodeSetParams, + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode + */ +CUresult CUDAAPI cuGraphAddKernelNode( + CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, + size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS *nodeParams); + +/** + * \brief Returns a kernel node's parameters + * + * Returns the parameters of kernel node \p hNode in \p nodeParams. + * The \p kernelParams or \p extra array returned in \p nodeParams, + * as well as the argument values it points to, are owned by the node. + * This memory remains valid until the node is destroyed or its + * parameters are modified, and should not be modified + * directly. Use ::cuGraphKernelNodeSetParams to update the + * parameters of this node. + * + * The params will contain either \p kernelParams or \p extra, + * according to which of these was most recently set on the node. + * + * \param hNode - Node to get the parameters for + * \param nodeParams - Pointer to return the parameters + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchKernel, + * ::cuGraphAddKernelNode, + * ::cuGraphKernelNodeSetParams + */ +CUresult CUDAAPI cuGraphKernelNodeGetParams( + CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS *nodeParams); + +/** + * \brief Sets a kernel node's parameters + * + * Sets the parameters of kernel node \p hNode to \p nodeParams. + * + * \param hNode - Node to set the parameters for + * \param nodeParams - Parameters to copy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_HANDLE, + * ::CUDA_ERROR_OUT_OF_MEMORY + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchKernel, + * ::cuGraphAddKernelNode, + * ::cuGraphKernelNodeGetParams + */ +CUresult CUDAAPI cuGraphKernelNodeSetParams( + CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS *nodeParams); + +/** + * \brief Creates a memcpy node and adds it to a graph + * + * Creates a new memcpy node and adds it to \p hGraph with \p numDependencies + * dependencies specified via \p dependencies. + * It is possible for \p numDependencies to be 0, in which case the node will be + * placed at the root of the graph. \p dependencies may not have any duplicate + * entries. A handle to the new node will be returned in \p phGraphNode. + * + * When the graph is launched, the node will perform the memcpy described by \p + * copyParams. See ::cuMemcpy3D() for a description of the structure and its + * restrictions. + * + * Memcpy nodes have some additional restrictions with regards to managed + * memory, if the system contains at least one device which has a zero value for + * the device attribute + * ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If one or more of the + * operands refer to managed memory, then using the memory type + * ::CU_MEMORYTYPE_UNIFIED is disallowed for those operand(s). The managed + * memory will be treated as residing on either the host or the device, + * depending on which memory type is specified. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * \param copyParams - Parameters for the memory copy + * \param ctx - Context on which to run the node + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemcpy3D, + * ::cuGraphMemcpyNodeGetParams, + * ::cuGraphMemcpyNodeSetParams, + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemsetNode + */ +CUresult CUDAAPI cuGraphAddMemcpyNode(CUgraphNode *phGraphNode, CUgraph hGraph, + const CUgraphNode *dependencies, + size_t numDependencies, + const CUDA_MEMCPY3D *copyParams, + CUcontext ctx); + +/** + * \brief Returns a memcpy node's parameters + * + * Returns the parameters of memcpy node \p hNode in \p nodeParams. + * + * \param hNode - Node to get the parameters for + * \param nodeParams - Pointer to return the parameters + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemcpy3D, + * ::cuGraphAddMemcpyNode, + * ::cuGraphMemcpyNodeSetParams + */ +CUresult CUDAAPI cuGraphMemcpyNodeGetParams(CUgraphNode hNode, + CUDA_MEMCPY3D *nodeParams); + +/** + * \brief Sets a memcpy node's parameters + * + * Sets the parameters of memcpy node \p hNode to \p nodeParams. + * + * \param hNode - Node to set the parameters for + * \param nodeParams - Parameters to copy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemcpy3D, + * ::cuGraphAddMemcpyNode, + * ::cuGraphMemcpyNodeGetParams + */ +CUresult CUDAAPI cuGraphMemcpyNodeSetParams(CUgraphNode hNode, + const CUDA_MEMCPY3D *nodeParams); + +/** + * \brief Creates a memset node and adds it to a graph + * + * Creates a new memset node and adds it to \p hGraph with \p numDependencies + * dependencies specified via \p dependencies. + * It is possible for \p numDependencies to be 0, in which case the node will be + * placed at the root of the graph. \p dependencies may not have any duplicate + * entries. A handle to the new node will be returned in \p phGraphNode. + * + * The element size must be 1, 2, or 4 bytes. + * When the graph is launched, the node will perform the memset described by \p + * memsetParams. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * \param memsetParams - Parameters for the memory set + * \param ctx - Context on which to run the node + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_INVALID_CONTEXT + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemsetD2D32, + * ::cuGraphMemsetNodeGetParams, + * ::cuGraphMemsetNodeSetParams, + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode + */ +CUresult CUDAAPI cuGraphAddMemsetNode( + CUgraphNode *phGraphNode, CUgraph hGraph, const CUgraphNode *dependencies, + size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS *memsetParams, + CUcontext ctx); + +/** + * \brief Returns a memset node's parameters + * + * Returns the parameters of memset node \p hNode in \p nodeParams. + * + * \param hNode - Node to get the parameters for + * \param nodeParams - Pointer to return the parameters + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemsetD2D32, + * ::cuGraphAddMemsetNode, + * ::cuGraphMemsetNodeSetParams + */ +CUresult CUDAAPI cuGraphMemsetNodeGetParams( + CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS *nodeParams); + +/** + * \brief Sets a memset node's parameters + * + * Sets the parameters of memset node \p hNode to \p nodeParams. + * + * \param hNode - Node to set the parameters for + * \param nodeParams - Parameters to copy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuMemsetD2D32, + * ::cuGraphAddMemsetNode, + * ::cuGraphMemsetNodeGetParams + */ +CUresult CUDAAPI cuGraphMemsetNodeSetParams( + CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS *nodeParams); + +/** + * \brief Creates a host execution node and adds it to a graph + * + * Creates a new CPU execution node and adds it to \p hGraph with \p + * numDependencies dependencies specified via \p dependencies and arguments + * specified in \p nodeParams. It is possible for \p numDependencies to be 0, in + * which case the node will be placed at the root of the graph. \p dependencies + * may not have any duplicate entries. A handle to the new node will be returned + * in \p phGraphNode. + * + * When the graph is launched, the node will invoke the specified CPU function. + * Host nodes are not supported under MPS with pre-Volta GPUs. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * \param nodeParams - Parameters for the host node + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_NOT_SUPPORTED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchHostFunc, + * ::cuGraphHostNodeGetParams, + * ::cuGraphHostNodeSetParams, + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode + */ +CUresult CUDAAPI cuGraphAddHostNode(CUgraphNode *phGraphNode, CUgraph hGraph, + const CUgraphNode *dependencies, + size_t numDependencies, + const CUDA_HOST_NODE_PARAMS *nodeParams); + +/** + * \brief Returns a host node's parameters + * + * Returns the parameters of host node \p hNode in \p nodeParams. + * + * \param hNode - Node to get the parameters for + * \param nodeParams - Pointer to return the parameters + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchHostFunc, + * ::cuGraphAddHostNode, + * ::cuGraphHostNodeSetParams + */ +CUresult CUDAAPI cuGraphHostNodeGetParams(CUgraphNode hNode, + CUDA_HOST_NODE_PARAMS *nodeParams); + +/** + * \brief Sets a host node's parameters + * + * Sets the parameters of host node \p hNode to \p nodeParams. + * + * \param hNode - Node to set the parameters for + * \param nodeParams - Parameters to copy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuLaunchHostFunc, + * ::cuGraphAddHostNode, + * ::cuGraphHostNodeGetParams + */ +CUresult CUDAAPI cuGraphHostNodeSetParams( + CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS *nodeParams); + +/** + * \brief Creates a child graph node and adds it to a graph + * + * Creates a new node which executes an embedded graph, and adds it to \p hGraph + * with \p numDependencies dependencies specified via \p dependencies. It is + * possible for \p numDependencies to be 0, in which case the node will be + * placed at the root of the graph. \p dependencies may not have any duplicate + * entries. A handle to the new node will be returned in \p phGraphNode. + * + * The node executes an embedded child graph. The child graph is cloned in this + * call. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * \param childGraph - The graph to clone into this node + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphChildGraphNodeGetGraph, + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode, + * ::cuGraphClone + */ +CUresult CUDAAPI cuGraphAddChildGraphNode(CUgraphNode *phGraphNode, + CUgraph hGraph, + const CUgraphNode *dependencies, + size_t numDependencies, + CUgraph childGraph); + +/** + * \brief Gets a handle to the embedded graph of a child graph node + * + * Gets a handle to the embedded graph in a child graph node. This call + * does not clone the graph. Changes to the graph will be reflected in + * the node, and the node retains ownership of the graph. + * + * \param hNode - Node to get the embedded graph for + * \param phGraph - Location to store a handle to the graph + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphAddChildGraphNode, + * ::cuGraphNodeFindInClone + */ +CUresult CUDAAPI cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, + CUgraph *phGraph); + +/** + * \brief Creates an empty node and adds it to a graph + * + * Creates a new node which performs no operation, and adds it to \p hGraph with + * \p numDependencies dependencies specified via \p dependencies. + * It is possible for \p numDependencies to be 0, in which case the node will be + * placed at the root of the graph. \p dependencies may not have any duplicate + * entries. A handle to the new node will be returned in \p phGraphNode. + * + * An empty node performs no operation during execution, but can be used for + * transitive ordering. For example, a phased execution graph with 2 groups of n + * nodes with a barrier between them can be represented using an empty node and + * 2*n dependency edges, rather than no empty node and n^2 dependency edges. + * + * \param phGraphNode - Returns newly created node + * \param hGraph - Graph to which to add the node + * \param dependencies - Dependencies of the node + * \param numDependencies - Number of dependencies + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate, + * ::cuGraphDestroyNode, + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode + */ +CUresult CUDAAPI cuGraphAddEmptyNode(CUgraphNode *phGraphNode, CUgraph hGraph, + const CUgraphNode *dependencies, + size_t numDependencies); + +/** + * \brief Clones a graph + * + * This function creates a copy of \p originalGraph and returns it in \p * + * phGraphClone. All parameters are copied into the cloned graph. The original + * graph may be modified after this call without affecting the clone. + * + * Child graph nodes in the original graph are recursively copied into the + * clone. + * + * \param phGraphClone - Returns newly created cloned graph + * \param originalGraph - Graph to clone + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * ::CUDA_ERROR_OUT_OF_MEMORY + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate, + * ::cuGraphNodeFindInClone + */ +CUresult CUDAAPI cuGraphClone(CUgraph *phGraphClone, CUgraph originalGraph); + +/** + * \brief Finds a cloned version of a node + * + * This function returns the node in \p hClonedGraph corresponding to \p + * hOriginalNode in the original graph. + * + * \p hClonedGraph must have been cloned from \p hOriginalGraph via + * ::cuGraphClone. \p hOriginalNode must have been in \p hOriginalGraph at the + * time of the call to + * ::cuGraphClone, and the corresponding cloned node in \p hClonedGraph must not + * have been removed. The cloned node is then returned via \p phClonedNode. + * + * \param phNode - Returns handle to the cloned node + * \param hOriginalNode - Handle to the original node + * \param hClonedGraph - Cloned graph to query + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphClone + */ +CUresult CUDAAPI cuGraphNodeFindInClone(CUgraphNode *phNode, + CUgraphNode hOriginalNode, + CUgraph hClonedGraph); + +/** + * \brief Returns a node's type + * + * Returns the node type of \p hNode in \p type. + * + * \param hNode - Node to query + * \param type - Pointer to return the node type + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphGetNodes, + * ::cuGraphGetRootNodes, + * ::cuGraphChildGraphNodeGetGraph, + * ::cuGraphKernelNodeGetParams, + * ::cuGraphKernelNodeSetParams, + * ::cuGraphHostNodeGetParams, + * ::cuGraphHostNodeSetParams, + * ::cuGraphMemcpyNodeGetParams, + * ::cuGraphMemcpyNodeSetParams, + * ::cuGraphMemsetNodeGetParams, + * ::cuGraphMemsetNodeSetParams + */ +CUresult CUDAAPI cuGraphNodeGetType(CUgraphNode hNode, CUgraphNodeType *type); + +/** + * \brief Returns a graph's nodes + * + * Returns a list of \p hGraph's nodes. \p nodes may be NULL, in which case this + * function will return the number of nodes in \p numNodes. Otherwise, + * \p numNodes entries will be filled in. If \p numNodes is higher than the + * actual number of nodes, the remaining entries in \p nodes will be set to + * NULL, and the number of nodes actually obtained will be returned in \p + * numNodes. + * + * \param hGraph - Graph to query + * \param nodes - Pointer to return the nodes + * \param numNodes - See description + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate, + * ::cuGraphGetRootNodes, + * ::cuGraphGetEdges, + * ::cuGraphNodeGetType, + * ::cuGraphNodeGetDependencies, + * ::cuGraphNodeGetDependentNodes + */ +CUresult CUDAAPI cuGraphGetNodes(CUgraph hGraph, CUgraphNode *nodes, + size_t *numNodes); + +/** + * \brief Returns a graph's root nodes + * + * Returns a list of \p hGraph's root nodes. \p rootNodes may be NULL, in which + * case this function will return the number of root nodes in \p numRootNodes. + * Otherwise, \p numRootNodes entries will be filled in. If \p numRootNodes is + * higher than the actual number of root nodes, the remaining entries in \p + * rootNodes will be set to NULL, and the number of nodes actually obtained will + * be returned in \p numRootNodes. + * + * \param hGraph - Graph to query + * \param rootNodes - Pointer to return the root nodes + * \param numRootNodes - See description + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate, + * ::cuGraphGetNodes, + * ::cuGraphGetEdges, + * ::cuGraphNodeGetType, + * ::cuGraphNodeGetDependencies, + * ::cuGraphNodeGetDependentNodes + */ +CUresult CUDAAPI cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode *rootNodes, + size_t *numRootNodes); + +/** + * \brief Returns a graph's dependency edges + * + * Returns a list of \p hGraph's dependency edges. Edges are returned via + * corresponding indices in \p from and \p to; that is, the node in \p to[i] has + * a dependency on the node in \p from[i]. \p from and \p to may both be NULL, + * in which case this function only returns the number of edges in \p numEdges. + * Otherwise, \p numEdges entries will be filled in. If \p numEdges is higher + * than the actual number of edges, the remaining entries in \p from and \p to + * will be set to NULL, and the number of edges actually returned will be + * written to \p numEdges. + * + * \param hGraph - Graph to get the edges from + * \param from - Location to return edge endpoints + * \param to - Location to return edge endpoints + * \param numEdges - See description + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphGetNodes, + * ::cuGraphGetRootNodes, + * ::cuGraphAddDependencies, + * ::cuGraphRemoveDependencies, + * ::cuGraphNodeGetDependencies, + * ::cuGraphNodeGetDependentNodes + */ +CUresult CUDAAPI cuGraphGetEdges(CUgraph hGraph, CUgraphNode *from, + CUgraphNode *to, size_t *numEdges); + +/** + * \brief Returns a node's dependencies + * + * Returns a list of \p node's dependencies. \p dependencies may be NULL, in + * which case this function will return the number of dependencies in \p + * numDependencies. Otherwise, \p numDependencies entries will be filled in. If + * \p numDependencies is higher than the actual number of dependencies, the + * remaining entries in \p dependencies will be set to NULL, and the number of + * nodes actually obtained will be returned in \p numDependencies. + * + * \param hNode - Node to query + * \param dependencies - Pointer to return the dependencies + * \param numDependencies - See description + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphNodeGetDependentNodes, + * ::cuGraphGetNodes, + * ::cuGraphGetRootNodes, + * ::cuGraphGetEdges, + * ::cuGraphAddDependencies, + * ::cuGraphRemoveDependencies + */ +CUresult CUDAAPI cuGraphNodeGetDependencies(CUgraphNode hNode, + CUgraphNode *dependencies, + size_t *numDependencies); + +/** + * \brief Returns a node's dependent nodes + * + * Returns a list of \p node's dependent nodes. \p dependentNodes may be NULL, + * in which case this function will return the number of dependent nodes in \p + * numDependentNodes. Otherwise, \p numDependentNodes entries will be filled in. + * If \p numDependentNodes is higher than the actual number of dependent nodes, + * the remaining entries in \p dependentNodes will be set to NULL, and the + * number of nodes actually obtained will be returned in \p numDependentNodes. + * + * \param hNode - Node to query + * \param dependentNodes - Pointer to return the dependent nodes + * \param numDependentNodes - See description + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphNodeGetDependencies, + * ::cuGraphGetNodes, + * ::cuGraphGetRootNodes, + * ::cuGraphGetEdges, + * ::cuGraphAddDependencies, + * ::cuGraphRemoveDependencies + */ +CUresult CUDAAPI cuGraphNodeGetDependentNodes(CUgraphNode hNode, + CUgraphNode *dependentNodes, + size_t *numDependentNodes); + +/** + * \brief Adds dependency edges to a graph + * + * The number of dependencies to be added is defined by \p numDependencies + * Elements in \p from and \p to at corresponding indices define a dependency. + * Each node in \p from and \p to must belong to \p hGraph. + * + * If \p numDependencies is 0, elements in \p from and \p to will be ignored. + * Specifying an existing dependency will return an error. + * + * \param hGraph - Graph to which dependencies are added + * \param from - Array of nodes that provide the dependencies + * \param to - Array of dependent nodes + * \param numDependencies - Number of dependencies to be added + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphRemoveDependencies, + * ::cuGraphGetEdges, + * ::cuGraphNodeGetDependencies, + * ::cuGraphNodeGetDependentNodes + */ +CUresult CUDAAPI cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode *from, + const CUgraphNode *to, + size_t numDependencies); + +/** + * \brief Removes dependency edges from a graph + * + * The number of \p dependencies to be removed is defined by \p numDependencies. + * Elements in \p from and \p to at corresponding indices define a dependency. + * Each node in \p from and \p to must belong to \p hGraph. + * + * If \p numDependencies is 0, elements in \p from and \p to will be ignored. + * Specifying a non-existing dependency will return an error. + * + * \param hGraph - Graph from which to remove dependencies + * \param from - Array of nodes that provide the dependencies + * \param to - Array of dependent nodes + * \param numDependencies - Number of dependencies to be removed + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphAddDependencies, + * ::cuGraphGetEdges, + * ::cuGraphNodeGetDependencies, + * ::cuGraphNodeGetDependentNodes + */ +CUresult CUDAAPI cuGraphRemoveDependencies(CUgraph hGraph, + const CUgraphNode *from, + const CUgraphNode *to, + size_t numDependencies); + +/** + * \brief Remove a node from the graph + * + * Removes \p hNode from its graph. This operation also severs any dependencies + * of other nodes on \p hNode and vice versa. + * + * \param hNode - Node to remove + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphAddChildGraphNode, + * ::cuGraphAddEmptyNode, + * ::cuGraphAddKernelNode, + * ::cuGraphAddHostNode, + * ::cuGraphAddMemcpyNode, + * ::cuGraphAddMemsetNode + */ +CUresult CUDAAPI cuGraphDestroyNode(CUgraphNode hNode); + +/** + * \brief Creates an executable graph from a graph + * + * Instantiates \p hGraph as an executable graph. The graph is validated for any + * structural constraints or intra-node constraints which were not previously + * validated. If instantiation is successful, a handle to the instantiated graph + * is returned in \p graphExec. + * + * If there are any errors, diagnostic information may be returned in \p + * errorNode and \p logBuffer. This is the primary way to inspect instantiation + * errors. The output will be null terminated unless the diagnostics overflow + * the buffer. In this case, they will be truncated, and the last byte can be + * inspected to determine if truncation occurred. + * + * \param phGraphExec - Returns instantiated graph + * \param hGraph - Graph to instantiate + * \param phErrorNode - In case of an instantiation error, this may be modified + * to indicate a node contributing to the error \param logBuffer - A character + * buffer to store diagnostic messages \param bufferSize - Size of the log + * buffer in bytes + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate, + * ::cuGraphLaunch, + * ::cuGraphExecDestroy + */ +CUresult CUDAAPI cuGraphInstantiate(CUgraphExec *phGraphExec, CUgraph hGraph, + CUgraphNode *phErrorNode, char *logBuffer, + size_t bufferSize); + +#if __CUDA_API_VERSION >= 10010 +/** + * \brief Sets the parameters for a kernel node in the given graphExec + * + * Sets the parameters of a kernel node in an executable graph \p hGraphExec. + * The node is identified by the corresponding node \p hNode in the + * non-executable graph, from which the executable graph was instantiated. + * + * \p hNode must not have been removed from the original graph. The \p func + * field of \p nodeParams cannot be modified and must match the original value. + * All other values can be modified. + * + * The modifications take effect at the next launch of \p hGraphExec. Already + * enqueued or running launches of \p hGraphExec are not affected by this call. + * \p hNode is also not modified by this call. + * + * \param hGraphExec - The executable graph in which to set the specified node + * \param hNode - kernel node from the graph from which graphExec was + * instantiated \param nodeParams - Updated Parameters to set + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_INVALID_VALUE, + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphAddKernelNode, + * ::cuGraphKernelNodeSetParams, + * ::cuGraphInstantiate + */ +CUresult CUDAAPI +cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, + const CUDA_KERNEL_NODE_PARAMS *nodeParams); + +#endif /* __CUDA_API_VERSION >= 10010 */ + +/** + * \brief Launches an executable graph in a stream + * + * Executes \p hGraphExec in \p hStream. Only one instance of \p hGraphExec may + * be executing at a time. Each launch is ordered behind both any previous work + * in \p hStream and any previous launches of \p hGraphExec. To execute a graph + * concurrently, it must be instantiated multiple times into multiple executable + * graphs. + * + * \param hGraphExec - Executable graph to launch + * \param hStream - Stream in which to launch the graph + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphInstantiate, + * ::cuGraphExecDestroy + */ +CUresult CUDAAPI cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream); + +/** + * \brief Destroys an executable graph + * + * Destroys the executable graph specified by \p hGraphExec, as well + * as all of its executable nodes. If the executable graph is + * in-flight, it will not be terminated, but rather freed + * asynchronously on completion. + * + * \param hGraphExec - Executable graph to destroy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphInstantiate, + * ::cuGraphLaunch + */ +CUresult CUDAAPI cuGraphExecDestroy(CUgraphExec hGraphExec); + +/** + * \brief Destroys a graph + * + * Destroys the graph specified by \p hGraph, as well as all of its nodes. + * + * \param hGraph - Graph to destroy + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_VALUE + * \note_graph_thread_safety + * \notefnerr + * + * \sa + * ::cuGraphCreate + */ +CUresult CUDAAPI cuGraphDestroy(CUgraph hGraph); +/** @} */ /* END CUDA_GRAPH */ +#endif /* __CUDA_API_VERSION >= 10000 */ #if __CUDA_API_VERSION >= 6050 /** @@ -9327,8 +13151,8 @@ CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRe * ___MANBRIEF___ occupancy calculation functions of the low-level CUDA driver * API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the occupancy calculation functions of the low-level CUDA - * driver application programming interface. + * This section describes the occupancy calculation functions of the low-level + * CUDA driver application programming interface. * * @{ */ @@ -9341,8 +13165,9 @@ CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRe * * \param numBlocks - Returned occupancy * \param func - Kernel for which occupancy is calculated - * \param blockSize - Block size the kernel is intended to be launched with - * \param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes + * \param blockSize - Block size the kernel is intended to be launched + * with \param dynamicSMemSize - Per-block dynamic shared memory usage intended, + * in bytes * * \return * ::CUDA_SUCCESS, @@ -9353,8 +13178,11 @@ CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRe * ::CUDA_ERROR_UNKNOWN * \notefnerr * + * \sa + * ::cudaOccupancyMaxActiveBlocksPerMultiprocessor */ -CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize); +CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize); /** * \brief Returns occupancy of a function @@ -9380,9 +13208,10 @@ CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, CUf * * \param numBlocks - Returned occupancy * \param func - Kernel for which occupancy is calculated - * \param blockSize - Block size the kernel is intended to be launched with - * \param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes - * \param flags - Requested behavior for the occupancy calculator + * \param blockSize - Block size the kernel is intended to be launched + * with \param dynamicSMemSize - Per-block dynamic shared memory usage intended, + * in bytes \param flags - Requested behavior for the occupancy + * calculator * * \return * ::CUDA_SUCCESS, @@ -9393,9 +13222,13 @@ CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, CUf * ::CUDA_ERROR_UNKNOWN * \notefnerr * + * \sa + * ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags */ -CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags); - +CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, + unsigned int flags); + /** * \brief Suggest a launch configuration with reasonable occupancy * @@ -9427,12 +13260,14 @@ CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBl * size_t blockToSmem(int blockSize); * \endcode * - * \param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy - * \param blockSize - Returned maximum block size that can achieve the maximum occupancy - * \param func - Kernel for which launch configuration is calculated - * \param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size - * \param dynamicSMemSize - Dynamic shared memory usage intended, in bytes - * \param blockSizeLimit - The maximum block size \p func is designed to handle + * \param minGridSize - Returned minimum grid size needed to achieve the maximum + * occupancy \param blockSize - Returned maximum block size that can achieve + * the maximum occupancy \param func - Kernel for which launch + * configuration is calculated \param blockSizeToDynamicSMemSize - A function + * that calculates how much per-block dynamic shared memory \p func uses based + * on the block size \param dynamicSMemSize - Dynamic shared memory usage + * intended, in bytes \param blockSizeLimit - The maximum block size \p func is + * designed to handle * * \return * ::CUDA_SUCCESS, @@ -9443,8 +13278,13 @@ CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBl * ::CUDA_ERROR_UNKNOWN * \notefnerr * + * \sa + * ::cudaOccupancyMaxPotentialBlockSize */ -CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit); +CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize( + int *minGridSize, int *blockSize, CUfunction func, + CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, + int blockSizeLimit); /** * \brief Suggest a launch configuration with reasonable occupancy @@ -9470,13 +13310,14 @@ CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSi * can be found about this feature in the "Unified L1/Texture Cache" * section of the Maxwell tuning guide. * - * \param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy - * \param blockSize - Returned maximum block size that can achieve the maximum occupancy - * \param func - Kernel for which launch configuration is calculated - * \param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size - * \param dynamicSMemSize - Dynamic shared memory usage intended, in bytes - * \param blockSizeLimit - The maximum block size \p func is designed to handle - * \param flags - Options + * \param minGridSize - Returned minimum grid size needed to achieve the maximum + * occupancy \param blockSize - Returned maximum block size that can achieve + * the maximum occupancy \param func - Kernel for which launch + * configuration is calculated \param blockSizeToDynamicSMemSize - A function + * that calculates how much per-block dynamic shared memory \p func uses based + * on the block size \param dynamicSMemSize - Dynamic shared memory usage + * intended, in bytes \param blockSizeLimit - The maximum block size \p func is + * designed to handle \param flags - Options * * \return * ::CUDA_SUCCESS, @@ -9487,20 +13328,25 @@ CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSi * ::CUDA_ERROR_UNKNOWN * \notefnerr * + * \sa + * ::cudaOccupancyMaxPotentialBlockSizeWithFlags */ -CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags); +CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, int *blockSize, CUfunction func, + CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, + int blockSizeLimit, unsigned int flags); /** @} */ /* END CUDA_OCCUPANCY */ -#endif /* __CUDA_API_VERSION >= 6050 */ +#endif /* __CUDA_API_VERSION >= 6050 */ /** - * \defgroup CUDA_TEXREF Texture Reference Management + * \defgroup CUDA_TEXREF_DEPRECATED Texture Reference Management [DEPRECATED] * - * ___MANBRIEF___ texture reference management functions of the low-level CUDA - * driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ + * ___MANBRIEF___ deprecated texture reference management functions of the + * low-level CUDA driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the texture reference management functions of the - * low-level CUDA driver application programming interface. + * This section describes the deprecated texture reference management + * functions of the low-level CUDA driver application programming interface. * * @{ */ @@ -9508,6 +13354,8 @@ CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int /** * \brief Binds an array as a texture reference * + * \deprecated + * * Binds the CUDA array \p hArray to the texture reference \p hTexRef. Any * previous address or CUDA array state associated with the texture reference * is superseded by this function. \p Flags must be set to @@ -9529,17 +13377,22 @@ CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToArray */ -CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags); +CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, + unsigned int Flags); /** * \brief Binds a mipmapped array to a texture reference * - * Binds the CUDA mipmapped array \p hMipmappedArray to the texture reference \p hTexRef. - * Any previous address or CUDA array state associated with the texture reference - * is superseded by this function. \p Flags must be set to ::CU_TRSA_OVERRIDE_FORMAT. - * Any CUDA array previously bound to \p hTexRef is unbound. + * \deprecated + * + * Binds the CUDA mipmapped array \p hMipmappedArray to the texture reference \p + * hTexRef. Any previous address or CUDA array state associated with the texture + * reference is superseded by this function. \p Flags must be set to + * ::CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to \p hTexRef is + * unbound. * * \param hTexRef - Texture reference to bind * \param hMipmappedArray - Mipmapped array to bind @@ -9556,14 +13409,19 @@ CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, unsigned int Flags); +CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, + CUmipmappedArray hMipmappedArray, + unsigned int Flags); #if __CUDA_API_VERSION >= 3020 /** * \brief Binds an address as a texture reference * + * \deprecated + * * Binds a linear address range to the texture reference \p hTexRef. Any * previous address or CUDA array state associated with the texture reference * is superseded by this function. Any memory previously bound to \p hTexRef @@ -9582,7 +13440,7 @@ CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hM * The total number of elements (or texels) in the linear address range * cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. * The number of elements is computed as (\p bytes / bytesPerElement), - * where bytesPerElement is determined from the data format and number of + * where bytesPerElement is determined from the data format and number of * components set using ::cuTexRefSetFormat(). * * \param ByteOffset - Returned byte offset @@ -9600,13 +13458,17 @@ CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hM * \sa ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTexture */ -CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t bytes); +CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, + CUdeviceptr dptr, size_t bytes); /** * \brief Binds an address as a 2D texture reference * + * \deprecated + * * Binds a linear address range to the texture reference \p hTexRef. Any * previous address or CUDA array state associated with the texture reference * is superseded by this function. Any memory previously bound to \p hTexRef @@ -9626,14 +13488,14 @@ CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdevi * supplied, ::CUDA_ERROR_INVALID_VALUE is returned. * * \p Pitch has to be aligned to the hardware-specific texture pitch alignment. - * This value can be queried using the device attribute - * ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. If an unaligned \p Pitch is + * This value can be queried using the device attribute + * ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. If an unaligned \p Pitch is * supplied, ::CUDA_ERROR_INVALID_VALUE is returned. * * Width and Height, which are specified in elements (or texels), cannot exceed * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively. - * \p Pitch, which is specified in bytes, cannot exceed + * \p Pitch, which is specified in bytes, cannot exceed * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH. * * \param hTexRef - Texture reference to bind @@ -9652,14 +13514,19 @@ CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdevi * ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTexture2D */ -CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch); +CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, + const CUDA_ARRAY_DESCRIPTOR *desc, + CUdeviceptr dptr, size_t Pitch); #endif /* __CUDA_API_VERSION >= 3020 */ /** * \brief Sets the format for a texture reference * + * \deprecated + * * Specifies the format of the data to be read by the texture reference * \p hTexRef. \p fmt and \p NumPackedComponents are exactly analogous to the * ::Format and ::NumChannels members of the ::CUDA_ARRAY_DESCRIPTOR structure: @@ -9681,13 +13548,21 @@ CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIP * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaCreateChannelDesc, + * ::cudaBindTexture, + * ::cudaBindTexture2D, + * ::cudaBindTextureToArray, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents); +CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, + int NumPackedComponents); /** * \brief Sets the addressing mode for a texture reference * + * \deprecated + * * Specifies the addressing mode \p am for the given dimension \p dim of the * texture reference \p hTexRef. If \p dim is zero, the addressing mode is * applied to the first parameter of the functions used to fetch from the @@ -9703,7 +13578,7 @@ CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int Num * \endcode * * Note that this call has no effect if \p hTexRef is bound to linear memory. - * Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES, is not set, the only + * Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES, is not set, the only * supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP. * * \param hTexRef - Texture reference @@ -9721,13 +13596,20 @@ CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int Num * ::cuTexRefSetAddress2D, ::cuTexRefSetArray, * ::cuTexRefSetFilterMode, ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTexture, + * ::cudaBindTexture2D, + * ::cudaBindTextureToArray, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am); +CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, + CUaddress_mode am); /** * \brief Sets the filtering mode for a texture reference * + * \deprecated + * * Specifies the filtering mode \p fm to be used when reading memory through * the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as: * @@ -9754,14 +13636,18 @@ CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mod * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToArray */ CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm); /** * \brief Sets the mipmap filtering mode for a texture reference * - * Specifies the mipmap filtering mode \p fm to be used when reading memory through + * \deprecated + * + * Specifies the mipmap filtering mode \p fm to be used when reading memory + through * the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as: * * \code @@ -9771,7 +13657,8 @@ CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm); } CUfilter_mode; * \endcode * - * Note that this call has no effect if \p hTexRef is not bound to a mipmapped array. + * Note that this call has no effect if \p hTexRef is not bound to a mipmapped + array. * * \param hTexRef - Texture reference * \param fm - Filtering mode to set @@ -9787,17 +13674,22 @@ CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm); * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm); +CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, + CUfilter_mode fm); /** * \brief Sets the mipmap level bias for a texture reference * - * Specifies the mipmap level bias \p bias to be added to the specified mipmap level when - * reading memory through the texture reference \p hTexRef. + * \deprecated + * + * Specifies the mipmap level bias \p bias to be added to the specified mipmap + * level when reading memory through the texture reference \p hTexRef. * - * Note that this call has no effect if \p hTexRef is not bound to a mipmapped array. + * Note that this call has no effect if \p hTexRef is not bound to a mipmapped + * array. * * \param hTexRef - Texture reference * \param bias - Mipmap level bias @@ -9813,18 +13705,22 @@ CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm) * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToMipmappedArray */ CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias); /** * \brief Sets the mipmap min/max mipmap level clamps for a texture reference * - * Specifies the min/max mipmap level clamps, \p minMipmapLevelClamp and \p maxMipmapLevelClamp - * respectively, to be used when reading memory through the texture reference - * \p hTexRef. + * \deprecated + * + * Specifies the min/max mipmap level clamps, \p minMipmapLevelClamp and \p + * maxMipmapLevelClamp respectively, to be used when reading memory through the + * texture reference \p hTexRef. * - * Note that this call has no effect if \p hTexRef is not bound to a mipmapped array. + * Note that this call has no effect if \p hTexRef is not bound to a mipmapped + * array. * * \param hTexRef - Texture reference * \param minMipmapLevelClamp - Mipmap min level clamp @@ -9841,15 +13737,20 @@ CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias); * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp); +CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, + float minMipmapLevelClamp, + float maxMipmapLevelClamp); /** * \brief Sets the maximum anisotropy for a texture reference * - * Specifies the maximum anisotropy \p maxAniso to be used when reading memory through - * the texture reference \p hTexRef. + * \deprecated + * + * Specifies the maximum anisotropy \p maxAniso to be used when reading memory + * through the texture reference \p hTexRef. * * Note that this call has no effect if \p hTexRef is bound to linear memory. * @@ -9867,24 +13768,28 @@ CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLe * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFlags, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTextureToArray, + * ::cudaBindTextureToMipmappedArray */ -CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso); +CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, + unsigned int maxAniso); /** * \brief Sets the border color for a texture reference * - * Specifies the value of the RGBA color via the \p pBorderColor to the texture reference - * \p hTexRef. The color value supports only float type and holds color components in - * the following sequence: - * pBorderColor[0] holds 'R' component - * pBorderColor[1] holds 'G' component - * pBorderColor[2] holds 'B' component - * pBorderColor[3] holds 'A' component + * \deprecated + * + * Specifies the value of the RGBA color via the \p pBorderColor to the texture + * reference \p hTexRef. The color value supports only float type and holds + * color components in the following sequence: pBorderColor[0] holds 'R' + * component pBorderColor[1] holds 'G' component pBorderColor[2] holds 'B' + * component pBorderColor[3] holds 'A' component * * Note that the color values can be set only when the Address mode is set to * CU_TR_ADDRESS_MODE_BORDER using ::cuTexRefSetAddressMode. - * Applications using integer border color values have to "reinterpret_cast" their values to float. + * Applications using integer border color values have to "reinterpret_cast" + * their values to float. * * \param hTexRef - Texture reference * \param pBorderColor - RGBA color @@ -9897,13 +13802,19 @@ CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAnis * ::CUDA_ERROR_INVALID_VALUE * * \sa ::cuTexRefSetAddressMode, - * ::cuTexRefGetAddressMode, ::cuTexRefGetBorderColor + * ::cuTexRefGetAddressMode, ::cuTexRefGetBorderColor, + * ::cudaBindTexture, + * ::cudaBindTexture2D, + * ::cudaBindTextureToArray, + * ::cudaBindTextureToMipmappedArray */ CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor); /** * \brief Sets the flags for a texture reference * + * \deprecated + * * Specifies optional flags via \p Flags to specify the behavior of data * returned through the texture reference \p hTexRef. The valid flags are: * @@ -9912,7 +13823,7 @@ CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor); * range [0, 1]. Note that texture with 32-bit integer format * would not be promoted, regardless of whether or not this * flag is specified; - * - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the + * - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the * default behavior of having the texture coordinates range * from [0, Dim) where Dim is the width or height of the CUDA * array. Instead, the texture coordinates [0, 1.0) reference @@ -9932,7 +13843,11 @@ CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor); * ::cuTexRefSetAddress2D, ::cuTexRefSetAddressMode, ::cuTexRefSetArray, * ::cuTexRefSetFilterMode, ::cuTexRefSetFormat, * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, - * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat + * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat, + * ::cudaBindTexture, + * ::cudaBindTexture2D, + * ::cudaBindTextureToArray, + * ::cudaBindTextureToMipmappedArray */ CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags); @@ -9940,6 +13855,8 @@ CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags); /** * \brief Gets the address associated with a texture reference * + * \deprecated + * * Returns in \p *pdptr the base address bound to the texture reference * \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference * is not bound to any device memory range. @@ -9966,6 +13883,8 @@ CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef); /** * \brief Gets the array bound to a texture reference * + * \deprecated + * * Returns in \p *phArray the CUDA array bound to the texture reference * \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference * is not bound to any CUDA array. @@ -9991,9 +13910,11 @@ CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef); /** * \brief Gets the mipmapped array bound to a texture reference * - * Returns in \p *phMipmappedArray the CUDA mipmapped array bound to the texture - * reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference - * is not bound to any CUDA mipmapped array. + * \deprecated + * + * Returns in \p *phMipmappedArray the CUDA mipmapped array bound to the texture + * reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture + * reference is not bound to any CUDA mipmapped array. * * \param phMipmappedArray - Returned mipmapped array * \param hTexRef - Texture reference @@ -10011,11 +13932,14 @@ CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef); * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat */ -CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, CUtexref hTexRef); +CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, + CUtexref hTexRef); /** * \brief Gets the addressing mode used by a texture reference * + * \deprecated + * * Returns in \p *pam the addressing mode corresponding to the * dimension \p dim of the texture reference \p hTexRef. Currently, the only * valid value for \p dim are 0 and 1. @@ -10037,11 +13961,14 @@ CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, C * ::cuTexRefGetAddress, ::cuTexRefGetArray, * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat */ -CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, int dim); +CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, + int dim); /** * \brief Gets the filter-mode used by a texture reference * + * \deprecated + * * Returns in \p *pfm the filtering mode of the texture reference * \p hTexRef. * @@ -10066,6 +13993,8 @@ CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef); /** * \brief Gets the format used by a texture reference * + * \deprecated + * * Returns in \p *pFormat and \p *pNumChannels the format and number * of components of the CUDA array bound to the texture reference \p hTexRef. * If \p pFormat or \p pNumChannels is NULL, it will be ignored. @@ -10087,13 +14016,16 @@ CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef); * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags */ -CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, CUtexref hTexRef); +CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, + CUtexref hTexRef); /** * \brief Gets the mipmap filtering mode for a texture reference * - * Returns the mipmap filtering mode in \p pfm that's used when reading memory through - * the texture reference \p hTexRef. + * \deprecated + * + * Returns the mipmap filtering mode in \p pfm that's used when reading memory + * through the texture reference \p hTexRef. * * \param pfm - Returned mipmap filtering mode * \param hTexRef - Texture reference @@ -10111,13 +14043,16 @@ CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, C * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat */ -CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm, CUtexref hTexRef); +CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm, + CUtexref hTexRef); /** * \brief Gets the mipmap level bias for a texture reference * - * Returns the mipmap level bias in \p pBias that's added to the specified mipmap - * level when reading memory through the texture reference \p hTexRef. + * \deprecated + * + * Returns the mipmap level bias in \p pBias that's added to the specified + * mipmap level when reading memory through the texture reference \p hTexRef. * * \param pbias - Returned mipmap level bias * \param hTexRef - Texture reference @@ -10140,8 +14075,11 @@ CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef); /** * \brief Gets the min/max mipmap level clamps for a texture reference * - * Returns the min/max mipmap level clamps in \p pminMipmapLevelClamp and \p pmaxMipmapLevelClamp - * that's used when reading memory through the texture reference \p hTexRef. + * \deprecated + * + * Returns the min/max mipmap level clamps in \p pminMipmapLevelClamp and \p + * pmaxMipmapLevelClamp that's used when reading memory through the texture + * reference \p hTexRef. * * \param pminMipmapLevelClamp - Returned mipmap min level clamp * \param pmaxMipmapLevelClamp - Returned mipmap max level clamp @@ -10160,13 +14098,17 @@ CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef); * ::cuTexRefGetAddress, ::cuTexRefGetAddressMode, ::cuTexRefGetArray, * ::cuTexRefGetFilterMode, ::cuTexRefGetFlags, ::cuTexRefGetFormat */ -CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, CUtexref hTexRef); +CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, + float *pmaxMipmapLevelClamp, + CUtexref hTexRef); /** * \brief Gets the maximum anisotropy for a texture reference * - * Returns the maximum anisotropy in \p pmaxAniso that's used when reading memory through - * the texture reference \p hTexRef. + * \deprecated + * + * Returns the maximum anisotropy in \p pmaxAniso that's used when reading + * memory through the texture reference \p hTexRef. * * \param pmaxAniso - Returned maximum anisotropy * \param hTexRef - Texture reference @@ -10189,6 +14131,8 @@ CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef); /** * \brief Gets the border color used by a texture reference * + * \deprecated + * * Returns in \p pBorderColor, values of the RGBA color used by * the texture reference \p hTexRef. * The color value is of type float and holds color components in @@ -10211,11 +14155,13 @@ CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef); * \sa ::cuTexRefSetAddressMode, * ::cuTexRefSetAddressMode, ::cuTexRefSetBorderColor */ -CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef); +CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef); /** * \brief Gets the flags used by a texture reference * + * \deprecated + * * Returns in \p *pFlags the flags of the texture reference \p hTexRef. * * \param pFlags - Returned flags @@ -10236,20 +14182,6 @@ CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef); */ CUresult CUDAAPI cuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef); -/** @} */ /* END CUDA_TEXREF */ - -/** - * \defgroup CUDA_TEXREF_DEPRECATED Texture Reference Management [DEPRECATED] - * - * ___MANBRIEF___ deprecated texture reference management functions of the - * low-level CUDA driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ - * - * This section describes the deprecated texture reference management - * functions of the low-level CUDA driver application programming interface. - * - * @{ - */ - /** * \brief Creates a texture reference * @@ -10297,9 +14229,8 @@ CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef); /** @} */ /* END CUDA_TEXREF_DEPRECATED */ - /** - * \defgroup CUDA_SURFREF Surface Reference Management + * \defgroup CUDA_SURFREF_DEPRECATED Surface Reference Management [DEPRECATED] * * ___MANBRIEF___ surface reference management functions of the low-level CUDA * driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ @@ -10313,6 +14244,8 @@ CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef); /** * \brief Sets the CUDA array for a surface reference. * + * \deprecated + * * Sets the CUDA array \p hArray to be read and written by the surface reference * \p hSurfRef. Any previous CUDA array state associated with the surface * reference is superseded by this function. \p Flags must be set to 0. @@ -10330,13 +14263,19 @@ CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef); * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuModuleGetSurfRef, ::cuSurfRefGetArray + * \sa + * ::cuModuleGetSurfRef, + * ::cuSurfRefGetArray, + * ::cudaBindSurfaceToArray */ -CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags); +CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, + unsigned int Flags); /** * \brief Passes back the CUDA array bound to a surface reference. * + * \deprecated + * * Returns in \p *phArray the CUDA array bound to the surface reference * \p hSurfRef, or returns ::CUDA_ERROR_INVALID_VALUE if the surface reference * is not bound to any CUDA array. @@ -10355,7 +14294,7 @@ CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned */ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); -/** @} */ /* END CUDA_SURFREF */ +/** @} */ /* END CUDA_SURFREF_DEPRECATED */ #if __CUDA_API_VERSION >= 5000 /** @@ -10374,15 +14313,21 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); /** * \brief Creates a texture object * - * Creates a texture object and returns it in \p pTexObject. \p pResDesc describes - * the data to texture from. \p pTexDesc describes how the data should be sampled. - * \p pResViewDesc is an optional argument that specifies an alternate format for + * Creates a texture object and returns it in \p pTexObject. \p pResDesc + describes + * the data to texture from. \p pTexDesc describes how the data should be + sampled. + * \p pResViewDesc is an optional argument that specifies an alternate format + for * the data described by \p pResDesc, and also describes the subresource region - * to restrict access to when texturing. \p pResViewDesc can only be specified if + * to restrict access to when texturing. \p pResViewDesc can only be specified + if * the type of resource is a CUDA array or a CUDA mipmapped array. * - * Texture objects are only supported on devices of compute capability 3.0 or higher. - * Additionally, a texture object is an opaque value, and, as such, should only be + * Texture objects are only supported on devices of compute capability 3.0 or + higher. + * Additionally, a texture object is an opaque value, and, as such, should only + be * accessed through CUDA API calls. * * The ::CUDA_RESOURCE_DESC structure is defined as: @@ -10419,7 +14364,8 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); * \endcode * where: - * - ::CUDA_RESOURCE_DESC::resType specifies the type of resource to texture from. + * - ::CUDA_RESOURCE_DESC::resType specifies the type of resource to texture + from. * CUresourceType is defined as: * \code typedef enum CUresourcetype_enum { @@ -10431,30 +14377,47 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); * \endcode * * \par - * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_ARRAY, ::CUDA_RESOURCE_DESC::res::array::hArray + * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_ARRAY, + ::CUDA_RESOURCE_DESC::res::array::hArray * must be set to a valid CUDA array handle. * * \par - * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, ::CUDA_RESOURCE_DESC::res::mipmap::hMipmappedArray + * If ::CUDA_RESOURCE_DESC::resType is set to + ::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, + ::CUDA_RESOURCE_DESC::res::mipmap::hMipmappedArray * must be set to a valid CUDA mipmapped array handle. * * \par - * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_LINEAR, ::CUDA_RESOURCE_DESC::res::linear::devPtr - * must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. - * ::CUDA_RESOURCE_DESC::res::linear::format and ::CUDA_RESOURCE_DESC::res::linear::numChannels - * describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::linear::sizeInBytes - * specifies the size of the array in bytes. The total number of elements in the linear address range cannot exceed - * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. The number of elements is computed as (sizeInBytes / (sizeof(format) * numChannels)). + * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_LINEAR, + ::CUDA_RESOURCE_DESC::res::linear::devPtr + * must be set to a valid device pointer, that is aligned to + ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. + * ::CUDA_RESOURCE_DESC::res::linear::format and + ::CUDA_RESOURCE_DESC::res::linear::numChannels + * describe the format of each component and the number of components per array + element. ::CUDA_RESOURCE_DESC::res::linear::sizeInBytes + * specifies the size of the array in bytes. The total number of elements in the + linear address range cannot exceed + * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. The number of elements + is computed as (sizeInBytes / (sizeof(format) * numChannels)). * * \par - * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_PITCH2D, ::CUDA_RESOURCE_DESC::res::pitch2D::devPtr - * must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. - * ::CUDA_RESOURCE_DESC::res::pitch2D::format and ::CUDA_RESOURCE_DESC::res::pitch2D::numChannels - * describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::pitch2D::width - * and ::CUDA_RESOURCE_DESC::res::pitch2D::height specify the width and height of the array in elements, and cannot exceed - * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively. - * ::CUDA_RESOURCE_DESC::res::pitch2D::pitchInBytes specifies the pitch between two rows in bytes and has to be aligned to - * ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. Pitch cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH. + * If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_PITCH2D, + ::CUDA_RESOURCE_DESC::res::pitch2D::devPtr + * must be set to a valid device pointer, that is aligned to + ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. + * ::CUDA_RESOURCE_DESC::res::pitch2D::format and + ::CUDA_RESOURCE_DESC::res::pitch2D::numChannels + * describe the format of each component and the number of components per array + element. ::CUDA_RESOURCE_DESC::res::pitch2D::width + * and ::CUDA_RESOURCE_DESC::res::pitch2D::height specify the width and height + of the array in elements, and cannot exceed + * ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and + ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively. + * ::CUDA_RESOURCE_DESC::res::pitch2D::pitchInBytes specifies the pitch between + two rows in bytes and has to be aligned to + * ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. Pitch cannot exceed + ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH. * * - ::flags must be set to zero. * @@ -10473,7 +14436,8 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); } CUDA_TEXTURE_DESC; * \endcode * where - * - ::CUDA_TEXTURE_DESC::addressMode specifies the addressing mode for each dimension of the texture data. ::CUaddress_mode is defined as: + * - ::CUDA_TEXTURE_DESC::addressMode specifies the addressing mode for each + dimension of the texture data. ::CUaddress_mode is defined as: * \code typedef enum CUaddress_mode_enum { CU_TR_ADDRESS_MODE_WRAP = 0, @@ -10482,35 +14446,47 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); CU_TR_ADDRESS_MODE_BORDER = 3 } CUaddress_mode; * \endcode - * This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR. Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES + * This is ignored if ::CUDA_RESOURCE_DESC::resType is + ::CU_RESOURCE_TYPE_LINEAR. Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES * is not set, the only supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP. * - * - ::CUDA_TEXTURE_DESC::filterMode specifies the filtering mode to be used when fetching from the texture. CUfilter_mode is defined as: + * - ::CUDA_TEXTURE_DESC::filterMode specifies the filtering mode to be used + when fetching from the texture. CUfilter_mode is defined as: * \code typedef enum CUfilter_mode_enum { CU_TR_FILTER_MODE_POINT = 0, CU_TR_FILTER_MODE_LINEAR = 1 } CUfilter_mode; * \endcode - * This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR. + * This is ignored if ::CUDA_RESOURCE_DESC::resType is + ::CU_RESOURCE_TYPE_LINEAR. * * - ::CUDA_TEXTURE_DESC::flags can be any combination of the following: - * - ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of having the texture promote integer data to floating point data in the - * range [0, 1]. Note that texture with 32-bit integer format would not be promoted, regardless of whether or not this flag is specified. - * - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the default behavior of having the texture coordinates range from [0, Dim) where Dim is - * the width or height of the CUDA array. Instead, the texture coordinates [0, 1.0) reference the entire breadth of the array dimension; Note + * - ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of + having the texture promote integer data to floating point data in the + * range [0, 1]. Note that texture with 32-bit integer format would not be + promoted, regardless of whether or not this flag is specified. + * - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the default behavior + of having the texture coordinates range from [0, Dim) where Dim is + * the width or height of the CUDA array. Instead, the texture coordinates + [0, 1.0) reference the entire breadth of the array dimension; Note * that for CUDA mipmapped arrays, this flag has to be set. * - * - ::CUDA_TEXTURE_DESC::maxAnisotropy specifies the maximum anisotropy ratio to be used when doing anisotropic filtering. This value will be + * - ::CUDA_TEXTURE_DESC::maxAnisotropy specifies the maximum anisotropy ratio + to be used when doing anisotropic filtering. This value will be * clamped to the range [1,16]. * - * - ::CUDA_TEXTURE_DESC::mipmapFilterMode specifies the filter mode when the calculated mipmap level lies between two defined mipmap levels. + * - ::CUDA_TEXTURE_DESC::mipmapFilterMode specifies the filter mode when the + calculated mipmap level lies between two defined mipmap levels. * - * - ::CUDA_TEXTURE_DESC::mipmapLevelBias specifies the offset to be applied to the calculated mipmap level. + * - ::CUDA_TEXTURE_DESC::mipmapLevelBias specifies the offset to be applied to + the calculated mipmap level. * - * - ::CUDA_TEXTURE_DESC::minMipmapLevelClamp specifies the lower end of the mipmap level range to clamp access to. + * - ::CUDA_TEXTURE_DESC::minMipmapLevelClamp specifies the lower end of the + mipmap level range to clamp access to. * - * - ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp specifies the upper end of the mipmap level range to clamp access to. + * - ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp specifies the upper end of the + mipmap level range to clamp access to. * * * The ::CUDA_RESOURCE_VIEW_DESC struct is defined as @@ -10528,43 +14504,60 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); } CUDA_RESOURCE_VIEW_DESC; * \endcode * where: - * - ::CUDA_RESOURCE_VIEW_DESC::format specifies how the data contained in the CUDA array or CUDA mipmapped array should - * be interpreted. Note that this can incur a change in size of the texture data. If the resource view format is a block - * compressed format, then the underlying CUDA array or CUDA mipmapped array has to have a base of format ::CU_AD_FORMAT_UNSIGNED_INT32. - * with 2 or 4 channels, depending on the block compressed format. For ex., BC1 and BC4 require the underlying CUDA array to have - * a format of ::CU_AD_FORMAT_UNSIGNED_INT32 with 2 channels. The other BC formats require the underlying resource to have the same base + * - ::CUDA_RESOURCE_VIEW_DESC::format specifies how the data contained in the + CUDA array or CUDA mipmapped array should + * be interpreted. Note that this can incur a change in size of the texture + data. If the resource view format is a block + * compressed format, then the underlying CUDA array or CUDA mipmapped array + has to have a base of format ::CU_AD_FORMAT_UNSIGNED_INT32. + * with 2 or 4 channels, depending on the block compressed format. For ex., + BC1 and BC4 require the underlying CUDA array to have + * a format of ::CU_AD_FORMAT_UNSIGNED_INT32 with 2 channels. The other BC + formats require the underlying resource to have the same base * format but with 4 channels. * - * - ::CUDA_RESOURCE_VIEW_DESC::width specifies the new width of the texture data. If the resource view format is a block - * compressed format, this value has to be 4 times the original width of the resource. For non block compressed formats, + * - ::CUDA_RESOURCE_VIEW_DESC::width specifies the new width of the texture + data. If the resource view format is a block + * compressed format, this value has to be 4 times the original width of the + resource. For non block compressed formats, * this value has to be equal to that of the original resource. * - * - ::CUDA_RESOURCE_VIEW_DESC::height specifies the new height of the texture data. If the resource view format is a block - * compressed format, this value has to be 4 times the original height of the resource. For non block compressed formats, + * - ::CUDA_RESOURCE_VIEW_DESC::height specifies the new height of the texture + data. If the resource view format is a block + * compressed format, this value has to be 4 times the original height of the + resource. For non block compressed formats, * this value has to be equal to that of the original resource. * - * - ::CUDA_RESOURCE_VIEW_DESC::depth specifies the new depth of the texture data. This value has to be equal to that of the + * - ::CUDA_RESOURCE_VIEW_DESC::depth specifies the new depth of the texture + data. This value has to be equal to that of the * original resource. * - * - ::CUDA_RESOURCE_VIEW_DESC::firstMipmapLevel specifies the most detailed mipmap level. This will be the new mipmap level zero. - * For non-mipmapped resources, this value has to be zero.::CUDA_TEXTURE_DESC::minMipmapLevelClamp and ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp - * will be relative to this value. For ex., if the firstMipmapLevel is set to 2, and a minMipmapLevelClamp of 1.2 is specified, + * - ::CUDA_RESOURCE_VIEW_DESC::firstMipmapLevel specifies the most detailed + mipmap level. This will be the new mipmap level zero. + * For non-mipmapped resources, this value has to be + zero.::CUDA_TEXTURE_DESC::minMipmapLevelClamp and + ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp + * will be relative to this value. For ex., if the firstMipmapLevel is set to + 2, and a minMipmapLevelClamp of 1.2 is specified, * then the actual minimum mipmap level clamp will be 3.2. * - * - ::CUDA_RESOURCE_VIEW_DESC::lastMipmapLevel specifies the least detailed mipmap level. For non-mipmapped resources, this value + * - ::CUDA_RESOURCE_VIEW_DESC::lastMipmapLevel specifies the least detailed + mipmap level. For non-mipmapped resources, this value * has to be zero. * - * - ::CUDA_RESOURCE_VIEW_DESC::firstLayer specifies the first layer index for layered textures. This will be the new layer zero. + * - ::CUDA_RESOURCE_VIEW_DESC::firstLayer specifies the first layer index for + layered textures. This will be the new layer zero. * For non-layered resources, this value has to be zero. * - * - ::CUDA_RESOURCE_VIEW_DESC::lastLayer specifies the last layer index for layered textures. For non-layered resources, + * - ::CUDA_RESOURCE_VIEW_DESC::lastLayer specifies the last layer index for + layered textures. For non-layered resources, * this value has to be zero. * * * \param pTexObject - Texture object to create * \param pResDesc - Resource descriptor * \param pTexDesc - Texture descriptor - * \param pResViewDesc - Resource view descriptor + * \param pResViewDesc - Resource view descriptor * * \return * ::CUDA_SUCCESS, @@ -10573,9 +14566,14 @@ CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef); * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuTexObjectDestroy + * \sa + * ::cuTexObjectDestroy, + * ::cudaCreateTextureObject */ -CUresult CUDAAPI cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_DESC *pResDesc, const CUDA_TEXTURE_DESC *pTexDesc, const CUDA_RESOURCE_VIEW_DESC *pResViewDesc); +CUresult CUDAAPI cuTexObjectCreate(CUtexObject *pTexObject, + const CUDA_RESOURCE_DESC *pResDesc, + const CUDA_TEXTURE_DESC *pTexDesc, + const CUDA_RESOURCE_VIEW_DESC *pResViewDesc); /** * \brief Destroys a texture object @@ -10591,14 +14589,17 @@ CUresult CUDAAPI cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_ * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuTexObjectCreate + * \sa + * ::cuTexObjectCreate, + * ::cudaDestroyTextureObject */ CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject); /** * \brief Returns a texture object's resource descriptor * - * Returns the resource descriptor for the texture object specified by \p texObject. + * Returns the resource descriptor for the texture object specified by \p + * texObject. * * \param pResDesc - Resource descriptor * \param texObject - Texture object @@ -10610,14 +14611,18 @@ CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject); * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuTexObjectCreate + * \sa + * ::cuTexObjectCreate, + * ::cudaGetTextureObjectResourceDesc, */ -CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUtexObject texObject); +CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, + CUtexObject texObject); /** * \brief Returns a texture object's texture descriptor * - * Returns the texture descriptor for the texture object specified by \p texObject. + * Returns the texture descriptor for the texture object specified by \p + * texObject. * * \param pTexDesc - Texture descriptor * \param texObject - Texture object @@ -10629,15 +14634,19 @@ CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUtexO * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuTexObjectCreate + * \sa + * ::cuTexObjectCreate, + * ::cudaGetTextureObjectTextureDesc */ -CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, CUtexObject texObject); +CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, + CUtexObject texObject); /** * \brief Returns a texture object's resource view descriptor * - * Returns the resource view descriptor for the texture object specified by \p texObject. - * If no resource view was set for \p texObject, the ::CUDA_ERROR_INVALID_VALUE is returned. + * Returns the resource view descriptor for the texture object specified by \p + * texObject. If no resource view was set for \p texObject, the + * ::CUDA_ERROR_INVALID_VALUE is returned. * * \param pResViewDesc - Resource view descriptor * \param texObject - Texture object @@ -10649,9 +14658,12 @@ CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, CUtexObj * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuTexObjectCreate + * \sa + * ::cuTexObjectCreate, + * ::cudaGetTextureObjectResourceViewDesc */ -CUresult CUDAAPI cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject); +CUresult CUDAAPI cuTexObjectGetResourceViewDesc( + CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject); /** @} */ /* END CUDA_TEXOBJECT */ @@ -10671,14 +14683,16 @@ CUresult CUDAAPI cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *pResVie /** * \brief Creates a surface object * - * Creates a surface object and returns it in \p pSurfObject. \p pResDesc describes - * the data to perform surface load/stores on. ::CUDA_RESOURCE_DESC::resType must be + * Creates a surface object and returns it in \p pSurfObject. \p pResDesc + * describes the data to perform surface load/stores on. + * ::CUDA_RESOURCE_DESC::resType must be * ::CU_RESOURCE_TYPE_ARRAY and ::CUDA_RESOURCE_DESC::res::array::hArray - * must be set to a valid CUDA array handle. ::CUDA_RESOURCE_DESC::flags must be set to zero. + * must be set to a valid CUDA array handle. ::CUDA_RESOURCE_DESC::flags must be + * set to zero. * - * Surface objects are only supported on devices of compute capability 3.0 or higher. - * Additionally, a surface object is an opaque value, and, as such, should only be - * accessed through CUDA API calls. + * Surface objects are only supported on devices of compute capability 3.0 or + * higher. Additionally, a surface object is an opaque value, and, as such, + * should only be accessed through CUDA API calls. * * \param pSurfObject - Surface object to create * \param pResDesc - Resource descriptor @@ -10690,9 +14704,12 @@ CUresult CUDAAPI cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *pResVie * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuSurfObjectDestroy + * \sa + * ::cuSurfObjectDestroy, + * ::cudaCreateSurfaceObject */ -CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, const CUDA_RESOURCE_DESC *pResDesc); +CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, + const CUDA_RESOURCE_DESC *pResDesc); /** * \brief Destroys a surface object @@ -10708,14 +14725,17 @@ CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, const CUDA_RESOUR * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuSurfObjectCreate + * \sa + * ::cuSurfObjectCreate, + * ::cudaDestroySurfaceObject */ CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject); /** * \brief Returns a surface object's resource descriptor * - * Returns the resource descriptor for the surface object specified by \p surfObject. + * Returns the resource descriptor for the surface object specified by \p + * surfObject. * * \param pResDesc - Resource descriptor * \param surfObject - Surface object @@ -10727,39 +14747,43 @@ CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject); * ::CUDA_ERROR_INVALID_CONTEXT, * ::CUDA_ERROR_INVALID_VALUE * - * \sa ::cuSurfObjectCreate + * \sa + * ::cuSurfObjectCreate, + * ::cudaGetSurfaceObjectResourceDesc */ -CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUsurfObject surfObject); +CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, + CUsurfObject surfObject); /** @} */ /* END CUDA_SURFOBJECT */ -#endif /* __CUDA_API_VERSION >= 5000 */ +#endif /* __CUDA_API_VERSION >= 5000 */ -#if __CUDA_API_VERSION >= 4000 /** * \defgroup CUDA_PEER_ACCESS Peer Context Memory Access * * ___MANBRIEF___ direct peer context memory access functions of the low-level * CUDA driver API (___CURRENT_FILE___) ___ENDMANBRIEF___ * - * This section describes the direct peer context memory access functions + * This section describes the direct peer context memory access functions * of the low-level CUDA driver application programming interface. * * @{ */ - + +#if __CUDA_API_VERSION >= 4000 + /** * \brief Queries if a device may directly access a peer device's memory. * - * Returns in \p *canAccessPeer a value of 1 if contexts on \p dev are capable of - * directly accessing memory from contexts on \p peerDev and 0 otherwise. - * If direct access of \p peerDev from \p dev is possible, then access may be + * Returns in \p *canAccessPeer a value of 1 if contexts on \p dev are capable + * of directly accessing memory from contexts on \p peerDev and 0 otherwise. If + * direct access of \p peerDev from \p dev is possible, then access may be * enabled on two specific contexts by calling ::cuCtxEnablePeerAccess(). * * \param canAccessPeer - Returned access capability * \param dev - Device from which allocations on \p peerDev are to * be directly accessed. - * \param peerDev - Device on which the allocations to be directly accessed - * by \p dev reside. + * \param peerDev - Device on which the allocations to be directly + * accessed by \p dev reside. * * \return * ::CUDA_SUCCESS, @@ -10768,80 +14792,48 @@ CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUsur * ::CUDA_ERROR_INVALID_DEVICE * \notefnerr * - * \sa ::cuCtxEnablePeerAccess, - * ::cuCtxDisablePeerAccess - */ -CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev, CUdevice peerDev); - - -/** - * \brief Queries attributes of the link between two devices. - * - * Returns in \p *value the value of the requested attribute \p attrib of the - * link between \p srcDevice and \p dstDevice. The supported attributes are: - * - ::CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: A relative value indicating the - * performance of the link between two devices. - * - ::CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED P2P: 1 if P2P Access is enable. - * - ::CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: 1 if Atomic operations over - * the link are supported. - * - * Returns ::CUDA_ERROR_INVALID_DEVICE if \p srcDevice or \p dstDevice are not valid - * or if they represent the same device. - * - * Returns ::CUDA_ERROR_INVALID_VALUE if \p attrib is not valid or if \p value is - * a null pointer. - * - * \param value - Returned value of the requested attribute - * \param attrib - The requested attribute of the link between \p srcDevice and \p dstDevice. - * \param srcDevice - The source device of the target link. - * \param dstDevice - The destination device of the target link. - * - * \return - * ::CUDA_SUCCESS, - * ::CUDA_ERROR_DEINITIALIZED, - * ::CUDA_ERROR_NOT_INITIALIZED, - * ::CUDA_ERROR_INVALID_DEVICE, - * ::CUDA_ERROR_INVALID_VALUE - * \notefnerr - * - * \sa ::cuCtxEnablePeerAccess, + * \sa + * ::cuCtxEnablePeerAccess, * ::cuCtxDisablePeerAccess, - * ::cuCtxCanAccessPeer + * ::cudaDeviceCanAccessPeer */ -CUresult CUDAAPI cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib, CUdevice srcDevice, CUdevice dstDevice); +CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev, + CUdevice peerDev); /** * \brief Enables direct access to memory allocations in a peer context. * - * If both the current context and \p peerContext are on devices which support unified - * addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING) and same - * major compute capability, then on success all allocations from \p peerContext will - * immediately be accessible by the current context. See \ref CUDA_UNIFIED for additional + * If both the current context and \p peerContext are on devices which support + * unified addressing (as may be queried using + * ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING) and same major compute capability, + * then on success all allocations from \p peerContext will immediately be + * accessible by the current context. See \ref CUDA_UNIFIED for additional * details. * - * Note that access granted by this call is unidirectional and that in order to access - * memory from the current context in \p peerContext, a separate symmetric call - * to ::cuCtxEnablePeerAccess() is required. + * Note that access granted by this call is unidirectional and that in order to + * access memory from the current context in \p peerContext, a separate + * symmetric call to ::cuCtxEnablePeerAccess() is required. * * There is a system-wide maximum of eight peer connections per device. * - * Returns ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED if ::cuDeviceCanAccessPeer() indicates - * that the ::CUdevice of the current context cannot directly access memory - * from the ::CUdevice of \p peerContext. + * Returns ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED if ::cuDeviceCanAccessPeer() + * indicates that the ::CUdevice of the current context cannot directly access + * memory from the ::CUdevice of \p peerContext. * * Returns ::CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED if direct access of * \p peerContext from the current context has already been enabled. * - * Returns ::CUDA_ERROR_TOO_MANY_PEERS if direct peer access is not possible + * Returns ::CUDA_ERROR_TOO_MANY_PEERS if direct peer access is not possible * because hardware resources required for peer access have been exhausted. * - * Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, \p peerContext - * is not a valid context, or if the current context is \p peerContext. + * Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, \p + * peerContext is not a valid context, or if the current context is \p + * peerContext. * * Returns ::CUDA_ERROR_INVALID_VALUE if \p Flags is not 0. * - * \param peerContext - Peer context to enable direct access to from the current context - * \param Flags - Reserved for future use and must be set to 0 + * \param peerContext - Peer context to enable direct access to from the current + * context \param Flags - Reserved for future use and must be set to 0 * * \return * ::CUDA_SUCCESS, @@ -10854,16 +14846,19 @@ CUresult CUDAAPI cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attri * ::CUDA_ERROR_INVALID_VALUE * \notefnerr * - * \sa ::cuDeviceCanAccessPeer, - * ::cuCtxDisablePeerAccess + * \sa + * ::cuDeviceCanAccessPeer, + * ::cuCtxDisablePeerAccess, + * ::cudaDeviceEnablePeerAccess */ -CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags); +CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, + unsigned int Flags); /** - * \brief Disables direct access to memory allocations in a peer context and + * \brief Disables direct access to memory allocations in a peer context and * unregisters any registered allocations. * - Returns ::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED if direct peer access has + Returns ::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED if direct peer access has * not yet been enabled from \p peerContext to the current context. * * Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, or if @@ -10879,14 +14874,65 @@ CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags * ::CUDA_ERROR_INVALID_CONTEXT, * \notefnerr * - * \sa ::cuDeviceCanAccessPeer, - * ::cuCtxEnablePeerAccess + * \sa + * ::cuDeviceCanAccessPeer, + * ::cuCtxEnablePeerAccess, + * ::cudaDeviceDisablePeerAccess */ CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext); -/** @} */ /* END CUDA_PEER_ACCESS */ #endif /* __CUDA_API_VERSION >= 4000 */ +#if __CUDA_API_VERSION >= 8000 + +/** + * \brief Queries attributes of the link between two devices. + * + * Returns in \p *value the value of the requested attribute \p attrib of the + * link between \p srcDevice and \p dstDevice. The supported attributes are: + * - ::CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: A relative value indicating the + * performance of the link between two devices. + * - ::CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED P2P: 1 if P2P Access is enable. + * - ::CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: 1 if Atomic operations + * over the link are supported. + * - ::CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED: 1 if cudaArray can + * be accessed over the link. + * + * Returns ::CUDA_ERROR_INVALID_DEVICE if \p srcDevice or \p dstDevice are not + * valid or if they represent the same device. + * + * Returns ::CUDA_ERROR_INVALID_VALUE if \p attrib is not valid or if \p value + * is a null pointer. + * + * \param value - Returned value of the requested attribute + * \param attrib - The requested attribute of the link between \p + * srcDevice and \p dstDevice. \param srcDevice - The source device of the + * target link. \param dstDevice - The destination device of the target + * link. + * + * \return + * ::CUDA_SUCCESS, + * ::CUDA_ERROR_DEINITIALIZED, + * ::CUDA_ERROR_NOT_INITIALIZED, + * ::CUDA_ERROR_INVALID_DEVICE, + * ::CUDA_ERROR_INVALID_VALUE + * \notefnerr + * + * \sa + * ::cuCtxEnablePeerAccess, + * ::cuCtxDisablePeerAccess, + * ::cuDeviceCanAccessPeer, + * ::cudaDeviceGetP2PAttribute + */ +CUresult CUDAAPI cuDeviceGetP2PAttribute(int *value, + CUdevice_P2PAttribute attrib, + CUdevice srcDevice, + CUdevice dstDevice); + +#endif /* __CUDA_API_VERSION >= 8000 */ + +/** @} */ /* END CUDA_PEER_ACCESS */ + /** * \defgroup CUDA_GRAPHICS Graphics Interoperability * @@ -10924,17 +14970,19 @@ CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext); * ::cuGraphicsD3D10RegisterResource, * ::cuGraphicsD3D11RegisterResource, * ::cuGraphicsGLRegisterBuffer, - * ::cuGraphicsGLRegisterImage + * ::cuGraphicsGLRegisterImage, + * ::cudaGraphicsUnregisterResource */ CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource); /** - * \brief Get an array through which to access a subresource of a mapped graphics resource. + * \brief Get an array through which to access a subresource of a mapped + * graphics resource. * * Returns in \p *pArray an array through which the subresource of the mapped * graphics resource \p resource which corresponds to array index \p arrayIndex - * and mipmap level \p mipLevel may be accessed. The value set in \p *pArray may - * change every time that \p resource is mapped. + * and mipmap level \p mipLevel may be accessed. The value set in \p *pArray + * may change every time that \p resource is mapped. * * If \p resource is not a texture then it cannot be accessed via an array and * ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. @@ -10944,8 +14992,8 @@ CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource); * ::CUDA_ERROR_INVALID_VALUE is returned. * If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned. * - * \param pArray - Returned array through which a subresource of \p resource may be accessed - * \param resource - Mapped resource to access + * \param pArray - Returned array through which a subresource of \p + * resource may be accessed \param resource - Mapped resource to access * \param arrayIndex - Array index for array textures or cubemap face * index as defined by ::CUarray_cubemap_face for * cubemap textures for the subresource to access @@ -10962,25 +15010,31 @@ CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource); * ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY * \notefnerr * - * \sa ::cuGraphicsResourceGetMappedPointer + * \sa + * ::cuGraphicsResourceGetMappedPointer, + * ::cudaGraphicsSubResourceGetMappedArray */ -CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel); +CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray( + CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, + unsigned int mipLevel); #if __CUDA_API_VERSION >= 5000 /** - * \brief Get a mipmapped array through which to access a mapped graphics resource. + * \brief Get a mipmapped array through which to access a mapped graphics + * resource. * - * Returns in \p *pMipmappedArray a mipmapped array through which the mapped graphics - * resource \p resource. The value set in \p *pMipmappedArray may change every time - * that \p resource is mapped. + * Returns in \p *pMipmappedArray a mipmapped array through which the mapped + * graphics resource \p resource. The value set in \p *pMipmappedArray may + * change every time that \p resource is mapped. * - * If \p resource is not a texture then it cannot be accessed via a mipmapped array and + * If \p resource is not a texture then it cannot be accessed via a mipmapped + * array and * ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. * If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned. * - * \param pMipmappedArray - Returned mipmapped array through which \p resource may be accessed - * \param resource - Mapped resource to access + * \param pMipmappedArray - Returned mipmapped array through which \p resource + * may be accessed \param resource - Mapped resource to access * * \return * ::CUDA_SUCCESS, @@ -10993,28 +15047,33 @@ CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray(CUarray *pArray, CUgraphics * ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY * \notefnerr * - * \sa ::cuGraphicsResourceGetMappedPointer + * \sa + * ::cuGraphicsResourceGetMappedPointer, + * ::cudaGraphicsResourceGetMappedMipmappedArray */ -CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource); +CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray( + CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource); #endif /* __CUDA_API_VERSION >= 5000 */ #if __CUDA_API_VERSION >= 3020 /** - * \brief Get a device pointer through which to access a mapped graphics resource. + * \brief Get a device pointer through which to access a mapped graphics + * resource. * * Returns in \p *pDevPtr a pointer through which the mapped graphics resource * \p resource may be accessed. - * Returns in \p pSize the size of the memory in bytes which may be accessed from that pointer. - * The value set in \p pPointer may change every time that \p resource is mapped. + * Returns in \p pSize the size of the memory in bytes which may be accessed + * from that pointer. The value set in \p pPointer may change every time that \p + * resource is mapped. * * If \p resource is not a buffer then it cannot be accessed via a pointer and * ::CUDA_ERROR_NOT_MAPPED_AS_POINTER is returned. * If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned. * * - * \param pDevPtr - Returned pointer through which \p resource may be accessed - * \param pSize - Returned size of the buffer accessible starting at \p *pPointer - * \param resource - Mapped resource to access + * \param pDevPtr - Returned pointer through which \p resource may be + * accessed \param pSize - Returned size of the buffer accessible starting + * at \p *pPointer \param resource - Mapped resource to access * * \return * ::CUDA_SUCCESS, @@ -11029,9 +15088,11 @@ CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *pMi * * \sa * ::cuGraphicsMapResources, - * ::cuGraphicsSubResourceGetMappedArray + * ::cuGraphicsSubResourceGetMappedArray, + * ::cudaGraphicsResourceGetMappedPointer */ -CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource); +CUresult CUDAAPI cuGraphicsResourceGetMappedPointer( + CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource); #endif /* __CUDA_API_VERSION >= 3020 */ /** @@ -11045,7 +15106,8 @@ CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t * - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE: Specifies no hints about how this * resource will be used. It is therefore assumed that this resource will be * read from and written to by CUDA kernels. This is the default value. - * - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_READONLY: Specifies that CUDA kernels which + * - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_READONLY: Specifies that CUDA kernels + which * access this resource will not write to this resource. * - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITEDISCARD: Specifies that CUDA kernels * which access this resource will not read from this resource and will @@ -11054,7 +15116,8 @@ CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t * * If \p resource is presently mapped for access by CUDA then * ::CUDA_ERROR_ALREADY_MAPPED is returned. - * If \p flags is not one of the above values then ::CUDA_ERROR_INVALID_VALUE is returned. + * If \p flags is not one of the above values then ::CUDA_ERROR_INVALID_VALUE is + returned. * * \param resource - Registered resource to set flags for * \param flags - Parameters for resource mapping @@ -11070,9 +15133,11 @@ CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t * \notefnerr * * \sa - * ::cuGraphicsMapResources + * ::cuGraphicsMapResources, + * ::cudaGraphicsResourceSetMapFlags */ -CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags); +CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, + unsigned int flags); /** * \brief Map graphics resources for access by CUDA @@ -11085,11 +15150,12 @@ CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsi * application does so, the results are undefined. * * This function provides the synchronization guarantee that any graphics calls - * issued before ::cuGraphicsMapResources() will complete before any subsequent CUDA - * work issued in \p stream begins. + * issued before ::cuGraphicsMapResources() will complete before any subsequent + * CUDA work issued in \p stream begins. * - * If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned. - * If any of \p resources are presently mapped for access by CUDA then ::CUDA_ERROR_ALREADY_MAPPED is returned. + * If \p resources includes any duplicate entries then + * ::CUDA_ERROR_INVALID_HANDLE is returned. If any of \p resources are presently + * mapped for access by CUDA then ::CUDA_ERROR_ALREADY_MAPPED is returned. * * \param count - Number of resources to map * \param resources - Resources to map for CUDA usage @@ -11109,9 +15175,12 @@ CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsi * \sa * ::cuGraphicsResourceGetMappedPointer, * ::cuGraphicsSubResourceGetMappedArray, - * ::cuGraphicsUnmapResources + * ::cuGraphicsUnmapResources, + * ::cudaGraphicsMapResources */ -CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); +CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream); /** * \brief Unmap graphics resources. @@ -11121,13 +15190,14 @@ CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource * * Once unmapped, the resources in \p resources may not be accessed by CUDA * until they are mapped again. * - * This function provides the synchronization guarantee that any CUDA work issued - * in \p stream before ::cuGraphicsUnmapResources() will complete before any - * subsequently issued graphics work begins. + * This function provides the synchronization guarantee that any CUDA work + * issued in \p stream before ::cuGraphicsUnmapResources() will complete before + * any subsequently issued graphics work begins. * * - * If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned. - * If any of \p resources are not presently mapped for access by CUDA then ::CUDA_ERROR_NOT_MAPPED is returned. + * If \p resources includes any duplicate entries then + * ::CUDA_ERROR_INVALID_HANDLE is returned. If any of \p resources are not + * presently mapped for access by CUDA then ::CUDA_ERROR_NOT_MAPPED is returned. * * \param count - Number of resources to unmap * \param resources - Resources to unmap @@ -11145,254 +15215,321 @@ CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource * * \notefnerr * * \sa - * ::cuGraphicsMapResources + * ::cuGraphicsMapResources, + * ::cudaGraphicsUnmapResources */ -CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); +CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream); /** @} */ /* END CUDA_GRAPHICS */ -CUresult CUDAAPI cuGetExportTable(const void **ppExportTable, const CUuuid *pExportTableId); - +CUresult CUDAAPI cuGetExportTable(const void **ppExportTable, + const CUuuid *pExportTableId); /** * CUDA API versioning support */ #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 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 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 cuStreamGetFlags - #undef cuStreamWaitEvent - #undef cuStreamAddCallback - #undef cuStreamAttachMemAsync - #undef cuStreamQuery - #undef cuStreamSynchronize - #undef cuEventRecord - #undef cuLaunchKernel - #undef cuGraphicsMapResources - #undef cuGraphicsUnmapResources - #undef cuMemPrefetchAsync - #undef cuStreamWriteValue32 - #undef cuStreamWaitValue32 - #undef cuStreamBatchMemOp +#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 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 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 cuStreamGetFlags +#undef cuStreamGetCtx +#undef cuStreamWaitEvent +#undef cuStreamAddCallback +#undef cuStreamAttachMemAsync +#undef cuStreamQuery +#undef cuStreamSynchronize +#undef cuEventRecord +#undef cuLaunchKernel +#undef cuLaunchHostFunc +#undef cuGraphicsMapResources +#undef cuGraphicsUnmapResources +#undef cuStreamWriteValue32 +#undef cuStreamWaitValue32 +#undef cuStreamWriteValue64 +#undef cuStreamWaitValue64 +#undef cuStreamBatchMemOp +#undef cuMemPrefetchAsync +#undef cuLaunchCooperativeKernel +#undef cuSignalExternalSemaphoresAsync +#undef cuWaitExternalSemaphoresAsync +#undef cuStreamBeginCapture +#undef cuStreamEndCapture +#undef cuStreamIsCapturing +#undef cuStreamGetCaptureInfo +#undef cuGraphLaunch #endif /* __CUDA_API_VERSION_INTERNAL */ -#if defined(__CUDA_API_VERSION_INTERNAL) || (__CUDA_API_VERSION >= 4000 && __CUDA_API_VERSION < 6050) -CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags); -#endif /* defined(__CUDA_API_VERSION_INTERNAL) || (__CUDA_API_VERSION >= 4000 && __CUDA_API_VERSION < 6050) */ +#if defined(__CUDA_API_VERSION_INTERNAL) || \ + (__CUDA_API_VERSION >= 4000 && __CUDA_API_VERSION < 6050) +CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, + unsigned int Flags); +#endif /* defined(__CUDA_API_VERSION_INTERNAL) || (__CUDA_API_VERSION >= 4000 \ + && __CUDA_API_VERSION < 6050) */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION < 6050 -CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags); +CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, + unsigned int flags); #endif /* defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION < 6050 */ -#if defined(__CUDA_API_VERSION_INTERNAL) || (__CUDA_API_VERSION >= 5050 && __CUDA_API_VERSION < 6050) -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); -#endif /* __CUDA_API_VERSION_INTERNAL || (__CUDA_API_VERSION >= 5050 && __CUDA_API_VERSION < 6050) */ +#if defined(__CUDA_API_VERSION_INTERNAL) || \ + (__CUDA_API_VERSION >= 5050 && __CUDA_API_VERSION < 6050) +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); +#endif /* __CUDA_API_VERSION_INTERNAL || (__CUDA_API_VERSION >= 5050 && \ + __CUDA_API_VERSION < 6050) */ -#if defined(__CUDA_API_VERSION_INTERNAL) || (__CUDA_API_VERSION >= 3020 && __CUDA_API_VERSION < 4010) -CUresult CUDAAPI cuTexRefSetAddress2D_v2(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch); -#endif /* __CUDA_API_VERSION_INTERNAL || (__CUDA_API_VERSION >= 3020 && __CUDA_API_VERSION < 4010) */ +#if defined(__CUDA_API_VERSION_INTERNAL) || \ + (__CUDA_API_VERSION >= 3020 && __CUDA_API_VERSION < 4010) +CUresult CUDAAPI cuTexRefSetAddress2D_v2(CUtexref hTexRef, + const CUDA_ARRAY_DESCRIPTOR *desc, + CUdeviceptr dptr, size_t Pitch); +#endif /* __CUDA_API_VERSION_INTERNAL || (__CUDA_API_VERSION >= 3020 && \ + __CUDA_API_VERSION < 4010) */ /** * CUDA API made obselete at API version 3020 */ #if defined(__CUDA_API_VERSION_INTERNAL) - #define CUdeviceptr CUdeviceptr_v1 - #define CUDA_MEMCPY2D_st CUDA_MEMCPY2D_v1_st - #define CUDA_MEMCPY2D CUDA_MEMCPY2D_v1 - #define CUDA_MEMCPY3D_st CUDA_MEMCPY3D_v1_st - #define CUDA_MEMCPY3D CUDA_MEMCPY3D_v1 - #define CUDA_ARRAY_DESCRIPTOR_st CUDA_ARRAY_DESCRIPTOR_v1_st - #define CUDA_ARRAY_DESCRIPTOR CUDA_ARRAY_DESCRIPTOR_v1 - #define CUDA_ARRAY3D_DESCRIPTOR_st CUDA_ARRAY3D_DESCRIPTOR_v1_st - #define CUDA_ARRAY3D_DESCRIPTOR CUDA_ARRAY3D_DESCRIPTOR_v1 +#define CUdeviceptr CUdeviceptr_v1 +#define CUDA_MEMCPY2D_st CUDA_MEMCPY2D_v1_st +#define CUDA_MEMCPY2D CUDA_MEMCPY2D_v1 +#define CUDA_MEMCPY3D_st CUDA_MEMCPY3D_v1_st +#define CUDA_MEMCPY3D CUDA_MEMCPY3D_v1 +#define CUDA_ARRAY_DESCRIPTOR_st CUDA_ARRAY_DESCRIPTOR_v1_st +#define CUDA_ARRAY_DESCRIPTOR CUDA_ARRAY_DESCRIPTOR_v1 +#define CUDA_ARRAY3D_DESCRIPTOR_st CUDA_ARRAY3D_DESCRIPTOR_v1_st +#define CUDA_ARRAY3D_DESCRIPTOR CUDA_ARRAY3D_DESCRIPTOR_v1 #endif /* CUDA_FORCE_LEGACY32_INTERNAL */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION < 3020 typedef unsigned int CUdeviceptr; -typedef struct CUDA_MEMCPY2D_st -{ - unsigned int srcXInBytes; /**< Source X in bytes */ - unsigned int srcY; /**< Source Y */ - CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ - const void *srcHost; /**< Source host pointer */ - CUdeviceptr srcDevice; /**< Source device pointer */ - CUarray srcArray; /**< Source array reference */ - unsigned int srcPitch; /**< Source pitch (ignored when src is array) */ +typedef struct CUDA_MEMCPY2D_st { + unsigned int srcXInBytes; /**< Source X in bytes */ + unsigned int srcY; /**< Source Y */ + CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ + const void *srcHost; /**< Source host pointer */ + CUdeviceptr srcDevice; /**< Source device pointer */ + CUarray srcArray; /**< Source array reference */ + unsigned int srcPitch; /**< Source pitch (ignored when src is array) */ - unsigned int dstXInBytes; /**< Destination X in bytes */ - unsigned int dstY; /**< Destination Y */ - CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ - void *dstHost; /**< Destination host pointer */ - CUdeviceptr dstDevice; /**< Destination device pointer */ - CUarray dstArray; /**< Destination array reference */ - unsigned int dstPitch; /**< Destination pitch (ignored when dst is array) */ + unsigned int dstXInBytes; /**< Destination X in bytes */ + unsigned int dstY; /**< Destination Y */ + CUmemorytype + dstMemoryType; /**< Destination memory type (host, device, array) */ + void *dstHost; /**< Destination host pointer */ + CUdeviceptr dstDevice; /**< Destination device pointer */ + CUarray dstArray; /**< Destination array reference */ + unsigned int dstPitch; /**< Destination pitch (ignored when dst is array) */ - unsigned int WidthInBytes; /**< Width of 2D memory copy in bytes */ - unsigned int Height; /**< Height of 2D memory copy */ + unsigned int WidthInBytes; /**< Width of 2D memory copy in bytes */ + unsigned int Height; /**< Height of 2D memory copy */ } CUDA_MEMCPY2D; -typedef struct CUDA_MEMCPY3D_st -{ - unsigned int srcXInBytes; /**< Source X in bytes */ - unsigned int srcY; /**< Source Y */ - unsigned int srcZ; /**< Source Z */ - unsigned int srcLOD; /**< Source LOD */ - CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ - const void *srcHost; /**< Source host pointer */ - CUdeviceptr srcDevice; /**< Source device pointer */ - CUarray srcArray; /**< Source array reference */ - void *reserved0; /**< Must be NULL */ - unsigned int srcPitch; /**< Source pitch (ignored when src is array) */ - unsigned int srcHeight; /**< Source height (ignored when src is array; may be 0 if Depth==1) */ +typedef struct CUDA_MEMCPY3D_st { + unsigned int srcXInBytes; /**< Source X in bytes */ + unsigned int srcY; /**< Source Y */ + unsigned int srcZ; /**< Source Z */ + unsigned int srcLOD; /**< Source LOD */ + CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ + const void *srcHost; /**< Source host pointer */ + CUdeviceptr srcDevice; /**< Source device pointer */ + CUarray srcArray; /**< Source array reference */ + void *reserved0; /**< Must be NULL */ + unsigned int srcPitch; /**< Source pitch (ignored when src is array) */ + unsigned int srcHeight; /**< Source height (ignored when src is array; may be + 0 if Depth==1) */ - unsigned int dstXInBytes; /**< Destination X in bytes */ - unsigned int dstY; /**< Destination Y */ - unsigned int dstZ; /**< Destination Z */ - unsigned int dstLOD; /**< Destination LOD */ - CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ - void *dstHost; /**< Destination host pointer */ - CUdeviceptr dstDevice; /**< Destination device pointer */ - CUarray dstArray; /**< Destination array reference */ - void *reserved1; /**< Must be NULL */ - unsigned int dstPitch; /**< Destination pitch (ignored when dst is array) */ - unsigned int dstHeight; /**< Destination height (ignored when dst is array; may be 0 if Depth==1) */ + unsigned int dstXInBytes; /**< Destination X in bytes */ + unsigned int dstY; /**< Destination Y */ + unsigned int dstZ; /**< Destination Z */ + unsigned int dstLOD; /**< Destination LOD */ + CUmemorytype + dstMemoryType; /**< Destination memory type (host, device, array) */ + void *dstHost; /**< Destination host pointer */ + CUdeviceptr dstDevice; /**< Destination device pointer */ + CUarray dstArray; /**< Destination array reference */ + void *reserved1; /**< Must be NULL */ + unsigned int dstPitch; /**< Destination pitch (ignored when dst is array) */ + unsigned int dstHeight; /**< Destination height (ignored when dst is array; + may be 0 if Depth==1) */ - unsigned int WidthInBytes; /**< Width of 3D memory copy in bytes */ - unsigned int Height; /**< Height of 3D memory copy */ - unsigned int Depth; /**< Depth of 3D memory copy */ + unsigned int WidthInBytes; /**< Width of 3D memory copy in bytes */ + unsigned int Height; /**< Height of 3D memory copy */ + unsigned int Depth; /**< Depth of 3D memory copy */ } CUDA_MEMCPY3D; -typedef struct CUDA_ARRAY_DESCRIPTOR_st -{ - unsigned int Width; /**< Width of array */ - unsigned int Height; /**< Height of array */ +typedef struct CUDA_ARRAY_DESCRIPTOR_st { + unsigned int Width; /**< Width of array */ + unsigned int Height; /**< Height of array */ - CUarray_format Format; /**< Array format */ - unsigned int NumChannels; /**< Channels per array element */ + CUarray_format Format; /**< Array format */ + unsigned int NumChannels; /**< Channels per array element */ } CUDA_ARRAY_DESCRIPTOR; -typedef struct CUDA_ARRAY3D_DESCRIPTOR_st -{ - unsigned int Width; /**< Width of 3D array */ - unsigned int Height; /**< Height of 3D array */ - unsigned int Depth; /**< Depth of 3D array */ +typedef struct CUDA_ARRAY3D_DESCRIPTOR_st { + unsigned int Width; /**< Width of 3D array */ + unsigned int Height; /**< Height of 3D array */ + unsigned int Depth; /**< Depth of 3D array */ - CUarray_format Format; /**< Array format */ - unsigned int NumChannels; /**< Channels per array element */ - unsigned int Flags; /**< Flags */ + CUarray_format Format; /**< Array format */ + unsigned int NumChannels; /**< Channels per array element */ + unsigned int Flags; /**< Flags */ } CUDA_ARRAY3D_DESCRIPTOR; CUresult CUDAAPI cuDeviceTotalMem(unsigned int *bytes, CUdevice dev); CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags, CUdevice dev); -CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, unsigned int *bytes, CUmodule hmod, const char *name); +CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, unsigned int *bytes, + CUmodule hmod, const char *name); CUresult CUDAAPI cuMemGetInfo(unsigned int *free, unsigned int *total); CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, unsigned int bytesize); -CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, unsigned int *pPitch, unsigned int WidthInBytes, unsigned int Height, unsigned int ElementSizeBytes); +CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, unsigned int *pPitch, + unsigned int WidthInBytes, unsigned int Height, + unsigned int ElementSizeBytes); CUresult CUDAAPI cuMemFree(CUdeviceptr dptr); -CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, unsigned int *psize, CUdeviceptr dptr); +CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, unsigned int *psize, + CUdeviceptr dptr); CUresult CUDAAPI cuMemAllocHost(void **pp, unsigned int bytesize); -CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags); -CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, unsigned int ByteCount); -CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, unsigned int ByteCount); -CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, unsigned int ByteCount); -CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, unsigned int dstOffset, CUdeviceptr srcDevice, unsigned int ByteCount); -CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr 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 cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, + unsigned int Flags); +CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, + unsigned int ByteCount); +CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, + unsigned int ByteCount); +CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + unsigned int ByteCount); +CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, unsigned int dstOffset, + CUdeviceptr srcDevice, unsigned int ByteCount); +CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr 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 *pCopy); CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy); CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy); -CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, unsigned int ByteCount, CUstream hStream); -CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, unsigned int ByteCount, CUstream hStream); -CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, unsigned int ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, + unsigned int ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, + unsigned int ByteCount, CUstream hStream); +CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + unsigned int ByteCount, CUstream hStream); CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream); CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream); -CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, unsigned int N); -CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, unsigned int N); -CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, unsigned int N); -CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned char uc, unsigned int Width, unsigned int Height); -CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned short us, unsigned int Width, unsigned int Height); -CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned int ui, unsigned int Width, unsigned int Height); -CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pAllocateArray); -CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray); -CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray); -CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray); -CUresult CUDAAPI cuTexRefSetAddress(unsigned int *ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, unsigned int bytes); -CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, unsigned int Pitch); +CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, + unsigned int N); +CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, + unsigned int N); +CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, + unsigned int N); +CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, unsigned int dstPitch, + unsigned char uc, unsigned int Width, + unsigned int Height); +CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, unsigned int dstPitch, + unsigned short us, unsigned int Width, + unsigned int Height); +CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, unsigned int dstPitch, + unsigned int ui, unsigned int Width, + unsigned int Height); +CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, + const CUDA_ARRAY_DESCRIPTOR *pAllocateArray); +CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, + CUarray hArray); +CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, + const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray); +CUresult CUDAAPI cuArray3DGetDescriptor( + CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray); +CUresult CUDAAPI cuTexRefSetAddress(unsigned int *ByteOffset, CUtexref hTexRef, + CUdeviceptr dptr, unsigned int bytes); +CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, + const CUDA_ARRAY_DESCRIPTOR *desc, + CUdeviceptr dptr, unsigned int Pitch); CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef); -CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, unsigned int *pSize, CUgraphicsResource resource); +CUresult CUDAAPI cuGraphicsResourceGetMappedPointer( + CUdeviceptr *pDevPtr, unsigned int *pSize, CUgraphicsResource resource); #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION < 3020 */ #if defined(__CUDA_API_VERSION_INTERNAL) || __CUDA_API_VERSION < 4000 CUresult CUDAAPI cuCtxDestroy(CUcontext ctx); @@ -11402,71 +15539,162 @@ CUresult CUDAAPI cuStreamDestroy(CUstream hStream); CUresult CUDAAPI cuEventDestroy(CUevent hEvent); #endif /* __CUDA_API_VERSION_INTERNAL || __CUDA_API_VERSION < 4000 */ #if defined(__CUDA_API_VERSION_INTERNAL) - #undef CUdeviceptr - #undef CUDA_MEMCPY2D_st - #undef CUDA_MEMCPY2D - #undef CUDA_MEMCPY3D_st - #undef CUDA_MEMCPY3D - #undef CUDA_ARRAY_DESCRIPTOR_st - #undef CUDA_ARRAY_DESCRIPTOR - #undef CUDA_ARRAY3D_DESCRIPTOR_st - #undef CUDA_ARRAY3D_DESCRIPTOR +#undef CUdeviceptr +#undef CUDA_MEMCPY2D_st +#undef CUDA_MEMCPY2D +#undef CUDA_MEMCPY3D_st +#undef CUDA_MEMCPY3D +#undef CUDA_ARRAY_DESCRIPTOR_st +#undef CUDA_ARRAY_DESCRIPTOR +#undef CUDA_ARRAY3D_DESCRIPTOR_st +#undef CUDA_ARRAY3D_DESCRIPTOR #endif /* __CUDA_API_VERSION_INTERNAL */ #if defined(__CUDA_API_VERSION_INTERNAL) - 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 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 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 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 cuStreamGetFlags(CUstream hStream, unsigned int *flags); - 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 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 cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); - CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream); - CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, 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 cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags); +CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority); +CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags); +CUresult CUDAAPI cuStreamGetCtx(CUstream hStream, CUcontext *pctx); +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 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 cuLaunchHostFunc(CUstream hStream, CUhostFn fn, + void *userData); +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 cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, + CUdevice dstDevice, 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 cuStreamEndCapture(CUstream hStream, CUgraph *phGraph); +CUresult CUDAAPI cuStreamIsCapturing(CUstream hStream, + CUstreamCaptureStatus *captureStatus); +CUresult CUDAAPI cuStreamGetCaptureInfo(CUstream hStream, + CUstreamCaptureStatus *captureStatus, + cuuint64_t *id); +CUresult CUDAAPI cuGraphLaunch(CUgraphExec hGraph, CUstream hStream); #endif #ifdef __cplusplus @@ -11474,6 +15702,6 @@ CUresult CUDAAPI cuEventDestroy(CUevent hEvent); #endif #undef __CUDA_API_VERSION +#undef __CUDA_DEPRECATED #endif /* __cuda_cuda_h__ */ - diff --git a/libcuda/cuda_api_object.h b/libcuda/cuda_api_object.h new file mode 100644 index 0000000..d292e22 --- /dev/null +++ b/libcuda/cuda_api_object.h @@ -0,0 +1,217 @@ +#ifndef __cuda_api_object_h__ +#define __cuda_api_object_h__ + +#include <list> +#include <map> +#include <set> +#include <string> + +#include "builtin_types.h" + +#include "../src/abstract_hardware_model.h" +#include "../src/cuda-sim/ptx_ir.h" +#include "../src/gpgpu-sim/gpu-sim.h" +#include "cuobjdump.h" + +typedef std::list<gpgpu_ptx_sim_arg> gpgpu_ptx_sim_arg_list_t; + +#ifndef OPENGL_SUPPORT +typedef unsigned long GLuint; +#endif + +struct glbmap_entry { + GLuint m_bufferObj; + void *m_devPtr; + size_t m_size; + struct glbmap_entry *m_next; +}; + +typedef struct glbmap_entry glbmap_entry_t; + +struct _cuda_device_id { + _cuda_device_id(gpgpu_sim *gpu) { + m_id = 0; + m_next = NULL; + m_gpgpu = gpu; + } + struct _cuda_device_id *next() { + return m_next; + } + unsigned num_shader() const { return m_gpgpu->get_config().num_shader(); } + int num_devices() const { + if (m_next == NULL) + return 1; + else + return 1 + m_next->num_devices(); + } + struct _cuda_device_id *get_device(unsigned n) { + assert(n < (unsigned)num_devices()); + struct _cuda_device_id *p = this; + for (unsigned i = 0; i < n; i++) p = p->m_next; + return p; + } + const struct cudaDeviceProp *get_prop() const { return m_gpgpu->get_prop(); } + unsigned get_id() const { return m_id; } + + gpgpu_sim *get_gpgpu() { return m_gpgpu; } + + private: + unsigned m_id; + class gpgpu_sim *m_gpgpu; + struct _cuda_device_id *m_next; +}; + +struct CUctx_st { + CUctx_st(_cuda_device_id *gpu) { + m_gpu = gpu; + m_binary_info.cmem = 0; + m_binary_info.gmem = 0; + no_of_ptx = 0; + } + + _cuda_device_id *get_device() { return m_gpu; } + + void add_binary(symbol_table *symtab, unsigned fat_cubin_handle) { + m_code[fat_cubin_handle] = symtab; + m_last_fat_cubin_handle = fat_cubin_handle; + } + + void add_ptxinfo(const char *deviceFun, + const struct gpgpu_ptx_sim_info &info) { + symbol *s = m_code[m_last_fat_cubin_handle]->lookup(deviceFun); + assert(s != NULL); + function_info *f = s->get_pc(); + assert(f != NULL); + f->set_kernel_info(info); + } + + void add_ptxinfo(const struct gpgpu_ptx_sim_info &info) { + m_binary_info = info; + } + + void register_function(unsigned fat_cubin_handle, const char *hostFun, + const char *deviceFun) { + if (m_code.find(fat_cubin_handle) != m_code.end()) { + symbol *s = m_code[fat_cubin_handle]->lookup(deviceFun); + if (s != NULL) { + function_info *f = s->get_pc(); + assert(f != NULL); + m_kernel_lookup[hostFun] = f; + } else { + printf("Warning: cannot find deviceFun %s\n", deviceFun); + m_kernel_lookup[hostFun] = NULL; + } + // assert( s != NULL ); + // function_info *f = s->get_pc(); + // assert( f != NULL ); + // m_kernel_lookup[hostFun] = f; + } else { + m_kernel_lookup[hostFun] = NULL; + } + } + + void register_hostFun_function(const char *hostFun, function_info *f) { + m_kernel_lookup[hostFun] = f; + } + + function_info *get_kernel(const char *hostFun) { + std::map<const void *, function_info *>::iterator i = + m_kernel_lookup.find(hostFun); + assert(i != m_kernel_lookup.end()); + return i->second; + } + + int no_of_ptx; + + private: + _cuda_device_id *m_gpu; // selected gpu + std::map<unsigned, symbol_table *> + m_code; // fat binary handle => global symbol table + unsigned m_last_fat_cubin_handle; + std::map<const void *, function_info *> + m_kernel_lookup; // unique id (CUDA app function address) => kernel entry + // point + struct gpgpu_ptx_sim_info m_binary_info; +}; + +class kernel_config { + public: + kernel_config(dim3 GridDim, dim3 BlockDim, size_t sharedMem, + struct CUstream_st *stream) { + m_GridDim = GridDim; + m_BlockDim = BlockDim; + m_sharedMem = sharedMem; + m_stream = stream; + } + kernel_config() { + m_GridDim = dim3(-1, -1, -1); + m_BlockDim = dim3(-1, -1, -1); + m_sharedMem = 0; + m_stream = NULL; + } + void set_arg(const void *arg, size_t size, size_t offset) { + m_args.push_front(gpgpu_ptx_sim_arg(arg, size, offset)); + } + dim3 grid_dim() const { return m_GridDim; } + dim3 block_dim() const { return m_BlockDim; } + void set_grid_dim(dim3 *d) { m_GridDim = *d; } + void set_block_dim(dim3 *d) { m_BlockDim = *d; } + gpgpu_ptx_sim_arg_list_t get_args() { return m_args; } + struct CUstream_st *get_stream() { + return m_stream; + } + + private: + dim3 m_GridDim; + dim3 m_BlockDim; + size_t m_sharedMem; + struct CUstream_st *m_stream; + gpgpu_ptx_sim_arg_list_t m_args; +}; + +class cuda_runtime_api { + public: + cuda_runtime_api(gpgpu_context *ctx) { + g_glbmap = NULL; + g_active_device = 0; // active gpu that runs the code + gpgpu_ctx = ctx; + } + // global list + std::list<cuobjdumpSection *> cuobjdumpSectionList; + std::list<cuobjdumpSection *> libSectionList; + std::list<kernel_config> g_cuda_launch_stack; + std::map<int, bool> fatbin_registered; + std::map<int, std::string> fatbinmap; + std::map<std::string, symbol_table *> name_symtab; + std::map<unsigned long long, size_t> g_mallocPtr_Size; + // maps sm version number to set of filenames + std::map<unsigned, std::set<std::string> > version_filename; + std::map<void *, void **> pinned_memory; // support for pinned memories added + std::map<void *, size_t> pinned_memory_size; + glbmap_entry_t *g_glbmap; + int g_active_device; // active gpu that runs the code + // backward pointer + class gpgpu_context *gpgpu_ctx; + // member function list + void cuobjdumpInit(); + void extract_code_using_cuobjdump(); + void extract_ptx_files_using_cuobjdump(CUctx_st *context); + std::list<cuobjdumpSection *> pruneSectionList(CUctx_st *context); + std::list<cuobjdumpSection *> mergeMatchingSections(std::string identifier); + std::list<cuobjdumpSection *> mergeSections(); + cuobjdumpELFSection *findELFSection(const std::string identifier); + cuobjdumpPTXSection *findPTXSection(const std::string identifier); + cuobjdumpPTXSection *findPTXSectionInList( + std::list<cuobjdumpSection *> §ionlist, const std::string identifier); + void cuobjdumpRegisterFatBinary(unsigned int handle, const char *filename, + CUctx_st *context); + kernel_info_t *gpgpu_cuda_ptx_sim_init_grid(const char *kernel_key, + gpgpu_ptx_sim_arg_list_t args, + struct dim3 gridDim, + struct dim3 blockDim, + struct CUctx_st *context); + int load_static_globals(symbol_table *symtab, unsigned min_gaddr, + unsigned max_gaddr, gpgpu_t *gpu); + int load_constants(symbol_table *symtab, addr_t min_gaddr, gpgpu_t *gpu); +}; +#endif /* __cuda_api_object_h__ */ diff --git a/libcuda/cuda_runtime_api.cc b/libcuda/cuda_runtime_api.cc index a6edf9a..12f9636 100644 --- a/libcuda/cuda_runtime_api.cc +++ b/libcuda/cuda_runtime_api.cc @@ -2,16 +2,16 @@ // Changes Copyright 2009, Tor M. Aamodt, Ali Bakhoda and George L. Yuan // University of British Columbia -/* +/* * cuda_runtime_api.cc * - * Copyright © 2009 by Tor M. Aamodt, Wilson W. L. Fung, Ali Bakhoda, - * George L. Yuan and the University of British Columbia, Vancouver, + * Copyright © 2009 by Tor M. Aamodt, Wilson W. L. Fung, Ali Bakhoda, + * George L. Yuan and the University of British Columbia, Vancouver, * BC V6T 1Z4, All Rights Reserved. - * + * * THIS IS A LEGAL DOCUMENT BY DOWNLOADING GPGPU-SIM, YOU ARE AGREEING TO THESE * TERMS AND CONDITIONS. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -23,114 +23,118 @@ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. - * + * * NOTE: The files libcuda/cuda_runtime_api.c and src/cuda-sim/cuda-math.h * are derived from the CUDA Toolset available from http://www.nvidia.com/cuda - * (property of NVIDIA). The files benchmarks/BlackScholes/ and - * benchmarks/template/ are derived from the CUDA SDK available from - * http://www.nvidia.com/cuda (also property of NVIDIA). The files from - * src/intersim/ are derived from Booksim (a simulator provided with the - * textbook "Principles and Practices of Interconnection Networks" available - * from http://cva.stanford.edu/books/ppin/). As such, those files are bound by - * the corresponding legal terms and conditions set forth separately (original - * copyright notices are left in files from these sources and where we have - * modified a file our copyright notice appears before the original copyright - * notice). - * - * Using this version of GPGPU-Sim requires a complete installation of CUDA - * which is distributed seperately by NVIDIA under separate terms and + * (property of NVIDIA). The files benchmarks/BlackScholes/ and + * benchmarks/template/ are derived from the CUDA SDK available from + * http://www.nvidia.com/cuda (also property of NVIDIA). The files from + * src/intersim/ are derived from Booksim (a simulator provided with the + * textbook "Principles and Practices of Interconnection Networks" available + * from http://cva.stanford.edu/books/ppin/). As such, those files are bound by + * the corresponding legal terms and conditions set forth separately (original + * copyright notices are left in files from these sources and where we have + * modified a file our copyright notice appears before the original copyright + * notice). + * + * Using this version of GPGPU-Sim requires a complete installation of CUDA + * which is distributed seperately by NVIDIA under separate terms and * conditions. To use this version of GPGPU-Sim with OpenCL requires a * recent version of NVIDIA's drivers which support OpenCL. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: - * + * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. - * + * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. - * + * * 3. Neither the name of the University of British Columbia nor the names of * its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. - * - * 4. This version of GPGPU-SIM is distributed freely for non-commercial use only. - * + * + * 4. This version of GPGPU-SIM is distributed freely for non-commercial use + * only. + * * 5. No nonprofit user may place any restrictions on the use of this software, * including as modified by the user, by any other authorized user. - * - * 6. GPGPU-SIM was developed primarily by Tor M. Aamodt, Wilson W. L. Fung, - * Ali Bakhoda, George L. Yuan, at the University of British Columbia, + * + * 6. GPGPU-SIM was developed primarily by Tor M. Aamodt, Wilson W. L. Fung, + * Ali Bakhoda, George L. Yuan, at the University of British Columbia, * Vancouver, BC V6T 1Z4 */ /* * Copyright 1993-2007 NVIDIA Corporation. All rights reserved. * - * NOTICE TO USER: + * NOTICE TO USER: * - * This source code is subject to NVIDIA ownership rights under U.S. and - * international Copyright laws. Users and possessors of this source code - * are hereby granted a nonexclusive, royalty-free license to use this code + * This source code is subject to NVIDIA ownership rights under U.S. and + * international Copyright laws. Users and possessors of this source code + * are hereby granted a nonexclusive, royalty-free license to use this code * in individual and commercial software. * - * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE - * CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR - * IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH - * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF + * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE + * CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR + * IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH + * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. - * 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 THIS SOURCE CODE. + * 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 THIS SOURCE CODE. * - * U.S. Government End Users. This source code is 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 - * source code with only those rights set forth herein. + * U.S. Government End Users. This source code is 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 + * source code with only those rights set forth herein. * - * Any use of this source code in individual and commercial software must + * Any use of this source code 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. */ -#include <stdlib.h> +#include <assert.h> +#include <stdarg.h> #include <stdio.h> +#include <stdlib.h> #include <string.h> -#include <assert.h> #include <time.h> -#include <stdarg.h> +#include <fstream> #include <iostream> -#include <string> #include <regex> #include <sstream> -#include <fstream> +#include <string> #ifdef OPENGL_SUPPORT #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ -#include <GLUT/glut.h> // Apple's version of GLUT is here +#include <GLUT/glut.h> // Apple's version of GLUT is here #else #include <GL/gl.h> #endif #endif #define __CUDA_RUNTIME_API_H__ - +// clang-format off #include "host_defines.h" #include "builtin_types.h" #include "driver_types.h" #include "cuda_api.h" #include "cudaProfiler.h" +// clang-format on #if (CUDART_VERSION < 8000) #include "__cudaFatFormat.h" #endif +#include "gpgpu_context.h" +#include "cuda_api_object.h" #include "../src/gpgpu-sim/gpu-sim.h" #include "../src/cuda-sim/ptx_loader.h" #include "../src/cuda-sim/cuda-sim.h" @@ -147,41 +151,20 @@ #include <mach-o/dyld.h> #endif -std::map<void *,void **> pinned_memory; //support for pinned memories added -std::map<void *, size_t> pinned_memory_size; -std::map<unsigned long long, size_t> g_mallocPtr_Size; -int no_of_ptx=0; -//maps sm version number to set of filenames -std::map<unsigned, std::set<std::string> > version_filename; - -extern void synchronize(); -extern void exit_simulation(); - -static int load_static_globals( symbol_table *symtab, unsigned min_gaddr, unsigned max_gaddr, gpgpu_t *gpu ); -static int load_constants( symbol_table *symtab, addr_t min_gaddr, gpgpu_t *gpu ); - -static kernel_info_t *gpgpu_cuda_ptx_sim_init_grid( const char *kernel_key, - gpgpu_ptx_sim_arg_list_t args, - struct dim3 gridDim, - struct dim3 blockDim, - struct CUctx_st* context ); - /*DEVICE_BUILTIN*/ -struct cudaArray -{ - void *devPtr; - int devPtr32; - struct cudaChannelFormatDesc desc; - int width; - int height; - int size; //in bytes - unsigned dimensions; +struct cudaArray { + void *devPtr; + int devPtr32; + struct cudaChannelFormatDesc desc; + int width; + int height; + int size; // in bytes + unsigned dimensions; }; #if !defined(__dv) #if defined(__cplusplus) -#define __dv(v) \ - = v +#define __dv(v) = v #else /* __cplusplus */ #define __dv(v) #endif /* __cplusplus */ @@ -189,734 +172,2116 @@ struct cudaArray cudaError_t g_last_cudaError = cudaSuccess; -extern stream_manager *g_stream_manager; - -void register_ptx_function( const char *name, function_info *impl ) -{ - // no longer need this +void register_ptx_function(const char *name, function_info *impl) { + // no longer need this } #if defined __APPLE__ -# define __my_func__ __PRETTY_FUNCTION__ +#define __my_func__ __PRETTY_FUNCTION__ +#else +#if defined __cplusplus ? __GNUC_PREREQ(2, 6) : __GNUC_PREREQ(2, 4) +#define __my_func__ __PRETTY_FUNCTION__ +#else +#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +#define __my_func__ __func__ #else -# if defined __cplusplus ? __GNUC_PREREQ (2, 6) : __GNUC_PREREQ (2, 4) -# define __my_func__ __PRETTY_FUNCTION__ -# else -# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L -# define __my_func__ __func__ -# else -# define __my_func__ ((__const char *) 0) -# endif -# endif +#define __my_func__ ((__const char *)0) +#endif +#endif #endif -struct _cuda_device_id { - _cuda_device_id(gpgpu_sim* gpu) {m_id = 0; m_next = NULL; m_gpgpu=gpu;} - struct _cuda_device_id *next() { return m_next; } - unsigned num_shader() const { return m_gpgpu->get_config().num_shader(); } - int num_devices() const { - if( m_next == NULL ) return 1; - else return 1 + m_next->num_devices(); - } - struct _cuda_device_id *get_device( unsigned n ) - { - assert( n < (unsigned)num_devices() ); - struct _cuda_device_id *p=this; - for(unsigned i=0; i<n; i++) - p = p->m_next; - return p; - } - const struct cudaDeviceProp *get_prop() const - { - return m_gpgpu->get_prop(); - } - unsigned get_id() const { return m_id; } +struct _cuda_device_id *gpgpu_context::GPGPUSim_Init() { + _cuda_device_id *the_device = the_gpgpusim->the_cude_device; + if (!the_device) { + gpgpu_sim *the_gpu = gpgpu_ptx_sim_init_perf(); - gpgpu_sim *get_gpgpu() { return m_gpgpu; } -private: - unsigned m_id; - class gpgpu_sim *m_gpgpu; - struct _cuda_device_id *m_next; -}; + cudaDeviceProp *prop = (cudaDeviceProp *)calloc(sizeof(cudaDeviceProp), 1); + snprintf(prop->name, 256, "GPGPU-Sim_v%s", g_gpgpusim_version_string); + prop->major = the_gpu->compute_capability_major(); + prop->minor = the_gpu->compute_capability_minor(); + prop->totalGlobalMem = 0x80000000 /* 2 GB */; + prop->memPitch = 0; + if (prop->major >= 2) { + prop->maxThreadsPerBlock = 1024; + prop->maxThreadsDim[0] = 1024; + prop->maxThreadsDim[1] = 1024; + } else { + prop->maxThreadsPerBlock = 512; + prop->maxThreadsDim[0] = 512; + prop->maxThreadsDim[1] = 512; + } -struct CUctx_st { - CUctx_st( _cuda_device_id *gpu ) - { - m_gpu = gpu; - m_binary_info.cmem = 0; - m_binary_info.gmem = 0; - } + prop->maxThreadsDim[2] = 64; + prop->maxGridSize[0] = 0x40000000; + prop->maxGridSize[1] = 0x40000000; + prop->maxGridSize[2] = 0x40000000; + prop->totalConstMem = 0x40000000; + prop->textureAlignment = 0; + // * TODO: Update the .config and xml files of all GPU config files + // with new value of sharedMemPerBlock and regsPerBlock + prop->sharedMemPerBlock = the_gpu->shared_mem_per_block(); +#if (CUDART_VERSION > 5050) + prop->regsPerMultiprocessor = the_gpu->num_registers_per_core(); + prop->sharedMemPerMultiprocessor = the_gpu->shared_mem_size(); +#endif + prop->sharedMemPerBlock = the_gpu->shared_mem_per_block(); + prop->regsPerBlock = the_gpu->num_registers_per_block(); + prop->warpSize = the_gpu->wrp_size(); + prop->clockRate = the_gpu->shader_clock(); +#if (CUDART_VERSION >= 2010) + prop->multiProcessorCount = the_gpu->get_config().num_shader(); +#endif +#if (CUDART_VERSION >= 4000) + prop->maxThreadsPerMultiProcessor = the_gpu->threads_per_core(); +#endif + the_gpu->set_prop(prop); + the_gpgpusim->the_cude_device = new _cuda_device_id(the_gpu); + the_device = the_gpgpusim->the_cude_device; + } + start_sim_thread(1); + return the_device; +} - _cuda_device_id *get_device() { return m_gpu; } +CUctx_st *GPGPUSim_Context(gpgpu_context *ctx) { + // static CUctx_st *the_context = NULL; + CUctx_st *the_context = ctx->the_gpgpusim->the_context; + if (the_context == NULL) { + _cuda_device_id *the_gpu = ctx->GPGPUSim_Init(); + ctx->the_gpgpusim->the_context = new CUctx_st(the_gpu); + the_context = ctx->the_gpgpusim->the_context; + } + return the_context; +} - void add_binary( symbol_table *symtab, unsigned fat_cubin_handle ) - { - m_code[fat_cubin_handle] = symtab; - m_last_fat_cubin_handle = fat_cubin_handle; - } +gpgpu_context *GPGPU_Context() { + static gpgpu_context *gpgpu_ctx = NULL; + if (gpgpu_ctx == NULL) { + gpgpu_ctx = new gpgpu_context(); + } + return gpgpu_ctx; +} - void add_ptxinfo( const char *deviceFun, const struct gpgpu_ptx_sim_info &info ) - { - symbol *s = m_code[m_last_fat_cubin_handle]->lookup(deviceFun); - assert( s != NULL ); - function_info *f = s->get_pc(); - assert( f != NULL ); - f->set_kernel_info(info); - } +void ptxinfo_data::ptxinfo_addinfo() { + CUctx_st *context = GPGPUSim_Context(gpgpu_ctx); + if (!get_ptxinfo_kname()) { + /* This info is not per kernel (since CUDA 5.0 some info (e.g. gmem, and + * cmem) is added at the beginning for the whole binary ) */ + print_ptxinfo(); + context->add_ptxinfo(get_ptxinfo()); + clear_ptxinfo(); + return; + } + if (!strcmp("__cuda_dummy_entry__", get_ptxinfo_kname())) { + // this string produced by ptxas for empty ptx files (e.g., bandwidth test) + clear_ptxinfo(); + return; + } + print_ptxinfo(); + context->add_ptxinfo(get_ptxinfo_kname(), get_ptxinfo()); + clear_ptxinfo(); +} - void add_ptxinfo( const struct gpgpu_ptx_sim_info &info ) - { - m_binary_info = info; - } +void cuda_not_implemented(const char *func, unsigned line) { + fflush(stdout); + fflush(stderr); + printf( + "\n\nGPGPU-Sim PTX: Execution error: CUDA API function \"%s()\" has not " + "been implemented yet.\n" + " [$GPGPUSIM_ROOT/libcuda/%s around line %u]\n\n\n", + func, __FILE__, line); + fflush(stdout); + abort(); +} - void register_function( unsigned fat_cubin_handle, const char *hostFun, const char *deviceFun ) - { - if( m_code.find(fat_cubin_handle) != m_code.end() ) { - symbol *s = m_code[fat_cubin_handle]->lookup(deviceFun); - if(s != NULL) { - function_info *f = s->get_pc(); - assert( f != NULL ); - m_kernel_lookup[hostFun] = f; - } - else { - printf("Warning: cannot find deviceFun %s\n", deviceFun); - m_kernel_lookup[hostFun] = NULL; - } - // assert( s != NULL ); - // function_info *f = s->get_pc(); - // assert( f != NULL ); - // m_kernel_lookup[hostFun] = f; - } else { - m_kernel_lookup[hostFun] = NULL; - } - } +void announce_call(const char *func) { + printf("\n\nGPGPU-Sim PTX: CUDA API function \"%s\" has been called.\n", + func); + fflush(stdout); +} - void register_hostFun_function( const char*hostFun, function_info* f){ - m_kernel_lookup[hostFun] = f; - } +#define gpgpusim_ptx_error(msg, ...) \ + gpgpusim_ptx_error_impl(__func__, __FILE__, __LINE__, msg, ##__VA_ARGS__) +#define gpgpusim_ptx_assert(cond, msg, ...) \ + gpgpusim_ptx_assert_impl((cond), __func__, __FILE__, __LINE__, msg, \ + ##__VA_ARGS__) - function_info *get_kernel(const char *hostFun) - { - std::map<const void*,function_info*>::iterator i=m_kernel_lookup.find(hostFun); - assert( i != m_kernel_lookup.end() ); - return i->second; - } +void gpgpusim_ptx_error_impl(const char *func, const char *file, unsigned line, + const char *msg, ...) { + va_list ap; + char buf[1024]; + va_start(ap, msg); + vsnprintf(buf, 1024, msg, ap); + va_end(ap); -private: - _cuda_device_id *m_gpu; // selected gpu - std::map<unsigned,symbol_table*> m_code; // fat binary handle => global symbol table - unsigned m_last_fat_cubin_handle; - std::map<const void*,function_info*> m_kernel_lookup; // unique id (CUDA app function address) => kernel entry point - struct gpgpu_ptx_sim_info m_binary_info; + printf("GPGPU-Sim CUDA API: %s\n", buf); + printf(" [%s:%u : %s]\n", file, line, func); + abort(); +} -}; +void gpgpusim_ptx_assert_impl(int test_value, const char *func, + const char *file, unsigned line, const char *msg, + ...) { + va_list ap; + char buf[1024]; + va_start(ap, msg); + vsnprintf(buf, 1024, msg, ap); + va_end(ap); -class kernel_config { -public: - kernel_config( dim3 GridDim, dim3 BlockDim, size_t sharedMem, struct CUstream_st *stream ) - { - m_GridDim=GridDim; - m_BlockDim=BlockDim; - m_sharedMem=sharedMem; - m_stream = stream; - } - kernel_config() - { - m_GridDim=dim3(-1,-1,-1); - m_BlockDim=dim3(-1,-1,-1); - m_sharedMem=0; - m_stream =NULL; - } - void set_arg( const void *arg, size_t size, size_t offset ) - { - m_args.push_front( gpgpu_ptx_sim_arg(arg,size,offset) ); - } - dim3 grid_dim() const { return m_GridDim; } - dim3 block_dim() const { return m_BlockDim; } - void set_grid_dim(dim3 *d) { m_GridDim = *d; } - void set_block_dim(dim3 *d) { m_BlockDim = *d; } - gpgpu_ptx_sim_arg_list_t get_args() { return m_args; } - struct CUstream_st *get_stream() { return m_stream; } + if (test_value == 0) gpgpusim_ptx_error_impl(func, file, line, msg); +} -private: - dim3 m_GridDim; - dim3 m_BlockDim; - size_t m_sharedMem; - struct CUstream_st *m_stream; - gpgpu_ptx_sim_arg_list_t m_args; -}; +typedef std::map<unsigned, CUevent_st *> event_tracker_t; -struct _cuda_device_id *GPGPUSim_Init() -{ - static _cuda_device_id *the_device = NULL; - if( !the_device ) { - gpgpu_sim *the_gpu = gpgpu_ptx_sim_init_perf(); +int CUevent_st::m_next_event_uid; +event_tracker_t g_timer_events; - cudaDeviceProp *prop = (cudaDeviceProp *) calloc(sizeof(cudaDeviceProp),1); - snprintf(prop->name,256,"GPGPU-Sim_v%s", g_gpgpusim_version_string ); - prop->major = the_gpu->compute_capability_major(); - prop->minor = the_gpu->compute_capability_minor(); - prop->totalGlobalMem = 0x80000000 /* 2 GB */; - prop->memPitch = 0; - if(prop->major >= 2) { - prop->maxThreadsPerBlock = 1024; - prop->maxThreadsDim[0] = 1024; - prop->maxThreadsDim[1] = 1024; - } - else - { - prop->maxThreadsPerBlock = 512; - prop->maxThreadsDim[0] = 512; - prop->maxThreadsDim[1] = 512; - } +extern int cuobjdump_lex_init(yyscan_t *scanner); +extern void cuobjdump_set_in(FILE *_in_str, yyscan_t yyscanner); +extern int cuobjdump_parse(yyscan_t scanner, struct cuobjdump_parser *parser, + std::list<cuobjdumpSection *> &cuobjdumpSectionList); +extern int cuobjdump_lex_destroy(yyscan_t scanner); - prop->maxThreadsDim[2] = 64; - prop->maxGridSize[0] = 0x40000000; - prop->maxGridSize[1] = 0x40000000; - prop->maxGridSize[2] = 0x40000000; - prop->totalConstMem = 0x40000000; - prop->textureAlignment = 0; -// * TODO: Update the .config and xml files of all GPU config files with new value of sharedMemPerBlock and regsPerBlock - prop->sharedMemPerBlock = the_gpu->shared_mem_per_block(); -#if (CUDART_VERSION > 5050) - prop->regsPerMultiprocessor = the_gpu->num_registers_per_core(); - prop->sharedMemPerMultiprocessor = the_gpu->shared_mem_size(); -#endif - prop->sharedMemPerBlock = the_gpu->shared_mem_per_block(); - prop->regsPerBlock = the_gpu->num_registers_per_core(); - prop->warpSize = the_gpu->wrp_size(); - prop->clockRate = the_gpu->shader_clock(); -#if (CUDART_VERSION >= 2010) - prop->multiProcessorCount = the_gpu->get_config().num_shader(); -#endif -#if (CUDART_VERSION >= 4000) - prop->maxThreadsPerMultiProcessor = the_gpu->threads_per_core(); -#endif - the_gpu->set_prop(prop); - the_device = new _cuda_device_id(the_gpu); - } - start_sim_thread(1); - return the_device; -} +enum cuobjdumpSectionType { PTXSECTION = 0, ELFSECTION }; -static CUctx_st* GPGPUSim_Context() -{ - static CUctx_st *the_context = NULL; - if( the_context == NULL ) { - _cuda_device_id *the_gpu = GPGPUSim_Init(); - the_context = new CUctx_st(the_gpu); - } - return the_context; +// sectiontype: 0 for ptx, 1 for elf +void addCuobjdumpSection(int sectiontype, + std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + if (sectiontype) + cuobjdumpSectionList.push_front(new cuobjdumpELFSection()); + else + cuobjdumpSectionList.push_front(new cuobjdumpPTXSection()); + printf("## Adding new section %s\n", sectiontype ? "ELF" : "PTX"); } - void ptxinfo_addinfo() -{ - if(!get_ptxinfo_kname()){ - /* This info is not per kernel (since CUDA 5.0 some info (e.g. gmem, and cmem) is added at the beginning for the whole binary ) */ - CUctx_st *context = GPGPUSim_Context(); - print_ptxinfo(); - context->add_ptxinfo(get_ptxinfo()); - clear_ptxinfo(); - return; - } - if( !strcmp("__cuda_dummy_entry__",get_ptxinfo_kname()) ) { - // this string produced by ptxas for empty ptx files (e.g., bandwidth test) - clear_ptxinfo(); - return; - } - CUctx_st *context = GPGPUSim_Context(); - print_ptxinfo(); - context->add_ptxinfo( get_ptxinfo_kname(), get_ptxinfo() ); - clear_ptxinfo(); +void setCuobjdumparch(const char *arch, + std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + unsigned archnum; + sscanf(arch, "sm_%u", &archnum); + assert(archnum && "cannot have sm_0"); + printf("Adding arch: %s\n", arch); + cuobjdumpSectionList.front()->setArch(archnum); } -void cuda_not_implemented( const char* func, unsigned line ) -{ - fflush(stdout); - fflush(stderr); - printf("\n\nGPGPU-Sim PTX: Execution error: CUDA API function \"%s()\" has not been implemented yet.\n" - " [$GPGPUSIM_ROOT/libcuda/%s around line %u]\n\n\n", - func,__FILE__, line ); - fflush(stdout); - abort(); +void setCuobjdumpidentifier( + const char *identifier, + std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + printf("Adding identifier: %s\n", identifier); + cuobjdumpSectionList.front()->setIdentifier(identifier); } -void announce_call( const char* func ) -{ - printf("\n\nGPGPU-Sim PTX: CUDA API function \"%s\" has been called.\n", func); - fflush(stdout); +void setCuobjdumpptxfilename( + const char *filename, std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + printf("Adding ptx filename: %s\n", filename); + cuobjdumpSection *x = cuobjdumpSectionList.front(); + if (dynamic_cast<cuobjdumpPTXSection *>(x) == NULL) { + assert(0 && + "You shouldn't be trying to add a ptxfilename to an elf section"); + } + (dynamic_cast<cuobjdumpPTXSection *>(x))->setPTXfilename(filename); } -#define gpgpusim_ptx_error(msg, ...) gpgpusim_ptx_error_impl(__func__, __FILE__,__LINE__, msg, ##__VA_ARGS__) -#define gpgpusim_ptx_assert(cond,msg, ...) gpgpusim_ptx_assert_impl((cond),__func__, __FILE__,__LINE__, msg, ##__VA_ARGS__) - -void gpgpusim_ptx_error_impl( const char *func, const char *file, unsigned line, const char *msg, ... ) -{ - va_list ap; - char buf[1024]; - va_start(ap,msg); - vsnprintf(buf,1024,msg,ap); - va_end(ap); +void setCuobjdumpelffilename( + const char *filename, std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + if (dynamic_cast<cuobjdumpELFSection *>(cuobjdumpSectionList.front()) == + NULL) { + assert(0 && + "You shouldn't be trying to add a elffilename to an ptx section"); + } + (dynamic_cast<cuobjdumpELFSection *>(cuobjdumpSectionList.front())) + ->setELFfilename(filename); +} - printf("GPGPU-Sim CUDA API: %s\n", buf); - printf(" [%s:%u : %s]\n", file, line, func ); - abort(); +void setCuobjdumpsassfilename( + const char *filename, std::list<cuobjdumpSection *> &cuobjdumpSectionList) { + if (dynamic_cast<cuobjdumpELFSection *>(cuobjdumpSectionList.front()) == + NULL) { + assert(0 && + "You shouldn't be trying to add a sassfilename to an ptx section"); + } + (dynamic_cast<cuobjdumpELFSection *>(cuobjdumpSectionList.front())) + ->setSASSfilename(filename); } -void gpgpusim_ptx_assert_impl( int test_value, const char *func, const char *file, unsigned line, const char *msg, ... ) -{ - va_list ap; - char buf[1024]; - va_start(ap,msg); - vsnprintf(buf,1024,msg,ap); - va_end(ap); +//! Return the executable file of the process containing the PTX/SASS code +//! +//! This Function returns the executable file ran by the process. This +//! executable is supposed to contain the PTX/SASS code. It provides workaround +//! for processes running on valgrind by dereferencing /proc/<pid>/exe within +//! the GPGPU-Sim process before calling cuobjdump to extract PTX/SASS. This is +//! needed because valgrind uses x86 emulation to detect memory leak. Other +//! processes (e.g. cuobjdump) reading /proc/<pid>/exe will see the emulator +//! executable instead of the application binary. +//! +std::string get_app_binary() { + char self_exe_path[1025]; +#ifdef __APPLE__ + uint32_t size = sizeof(self_exe_path); + if (_NSGetExecutablePath(self_exe_path, &size) != 0) { + printf("GPGPU-Sim ** ERROR: _NSGetExecutablePath input buffer too small\n"); + exit(1); + } +#else + std::stringstream exec_link; + exec_link << "/proc/self/exe"; + + ssize_t path_length = readlink(exec_link.str().c_str(), self_exe_path, 1024); + assert(path_length != -1); + self_exe_path[path_length] = '\0'; +#endif - if ( test_value == 0 ) - gpgpusim_ptx_error_impl(func, file, line, msg); + printf("self exe links to: %s\n", self_exe_path); + return self_exe_path; } +// above func gives abs path whereas this give just the name of application. +char *get_app_binary_name(std::string abs_path) { + char *self_exe_path; +#ifdef __APPLE__ + // TODO: get apple device and check the result. + printf("WARNING: not tested for Apple-mac devices \n"); + abort(); +#else + char *buf = strdup(abs_path.c_str()); + char *token = strtok(buf, "/"); + while (token != NULL) { + self_exe_path = token; + token = strtok(NULL, "/"); + } +#endif + self_exe_path = strtok(self_exe_path, "."); + printf("self exe links to: %s\n", self_exe_path); + return self_exe_path; +} -typedef std::map<unsigned,CUevent_st*> event_tracker_t; +static int get_app_cuda_version() { + int app_cuda_version = 0; + char fname[1024]; + snprintf(fname, 1024, "_app_cuda_version_XXXXXX"); + int fd = mkstemp(fname); + close(fd); + std::string app_cuda_version_command = + "ldd " + get_app_binary() + + " | grep libcudart.so | sed 's/.*libcudart.so.\\(.*\\) =>.*/\\1/' > " + + fname; + system(app_cuda_version_command.c_str()); + FILE *cmd = fopen(fname, "r"); + char buf[256]; + while (fgets(buf, sizeof(buf), cmd) != 0) { + std::cout << buf; + app_cuda_version = atoi(buf); + } + fclose(cmd); + if (app_cuda_version == 0) { + printf("Error - Cannot detect the app's CUDA version.\n"); + exit(1); + } + return app_cuda_version; +} -int CUevent_st::m_next_event_uid; -event_tracker_t g_timer_events; -int g_active_device = 0; //active gpu that runs the code -std::list<kernel_config> g_cuda_launch_stack; +//! Keep track of the association between filename and cubin handle +void cuda_runtime_api::cuobjdumpRegisterFatBinary(unsigned int handle, + const char *filename, + CUctx_st *context) { + fatbinmap[handle] = filename; +} /******************************************************************************* - * * - * * - * * + * Add internal cuda runtime API call to accept gpgpu_context * *******************************************************************************/ +cudaError_t cudaSetDeviceInternal(int device, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // set the active device to run cuda + if (device <= ctx->GPGPUSim_Init()->num_devices()) { + ctx->api->g_active_device = device; + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorInvalidDevice; + } +} -extern "C" { +cudaError_t cudaGetDeviceInternal(int *device, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *device = ctx->api->g_active_device; + return g_last_cudaError = cudaSuccess; +} -/******************************************************************************* - * * - * * - * * - *******************************************************************************/ -cudaError_t cudaPeekAtLastError(void) -{ - return g_last_cudaError; +__host__ cudaError_t CUDARTAPI cudaDeviceGetLimitInternal( + size_t *pValue, cudaLimit limit, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + const struct cudaDeviceProp *prop = dev->get_prop(); + const gpgpu_sim_config &config = dev->get_gpgpu()->get_config(); + switch (limit) { + case 0: // cudaLimitStackSize + *pValue = config.stack_limit(); + break; + case 2: // cudaLimitMallocHeapSize + *pValue = config.heap_limit(); + break; +#if (CUDART_VERSION > 5050) + case 3: // cudaLimitDevRuntimeSyncDepth + if (prop->major > 2) { + *pValue = config.sync_depth_limit(); + break; + } else { + printf("ERROR:Limit %d is not supported on this architecture \n", + limit); + abort(); + } + case 4: // cudaLimitDevRuntimePendingLaunchCount + if (prop->major > 2) { + *pValue = config.pending_launch_count_limit(); + break; + } else { + printf("ERROR:Limit %d is not supported on this architecture \n", + limit); + abort(); + } +#endif + default: + printf("ERROR:Limit %d unimplemented \n", limit); + abort(); + } + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaMalloc(void **devPtr, size_t size) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); +void **cudaRegisterFatBinaryInternal(void *fatCubin, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } +#if (CUDART_VERSION < 2010) + printf( + "GPGPU-Sim PTX: ERROR ** this version of GPGPU-Sim requires CUDA 2.1 or " + "higher\n"); + exit(1); +#endif + CUctx_st *context = GPGPUSim_Context(ctx); + static unsigned next_fat_bin_handle = 1; + if (context->get_device()->get_gpgpu()->get_config().use_cuobjdump()) { + // The following workaround has only been verified on 64-bit systems. + if (sizeof(void *) == 4) + printf( + "GPGPU-Sim PTX: FatBin file name extraction has not been tested on " + "32-bit system.\n"); + + // This code will get the CUDA version the app was compiled with. + // We need this to determine how to handle the parsing of the binary. + // Making this a runtime variable based on the app, enables GPGPU-Sim + // compiled with a newer version of CUDA to run apps compiled with older + // versions of CUDA. This is especially useful for PTXPLUS execution. + // Skip cuda version check for pytorch application + std::string app_binary_path = get_app_binary(); + int pos = app_binary_path.find("python"); + if (pos == std::string::npos) { + // Not pytorch app : checking cuda version + int app_cuda_version = get_app_cuda_version(); + assert( + app_cuda_version == CUDART_VERSION / 1000 && + "The app must be compiled with same major version as the simulator."); + } + + // int app_cuda_version = get_app_cuda_version(); + // assert( app_cuda_version == CUDART_VERSION / 1000 && "The app must be + // compiled with same major version as the simulator." ); + const char *filename; +#if CUDART_VERSION < 6000 + // FatBin handle from the .fatbin.c file (one of the intermediate files + // generated by NVCC) + typedef struct { + int m; + int v; + const unsigned long long *d; + char *f; + } __fatDeviceText __attribute__((aligned(8))); + __fatDeviceText *fatDeviceText = (__fatDeviceText *)fatCubin; + + // Extract the source code file name that generate the given FatBin. + // - Obtains the pointer to the actual fatbin structure from the FatBin + // handle (fatCubin). + // - An integer inside the fatbin structure contains the relative offset to + // the source code file name. + // - This offset differs among different CUDA and GCC versions. + char *pfatbin = (char *)fatDeviceText->d; + int offset = *((int *)(pfatbin + 48)); + filename = (pfatbin + 16 + offset); +#else + filename = "default"; +#endif + + // The extracted file name is associated with a fat_cubin_handle passed + // into cudaLaunch(). Inside cudaLaunch(), the associated file name is + // used to find the PTX/SASS section from cuobjdump, which contains the + // PTX/SASS code for the launched kernel function. + // This allows us to work around the fact that cuobjdump only outputs the + // file name associated with each section. + unsigned long long fat_cubin_handle = next_fat_bin_handle; + next_fat_bin_handle++; + printf( + "GPGPU-Sim PTX: __cudaRegisterFatBinary, fat_cubin_handle = %llu, " + "filename=%s\n", + fat_cubin_handle, filename); + /*! + * This function extracts all data from all files in first call + * then for next calls, only returns the appropriate number + */ + assert(fat_cubin_handle >= 1); + if (fat_cubin_handle == 1) ctx->api->cuobjdumpInit(); + ctx->api->cuobjdumpRegisterFatBinary(fat_cubin_handle, filename, context); + + return (void **)fat_cubin_handle; + } +#if (CUDART_VERSION < 8000) + else { + static unsigned source_num = 1; + unsigned long long fat_cubin_handle = next_fat_bin_handle++; + __cudaFatCudaBinary *info = (__cudaFatCudaBinary *)fatCubin; + assert(info->version >= 3); + unsigned num_ptx_versions = 0; + unsigned max_capability = 0; + unsigned selected_capability = 0; + bool found = false; + unsigned forced_max_capability = context->get_device() + ->get_gpgpu() + ->get_config() + .get_forced_max_capability(); + if (!info->ptx) { + printf( + "ERROR: Cannot find ptx code in cubin file\n" + "\tIf you are using CUDA 4.0 or higher, please enable " + "-gpgpu_ptx_use_cuobjdump or downgrade to CUDA 3.1\n"); + exit(1); } - CUctx_st* context = GPGPUSim_Context(); - *devPtr = context->get_device()->get_gpgpu()->gpu_malloc(size); - if(g_debug_execution >= 3){ - printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n",size, (unsigned long long) *devPtr); - g_mallocPtr_Size[(unsigned long long)*devPtr] = size; + while (info->ptx[num_ptx_versions].gpuProfileName != NULL) { + unsigned capability = 0; + sscanf(info->ptx[num_ptx_versions].gpuProfileName, "compute_%u", + &capability); + printf( + "GPGPU-Sim PTX: __cudaRegisterFatBinary found PTX versions for " + "'%s', ", + info->ident); + printf("capability = %s\n", info->ptx[num_ptx_versions].gpuProfileName); + if (forced_max_capability) { + if (capability > max_capability && + capability <= forced_max_capability) { + found = true; + max_capability = capability; + selected_capability = num_ptx_versions; + } + } else { + if (capability > max_capability) { + found = true; + max_capability = capability; + selected_capability = num_ptx_versions; + } + } + num_ptx_versions++; + } + if (found) { + printf("GPGPU-Sim PTX: Loading PTX for %s, capability = %s\n", + info->ident, info->ptx[selected_capability].gpuProfileName); + symbol_table *symtab; + const char *ptx = info->ptx[selected_capability].ptx; + if (context->get_device() + ->get_gpgpu() + ->get_config() + .convert_to_ptxplus()) { + printf( + "GPGPU-Sim PTX: ERROR ** PTXPlus is only supported through " + "cuobjdump\n" + "\tEither enable cuobjdump or disable PTXPlus in your " + "configuration file\n"); + exit(1); + } else { + symtab = ctx->gpgpu_ptx_sim_load_ptx_from_string(ptx, source_num); + context->add_binary(symtab, fat_cubin_handle); + ctx->gpgpu_ptxinfo_load_from_string(ptx, source_num, max_capability, + context->no_of_ptx); + } + source_num++; + ctx->api->load_static_globals(symtab, STATIC_ALLOC_LIMIT, 0xFFFFFFFF, + context->get_device()->get_gpgpu()); + ctx->api->load_constants(symtab, STATIC_ALLOC_LIMIT, + context->get_device()->get_gpgpu()); + } else { + printf( + "GPGPU-Sim PTX: warning -- did not find an appropriate PTX in " + "cubin\n"); } - if ( *devPtr ) { - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } + return (void **)fat_cubin_handle; + } +#else + else { + printf("ERROR ** __cudaRegisterFatBinary() needs to be updated\n"); + abort(); + } +#endif } -__host__ cudaError_t CUDARTAPI cudaMallocHost(void **ptr, size_t size) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - GPGPUSim_Context(); - *ptr = malloc(size); - if ( *ptr ) { - //track pinned memory size allocated in the host so that same amount of memory is also allocated in GPU. - pinned_memory_size[*ptr]=size; - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } +void cudaRegisterFunctionInternal(void **fatCubinHandle, const char *hostFun, + char *deviceFun, const char *deviceName, + int thread_limit, uint3 *tid, uint3 *bid, + dim3 *bDim, dim3 *gDim, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + unsigned fat_cubin_handle = (unsigned)(unsigned long long)fatCubinHandle; + printf( + "GPGPU-Sim PTX: __cudaRegisterFunction %s : hostFun 0x%p, " + "fat_cubin_handle = %u\n", + deviceFun, hostFun, fat_cubin_handle); + if (context->get_device()->get_gpgpu()->get_config().use_cuobjdump()) + ctx->cuobjdumpParseBinary(fat_cubin_handle); + context->register_function(fat_cubin_handle, hostFun, deviceFun); } -__host__ cudaError_t CUDARTAPI cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - unsigned malloc_width_inbytes = width; - printf("GPGPU-Sim PTX: cudaMallocPitch (width = %d)\n", malloc_width_inbytes); - CUctx_st* ctx = GPGPUSim_Context(); - *devPtr = ctx->get_device()->get_gpgpu()->gpu_malloc(malloc_width_inbytes*height); - pitch[0] = malloc_width_inbytes; - if ( *devPtr ) { - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } + +void cudaRegisterVarInternal( + void **fatCubinHandle, + char *hostVar, // pointer to...something + char *deviceAddress, // name of variable + const char *deviceName, // name of variable (same as above) + int ext, int size, int constant, int global, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf( + "GPGPU-Sim PTX: __cudaRegisterVar: hostVar = %p; deviceAddress = %s; " + "deviceName = %s\n", + hostVar, deviceAddress, deviceName); + printf( + "GPGPU-Sim PTX: __cudaRegisterVar: Registering const memory space of %d " + "bytes\n", + size); + if (GPGPUSim_Context(ctx) + ->get_device() + ->get_gpgpu() + ->get_config() + .use_cuobjdump()) + ctx->cuobjdumpParseBinary((unsigned)(unsigned long long)fatCubinHandle); + fflush(stdout); + if (constant && !global && !ext) { + ctx->func_sim->gpgpu_ptx_sim_register_const_variable(hostVar, deviceName, + size); + } else if (!constant && !global && !ext) { + ctx->func_sim->gpgpu_ptx_sim_register_global_variable(hostVar, deviceName, + size); + } else + cuda_not_implemented(__my_func__, __LINE__); } -__host__ cudaError_t CUDARTAPI cudaMallocArray(struct cudaArray **array, const struct cudaChannelFormatDesc *desc, size_t width, size_t height __dv(1)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - unsigned size = width * height * ((desc->x + desc->y + desc->z + desc->w)/8); - CUctx_st* context = GPGPUSim_Context(); - (*array) = (struct cudaArray*) malloc(sizeof(struct cudaArray)); - (*array)->desc = *desc; - (*array)->width = width; - (*array)->height = height; - (*array)->size = size; - (*array)->dimensions = 2; - ((*array)->devPtr32)= (int) (long long)context->get_device()->get_gpgpu()->gpu_mallocarray(size); - printf("GPGPU-Sim PTX: cudaMallocArray: devPtr32 = %d\n", ((*array)->devPtr32)); - ((*array)->devPtr) = (void*) (long long) ((*array)->devPtr32); - if ( ((*array)->devPtr) ) { - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } +cudaError_t cudaConfigureCallInternal(dim3 gridDim, dim3 blockDim, + size_t sharedMem, cudaStream_t stream, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + struct CUstream_st *s = (struct CUstream_st *)stream; + ctx->api->g_cuda_launch_stack.push_back( + kernel_config(gridDim, blockDim, sharedMem, s)); + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaFree(void *devPtr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - // TODO... manage g_global_mem space? - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaGetDeviceCountInternal(int *count, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + *count = dev->num_devices(); + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaFreeHost(void *ptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - free (ptr); // this will crash the system if called twice - return g_last_cudaError = cudaSuccess; + +__host__ cudaError_t CUDARTAPI cudaGetDevicePropertiesInternal( + struct cudaDeviceProp *prop, int device, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + if (device <= dev->num_devices()) { + *prop = *dev->get_prop(); + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorInvalidDevice; + } } -__host__ cudaError_t CUDARTAPI cudaFreeArray(struct cudaArray *array) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - // TODO... manage g_global_mem space? - return g_last_cudaError = cudaSuccess; -}; +__host__ cudaError_t CUDARTAPI +cudaChooseDeviceInternal(int *device, const struct cudaDeviceProp *prop, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + *device = dev->get_id(); + return g_last_cudaError = cudaSuccess; +} +cudaError_t cudaSetupArgumentInternal(const void *arg, size_t size, + size_t offset, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + gpgpusim_ptx_assert(!ctx->api->g_cuda_launch_stack.empty(), + "empty launch stack"); + kernel_config &config = ctx->api->g_cuda_launch_stack.back(); + config.set_arg(arg, size, offset); + printf( + "GPGPU-Sim PTX: Setting up arguments for %zu bytes starting at " + "0x%llx..\n", + size, (unsigned long long)arg); -/******************************************************************************* - * * - * * - * * - *******************************************************************************/ + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); +cudaError_t cudaLaunchInternal(const char *hostFun, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + char *mode = getenv("PTX_SIM_MODE_FUNC"); + if (mode) sscanf(mode, "%u", &(ctx->func_sim->g_ptx_sim_mode)); + gpgpusim_ptx_assert(!ctx->api->g_cuda_launch_stack.empty(), + "empty launch stack"); + kernel_config config = ctx->api->g_cuda_launch_stack.back(); + { + dim3 gridDim = config.grid_dim(); + dim3 blockDim = config.block_dim(); + if (gridDim.x * gridDim.y * gridDim.z == 0 || + blockDim.x * blockDim.y * blockDim.z == 0) { + // can't launch + printf("can't launch a empty kernel\n"); + ctx->api->g_cuda_launch_stack.pop_back(); + return g_last_cudaError = cudaErrorInvalidConfiguration; } - //CUctx_st *context = GPGPUSim_Context(); - //gpgpu_t *gpu = context->get_device()->get_gpgpu(); - if(g_debug_execution >= 3) - printf("GPGPU-Sim PTX: cudaMemcpy(): devPtr = %p\n", dst); - if( kind == cudaMemcpyHostToDevice ) - g_stream_manager->push( stream_operation(src,(size_t)dst,count,0) ); - else if( kind == cudaMemcpyDeviceToHost ) - g_stream_manager->push( stream_operation((size_t)src,dst,count,0) ); - else if( kind == cudaMemcpyDeviceToDevice ) - g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,0) ); - else if ( kind == cudaMemcpyDefault ) { - if ((size_t)src >= GLOBAL_HEAP_START) { - if ((size_t)dst >= GLOBAL_HEAP_START) - g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,0) ); // device to device - else - g_stream_manager->push( stream_operation((size_t)src,dst,count,0) ); // device to host - } - else { - if ((size_t)dst >= GLOBAL_HEAP_START) - g_stream_manager->push( stream_operation(src,(size_t)dst,count,0) ); - else { - printf("GPGPU-Sim PTX: cudaMemcpy - ERROR : unsupported transfer: host to host\n"); - abort(); - } - } - } - else { - printf("GPGPU-Sim PTX: cudaMemcpy - ERROR : unsupported cudaMemcpyKind\n"); - abort(); - } - return g_last_cudaError = cudaSuccess; + } + struct CUstream_st *stream = config.get_stream(); + + printf("\nGPGPU-Sim PTX: cudaLaunch for 0x%p (mode=%s) on stream %u\n", + hostFun, + (ctx->func_sim->g_ptx_sim_mode) ? "functional simulation" + : "performance simulation", + stream ? stream->get_uid() : 0); + kernel_info_t *grid = ctx->api->gpgpu_cuda_ptx_sim_init_grid( + hostFun, config.get_args(), config.grid_dim(), config.block_dim(), + context); + // do dynamic PDOM analysis for performance simulation scenario + std::string kname = grid->name(); + function_info *kernel_func_info = grid->entry(); + if (kernel_func_info->is_pdom_set()) { + printf("GPGPU-Sim PTX: PDOM analysis already done for %s \n", + kname.c_str()); + } else { + printf("GPGPU-Sim PTX: finding reconvergence points for \'%s\'...\n", + kname.c_str()); + kernel_func_info->do_pdom(); + kernel_func_info->set_pdom(); + } + dim3 gridDim = config.grid_dim(); + dim3 blockDim = config.block_dim(); + + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + checkpoint *g_checkpoint; + g_checkpoint = new checkpoint(); + class memory_space *global_mem; + global_mem = gpu->get_global_memory(); + + if (gpu->resume_option == 1 && (grid->get_uid() == gpu->resume_kernel)) { + char f1name[2048]; + snprintf(f1name, 2048, "checkpoint_files/global_mem_%d.txt", + grid->get_uid()); + + g_checkpoint->load_global_mem(global_mem, f1name); + for (int i = 0; i < gpu->resume_CTA; i++) grid->increment_cta_id(); + } + if (gpu->resume_option == 1 && (grid->get_uid() < gpu->resume_kernel)) { + char f1name[2048]; + snprintf(f1name, 2048, "checkpoint_files/global_mem_%d.txt", + grid->get_uid()); + + g_checkpoint->load_global_mem(global_mem, f1name); + printf("Skipping kernel %d as resuming from kernel %d\n", grid->get_uid(), + gpu->resume_kernel); + ctx->api->g_cuda_launch_stack.pop_back(); + return g_last_cudaError = cudaSuccess; + } + if (gpu->checkpoint_option == 1 && + (grid->get_uid() > gpu->checkpoint_kernel)) { + printf("Skipping kernel %d as checkpoint from kernel %d\n", grid->get_uid(), + gpu->checkpoint_kernel); + ctx->api->g_cuda_launch_stack.pop_back(); + return g_last_cudaError = cudaSuccess; + } + printf( + "GPGPU-Sim PTX: pushing kernel \'%s\' to stream %u, gridDim= (%u,%u,%u) " + "blockDim = (%u,%u,%u) \n", + kname.c_str(), stream ? stream->get_uid() : 0, gridDim.x, gridDim.y, + gridDim.z, blockDim.x, blockDim.y, blockDim.z); + stream_operation op(grid, ctx->func_sim->g_ptx_sim_mode, stream); + ctx->the_gpgpusim->g_stream_manager->push(op); + ctx->api->g_cuda_launch_stack.pop_back(); + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaMemcpyToArray(struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - size_t size = count; - printf("GPGPU-Sim PTX: cudaMemcpyToArray\n"); - if( kind == cudaMemcpyHostToDevice ) - gpu->memcpy_to_gpu( (size_t)(dst->devPtr), src, size); - else if( kind == cudaMemcpyDeviceToHost ) - gpu->memcpy_from_gpu( dst->devPtr, (size_t)src, size); - else if( kind == cudaMemcpyDeviceToDevice ) - gpu->memcpy_gpu_to_gpu( (size_t)(dst->devPtr), (size_t)src, size); - else { - printf("GPGPU-Sim PTX: cudaMemcpyToArray - ERROR : unsupported cudaMemcpyKind\n"); - abort(); - } - dst->devPtr32 = (unsigned) (size_t)(dst->devPtr); - return g_last_cudaError = cudaSuccess; +cudaError_t cudaMallocInternal(void **devPtr, size_t size, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + *devPtr = context->get_device()->get_gpgpu()->gpu_malloc(size); + if (g_debug_execution >= 3) { + printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n", + size, (unsigned long long)*devPtr); + ctx->api->g_mallocPtr_Size[(unsigned long long)*devPtr] = size; + } + if (*devPtr) { + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } } +cudaError_t cudaMallocHostInternal(void **ptr, size_t size, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *ptr = malloc(size); + if (*ptr) { + // track pinned memory size allocated in the host so that same amount of + // memory is also allocated in GPU. + ctx->api->pinned_memory_size[*ptr] = size; + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } +} -__host__ cudaError_t CUDARTAPI cudaMemcpyFromArray(void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI +cudaMallocPitchInternal(void **devPtr, size_t *pitch, size_t width, + size_t height, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + unsigned malloc_width_inbytes = width; + printf("GPGPU-Sim PTX: cudaMallocPitch (width = %d)\n", malloc_width_inbytes); + CUctx_st *context = GPGPUSim_Context(ctx); + *devPtr = context->get_device()->get_gpgpu()->gpu_malloc( + malloc_width_inbytes * height); + pitch[0] = malloc_width_inbytes; + if (*devPtr) { + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } } +cudaError_t cudaHostGetDevicePointerInternal(void **pDevice, void *pHost, + unsigned int flags, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // only cpu memory allocation happens in cudaHostAlloc. Linking with device + // pointer to pinned memory happens here. + // TODO: once kernel is executed, the contents in global pointer of GPU must + // be copied back to CPU host pointer! + flags = 0; + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + std::map<void *, size_t>::const_iterator i = + ctx->api->pinned_memory_size.find(pHost); + assert(i != ctx->api->pinned_memory_size.end()); + size_t size = i->second; + *pDevice = gpu->gpu_malloc(size); + if (g_debug_execution >= 3) { + printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n", + size, (unsigned long long)*pDevice); + ctx->api->g_mallocPtr_Size[(unsigned long long)*pDevice] = size; + } + if (*pDevice) { + ctx->api->pinned_memory[pHost] = pDevice; + // Copy contents in cpu to gpu + gpu->memcpy_to_gpu((size_t)*pDevice, pHost, size); + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } +} -__host__ cudaError_t CUDARTAPI cudaMemcpyArrayToArray(struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); +__host__ cudaError_t CUDARTAPI cudaMallocArrayInternal( + struct cudaArray **array, const struct cudaChannelFormatDesc *desc, + size_t width, size_t height __dv(1), gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + unsigned size = + width * height * ((desc->x + desc->y + desc->z + desc->w) / 8); + CUctx_st *context = GPGPUSim_Context(ctx); + (*array) = (struct cudaArray *)malloc(sizeof(struct cudaArray)); + (*array)->desc = *desc; + (*array)->width = width; + (*array)->height = height; + (*array)->size = size; + (*array)->dimensions = 2; + ((*array)->devPtr32) = + (int)(long long)context->get_device()->get_gpgpu()->gpu_mallocarray(size); + printf("GPGPU-Sim PTX: cudaMallocArray: devPtr32 = %d\n", + ((*array)->devPtr32)); + ((*array)->devPtr) = (void *)(long long)((*array)->devPtr32); + if (((*array)->devPtr)) { + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } +} + +__host__ cudaError_t CUDARTAPI +cudaMemcpyInternal(void *dst, const void *src, size_t count, + enum cudaMemcpyKind kind, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // CUctx_st *context = GPGPUSim_Context(); + // gpgpu_t *gpu = context->get_device()->get_gpgpu(); + if (g_debug_execution >= 3) + printf("GPGPU-Sim PTX: cudaMemcpy(): devPtr = %p\n", dst); + if (kind == cudaMemcpyHostToDevice) + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation(src, (size_t)dst, count, 0)); + else if (kind == cudaMemcpyDeviceToHost) + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation((size_t)src, dst, count, 0)); + else if (kind == cudaMemcpyDeviceToDevice) + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation((size_t)src, (size_t)dst, count, 0)); + else if (kind == cudaMemcpyDefault) { + if ((size_t)src >= GLOBAL_HEAP_START) { + if ((size_t)dst >= GLOBAL_HEAP_START) + ctx->the_gpgpusim->g_stream_manager->push(stream_operation( + (size_t)src, (size_t)dst, count, 0)); // device to device + else + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation((size_t)src, dst, count, 0)); // device to host + } else { + if ((size_t)dst >= GLOBAL_HEAP_START) + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation(src, (size_t)dst, count, 0)); + else { + printf( + "GPGPU-Sim PTX: cudaMemcpy - ERROR : unsupported transfer: host to " + "host\n"); + abort(); + } } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; + } else { + printf("GPGPU-Sim PTX: cudaMemcpy - ERROR : unsupported cudaMemcpyKind\n"); + abort(); + } + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaMemcpyToArrayInternal( + struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, + size_t count, enum cudaMemcpyKind kind, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + size_t size = count; + printf("GPGPU-Sim PTX: cudaMemcpyToArray\n"); + if (kind == cudaMemcpyHostToDevice) + gpu->memcpy_to_gpu((size_t)(dst->devPtr), src, size); + else if (kind == cudaMemcpyDeviceToHost) + gpu->memcpy_from_gpu(dst->devPtr, (size_t)src, size); + else if (kind == cudaMemcpyDeviceToDevice) + gpu->memcpy_gpu_to_gpu((size_t)(dst->devPtr), (size_t)src, size); + else { + printf( + "GPGPU-Sim PTX: cudaMemcpyToArray - ERROR : unsupported " + "cudaMemcpyKind\n"); + abort(); + } + dst->devPtr32 = (unsigned)(size_t)(dst->devPtr); + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - size_t size = spitch*height; - gpgpusim_ptx_assert( (dpitch==spitch), "different src and dst pitch not supported yet" ); - if( kind == cudaMemcpyHostToDevice ) - gpu->memcpy_to_gpu( (size_t)dst, src, size ); - else if( kind == cudaMemcpyDeviceToHost ) - gpu->memcpy_from_gpu( dst, (size_t)src, size ); - else if( kind == cudaMemcpyDeviceToDevice ) - gpu->memcpy_gpu_to_gpu( (size_t)dst, (size_t)src, size); - else { - printf("GPGPU-Sim PTX: cudaMemcpy2D - ERROR : unsupported cudaMemcpyKind\n"); - abort(); - } - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpy2DInternal( + void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, + size_t height, enum cudaMemcpyKind kind, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + size_t size = spitch * height; + gpgpusim_ptx_assert((dpitch == spitch), + "different src and dst pitch not supported yet"); + if (kind == cudaMemcpyHostToDevice) + gpu->memcpy_to_gpu((size_t)dst, src, size); + else if (kind == cudaMemcpyDeviceToHost) + gpu->memcpy_from_gpu(dst, (size_t)src, size); + else if (kind == cudaMemcpyDeviceToDevice) + gpu->memcpy_gpu_to_gpu((size_t)dst, (size_t)src, size); + else { + printf( + "GPGPU-Sim PTX: cudaMemcpy2D - ERROR : unsupported cudaMemcpyKind\n"); + abort(); + } + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaMemcpy2DToArrayInternal( + struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, + size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + size_t size = spitch * height; + size_t channel_size = dst->desc.w + dst->desc.x + dst->desc.y + dst->desc.z; + gpgpusim_ptx_assert( + ((channel_size % 8) == 0), + "none byte multiple destination channel size not supported (sz=%u)", + channel_size); + unsigned elem_size = channel_size / 8; + gpgpusim_ptx_assert((dst->dimensions == 2), + "copy to none 2D array not supported"); + gpgpusim_ptx_assert((wOffset == 0), "non-zero wOffset not yet supported"); + gpgpusim_ptx_assert((hOffset == 0), "non-zero hOffset not yet supported"); + gpgpusim_ptx_assert((dst->height == (int)height), + "partial copy not supported"); + gpgpusim_ptx_assert((elem_size * dst->width == width), + "partial copy not supported"); + gpgpusim_ptx_assert((spitch == width), "spitch != width not supported"); + if (kind == cudaMemcpyHostToDevice) + gpu->memcpy_to_gpu((size_t)(dst->devPtr), src, size); + else if (kind == cudaMemcpyDeviceToHost) + gpu->memcpy_from_gpu(dst->devPtr, (size_t)src, size); + else if (kind == cudaMemcpyDeviceToDevice) + gpu->memcpy_gpu_to_gpu((size_t)dst->devPtr, (size_t)src, size); + else { + printf( + "GPGPU-Sim PTX: cudaMemcpy2D - ERROR : unsupported cudaMemcpyKind\n"); + abort(); + } + dst->devPtr32 = (unsigned)(size_t)(dst->devPtr); + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpy2DToArray(struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - size_t size = spitch*height; - size_t channel_size = dst->desc.w+dst->desc.x+dst->desc.y+dst->desc.z; - gpgpusim_ptx_assert( ((channel_size%8) == 0), "none byte multiple destination channel size not supported (sz=%u)", channel_size ); - unsigned elem_size = channel_size/8; - gpgpusim_ptx_assert( (dst->dimensions==2), "copy to none 2D array not supported" ); - gpgpusim_ptx_assert( (wOffset==0), "non-zero wOffset not yet supported" ); - gpgpusim_ptx_assert( (hOffset==0), "non-zero hOffset not yet supported" ); - gpgpusim_ptx_assert( (dst->height == (int)height), "partial copy not supported" ); - gpgpusim_ptx_assert( (elem_size*dst->width == width), "partial copy not supported" ); - gpgpusim_ptx_assert( (spitch == width), "spitch != width not supported" ); - if( kind == cudaMemcpyHostToDevice ) - gpu->memcpy_to_gpu( (size_t)(dst->devPtr), src, size); - else if( kind == cudaMemcpyDeviceToHost ) - gpu->memcpy_from_gpu( dst->devPtr, (size_t)src, size); - else if( kind == cudaMemcpyDeviceToDevice ) - gpu->memcpy_gpu_to_gpu( (size_t)dst->devPtr, (size_t)src, size); - else { - printf("GPGPU-Sim PTX: cudaMemcpy2D - ERROR : unsupported cudaMemcpyKind\n"); - abort(); - } - dst->devPtr32 = (unsigned) (size_t)(dst->devPtr); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpyToSymbolInternal( + const char *symbol, const void *src, size_t count, size_t offset __dv(0), + enum cudaMemcpyKind kind __dv(cudaMemcpyHostToDevice), + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // CUctx_st *context = GPGPUSim_Context(); + assert(kind == cudaMemcpyHostToDevice); + printf("GPGPU-Sim PTX: cudaMemcpyToSymbol: symbol = %p\n", symbol); + // stream_operation( const char *symbol, const void *src, size_t count, size_t + // offset ) + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation(src, symbol, count, offset, 0)); + // gpgpu_ptx_sim_memcpy_symbol(symbol,src,count,offset,1,context->get_device()->get_gpgpu()); + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbolInternal( + void *dst, const char *symbol, size_t count, size_t offset __dv(0), + enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToHost), + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // CUctx_st *context = GPGPUSim_Context(); + assert(kind == cudaMemcpyDeviceToHost); + printf("GPGPU-Sim PTX: cudaMemcpyFromSymbol: symbol = %p\n", symbol); + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation(symbol, dst, count, offset, 0)); + // gpgpu_ptx_sim_memcpy_symbol(symbol,dst,count,offset,0,context->get_device()->get_gpgpu()); + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArray(void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaMemcpyAsyncInternal( + void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, + cudaStream_t stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + struct CUstream_st *s = (struct CUstream_st *)stream; + switch (kind) { + case cudaMemcpyHostToDevice: + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation(src, (size_t)dst, count, s)); + break; + case cudaMemcpyDeviceToHost: + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation((size_t)src, dst, count, s)); + break; + case cudaMemcpyDeviceToDevice: + ctx->the_gpgpusim->g_stream_manager->push( + stream_operation((size_t)src, (size_t)dst, count, s)); + break; + default: + abort(); + } + return g_last_cudaError = cudaSuccess; } +#if (CUDART_VERSION >= 8000) +cudaError_t CUDARTAPI +cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlagsInternal( + int *numBlocks, const char *hostFunc, int blockSize, size_t dynamicSMemSize, + unsigned int flags, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + printf( + "GPGPU-Sim PTX: cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags " + "%p\n", + hostFunc); + CUctx_st *context = GPGPUSim_Context(ctx); + function_info *entry = context->get_kernel(hostFunc); + printf( + "Calculate Maxium Active Block with function ptr=%p, blockSize=%d, " + "SMemSize=%d\n", + hostFunc, blockSize, dynamicSMemSize); + if (flags == cudaOccupancyDefault) { + // create kernel_info based on entry + dim3 gridDim(context->get_device()->get_gpgpu()->max_cta_per_core() * + context->get_device()->get_gpgpu()->get_config().num_shader()); + dim3 blockDim(blockSize); + kernel_info_t result(gridDim, blockDim, entry); + // if(entry == NULL){ + // *numBlocks = 1; + // return g_last_cudaError = cudaErrorUnknown; + //} + *numBlocks = context->get_device()->get_gpgpu()->get_max_cta(result); + printf("Maximum size is %d with gridDim %d and blockDim %d\n", *numBlocks, + gridDim.x, blockDim.x); + return g_last_cudaError = cudaSuccess; + } else { + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; + } +} -__host__ cudaError_t CUDARTAPI cudaMemcpy2DArrayToArray(struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +#endif + +__host__ cudaError_t CUDARTAPI cudaMemsetInternal( + void *mem, int c, size_t count, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + gpu->gpu_memset((size_t)mem, c, count); + return g_last_cudaError = cudaSuccess; } +// memset operation is done but i think its not async? +__host__ cudaError_t CUDARTAPI +cudaMemsetAsyncInternal(void *mem, int c, size_t count, cudaStream_t stream = 0, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: WARNING: Asynchronous memset not supported (%s)\n", + __my_func__); + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + gpu->gpu_memset((size_t)mem, c, count); + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpyToSymbol(const char *symbol, const void *src, size_t count, size_t offset __dv(0), enum cudaMemcpyKind kind __dv(cudaMemcpyHostToDevice)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //CUctx_st *context = GPGPUSim_Context(); - assert(kind == cudaMemcpyHostToDevice); - printf("GPGPU-Sim PTX: cudaMemcpyToSymbol: symbol = %p\n", symbol); - //stream_operation( const char *symbol, const void *src, size_t count, size_t offset ) - g_stream_manager->push( stream_operation(src,symbol,count,offset,0) ); - //gpgpu_ptx_sim_memcpy_symbol(symbol,src,count,offset,1,context->get_device()->get_gpgpu()); - return g_last_cudaError = cudaSuccess; +cudaError_t cudaGLMapBufferObjectInternal(void **devPtr, GLuint bufferObj, + gpgpu_context *gpgpu_ctx = NULL) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } +#ifdef OPENGL_SUPPORT + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + GLint buffer_size = 0; + CUctx_st *context = GPGPUSim_Context(ctx); + + glbmap_entry_t *p = ctx->api->g_glbmap; + while (p && p->m_bufferObj != bufferObj) p = p->m_next; + if (p == NULL) { + glBindBuffer(GL_ARRAY_BUFFER, bufferObj); + glGetBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &buffer_size); + assert(buffer_size != 0); + *devPtr = context->get_device()->get_gpgpu()->gpu_malloc(buffer_size); + + // create entry and insert to front of list + glbmap_entry_t *n = (glbmap_entry_t *)calloc(1, sizeof(glbmap_entry_t)); + n->m_next = ctx->api->g_glbmap; + ctx->api->g_glbmap = n; + + // initialize entry + n->m_bufferObj = bufferObj; + n->m_devPtr = *devPtr; + n->m_size = buffer_size; + + p = n; + } else { + buffer_size = p->m_size; + *devPtr = p->m_devPtr; + } + + if (*devPtr) { + char *data = (char *)calloc(p->m_size, 1); + glGetBufferSubData(GL_ARRAY_BUFFER, 0, buffer_size, data); + memcpy_to_gpu((size_t)*devPtr, data, buffer_size); + free(data); + printf( + "GPGPU-Sim PTX: cudaGLMapBufferObject %zu bytes starting at 0x%llx..\n", + (size_t)buffer_size, (unsigned long long)*devPtr); + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorMemoryAllocation; + } + + return g_last_cudaError = cudaSuccess; +#else + fflush(stdout); + fflush(stderr); + printf( + "GPGPU-Sim PTX: GPGPU-Sim support for OpenGL integration disabled -- " + "exiting\n"); + fflush(stdout); + exit(50); +#endif } +#if CUDART_VERSION >= 6050 +CUresult cuLinkAddFileInternal(CUlinkState state, CUjitInputType type, + const char *path, unsigned int numOptions, + CUjit_option *options, void **optionValues, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + static bool addedFile = false; + if (addedFile) { + printf( + "GPGPU-Sim PTX: ERROR: cuLinkAddFile does not support multiple " + "files\n"); + abort(); + } -__host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbol(void *dst, const char *symbol, size_t count, size_t offset __dv(0), enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToHost)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //CUctx_st *context = GPGPUSim_Context(); - assert(kind == cudaMemcpyDeviceToHost); - printf("GPGPU-Sim PTX: cudaMemcpyFromSymbol: symbol = %p\n", symbol); - g_stream_manager->push( stream_operation(symbol,dst,count,offset,0) ); - //gpgpu_ptx_sim_memcpy_symbol(symbol,dst,count,offset,0,context->get_device()->get_gpgpu()); - return g_last_cudaError = cudaSuccess; + // blocking + assert(type == CU_JIT_INPUT_PTX); + CUctx_st *context = GPGPUSim_Context(ctx); + char *file = getenv("PTX_JIT_PATH"); + if (file == NULL) { + printf("GPGPU-Sim PTX: ERROR: PTX_JIT_PATH has not been set\n"); + abort(); + } + strcat(file, "/"); + strcat(file, path); + symbol_table *symtab = ctx->gpgpu_ptx_sim_load_ptx_from_filename(file); + std::string fname(path); + ctx->api->name_symtab[fname] = symtab; + context->add_binary(symtab, 1); + ctx->api->load_static_globals(symtab, STATIC_ALLOC_LIMIT, 0xFFFFFFFF, + context->get_device()->get_gpgpu()); + ctx->api->load_constants(symtab, STATIC_ALLOC_LIMIT, + context->get_device()->get_gpgpu()); + addedFile = true; + return CUDA_SUCCESS; } +#endif -__host__ cudaError_t CUDARTAPI cudaMemGetInfo (size_t *free, size_t *total){ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //placeholder; should interact with cudaMalloc and cudaFree? - *free = 10000000000; - *total = 10000000000; +#if (CUDART_VERSION >= 2010) - return g_last_cudaError = cudaSuccess; +cudaError_t cudaHostAllocInternal(void **pHost, size_t bytes, + unsigned int flags, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *pHost = malloc(bytes); + // need to track the size allocated so that cudaHostGetDevicePointer() can + // function properly. + // TODO: vary this function behavior based on flags value (following nvidia + // documentation) + ctx->api->pinned_memory_size[*pHost] = bytes; + if (*pHost) + return g_last_cudaError = cudaSuccess; + else + return g_last_cudaError = cudaErrorMemoryAllocation; } -/******************************************************************************* - * * - * * - * * - *******************************************************************************/ +#endif -__host__ cudaError_t CUDARTAPI cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - struct CUstream_st *s = (struct CUstream_st *)stream; - switch( kind ) { - case cudaMemcpyHostToDevice: g_stream_manager->push( stream_operation(src,(size_t)dst,count,s) ); break; - case cudaMemcpyDeviceToHost: g_stream_manager->push( stream_operation((size_t)src,dst,count,s) ); break; - case cudaMemcpyDeviceToDevice: g_stream_manager->push( stream_operation((size_t)src,(size_t)dst,count,s) ); break; - default: - abort(); - } - return g_last_cudaError = cudaSuccess; +size_t getMaxThreadsPerBlock(struct cudaFuncAttributes *attr, + gpgpu_context *ctx) { + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + struct cudaDeviceProp prop; + + prop = *dev->get_prop(); + + size_t max = prop.maxThreadsPerBlock; + + if (attr->numRegs && (prop.regsPerBlock / attr->numRegs) < max) + max = prop.regsPerBlock / attr->numRegs; + + if (attr->sharedSizeBytes && + (prop.sharedMemPerBlock / attr->sharedSizeBytes) < max) + max = prop.sharedMemPerBlock / attr->sharedSizeBytes; + + return max; } +cudaError_t CUDARTAPI cudaFuncGetAttributesInternal( + struct cudaFuncAttributes *attr, const char *hostFun, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + function_info *entry = context->get_kernel(hostFun); + if (entry) { + const struct gpgpu_ptx_sim_info *kinfo = entry->get_kernel_info(); + attr->sharedSizeBytes = kinfo->smem; + attr->constSizeBytes = kinfo->cmem; + attr->localSizeBytes = kinfo->lmem; + attr->numRegs = kinfo->regs; + if (kinfo->maxthreads > 0) + attr->maxThreadsPerBlock = kinfo->maxthreads; + else + attr->maxThreadsPerBlock = getMaxThreadsPerBlock(attr, ctx); +#if CUDART_VERSION >= 3000 + attr->ptxVersion = kinfo->ptx_version; + attr->binaryVersion = kinfo->sm_target; +#endif + } + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpyToArrayAsync(struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); +#if (CUDART_VERSION > 5000) +__host__ cudaError_t CUDARTAPI +cudaDeviceGetAttributeInternal(int *value, enum cudaDeviceAttr attr, int device, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + + const struct cudaDeviceProp *prop; + _cuda_device_id *dev = ctx->GPGPUSim_Init(); + + if (device <= dev->num_devices()) { + prop = dev->get_prop(); + switch (attr) { + case 1: + *value = prop->maxThreadsPerBlock; + break; + case 2: + *value = prop->maxThreadsDim[0]; + break; + case 3: + *value = prop->maxThreadsDim[1]; + break; + case 4: + *value = prop->maxThreadsDim[2]; + break; + case 5: + *value = prop->maxGridSize[0]; + break; + case 6: + *value = prop->maxGridSize[1]; + break; + case 7: + *value = prop->maxGridSize[2]; + break; + case 8: + *value = prop->sharedMemPerBlock; + break; + case 9: + *value = prop->totalConstMem; + break; + case 10: + *value = prop->warpSize; + break; + case 11: + *value = 16; // dummy value + break; + case 12: + *value = prop->regsPerBlock; + break; + case 13: + *value = 1480000; // for 1080ti + break; + case 14: + *value = prop->textureAlignment; + break; + case 15: + *value = 0; + break; + case 16: + *value = prop->multiProcessorCount; + break; + case 17: + case 18: + case 19: + *value = 0; + break; + case 21: + case 22: + case 23: + case 24: + case 25: + case 26: + case 27: + case 28: + case 42: + case 45: + case 46: + case 47: + case 48: + case 49: + case 52: + case 53: + case 55: + case 56: + case 57: + case 58: + case 59: + case 60: + case 61: + case 62: + case 63: + case 64: + case 66: + case 67: + case 69: + case 70: + case 71: + case 73: + case 74: + case 77: + *value = 1000; // dummy value + break; + case 29: + case 43: + case 54: + case 65: + case 68: + case 72: + *value = 10; // dummy value + break; + case 30: + case 51: + *value = 128; // dummy value + break; + case 31: + *value = 1; + break; + case 32: + *value = 0; + break; + case 33: + case 50: + *value = 0; // dummy value + break; + case 34: + *value = 0; + break; + case 35: + *value = 0; + break; + case 36: + *value = 1250000; // CK value for 1080ti + break; + case 37: + *value = 352; // value for 1080ti + break; + case 38: + *value = 3000000; // value for 1080ti + break; + case 39: + *value = dev->get_gpgpu()->threads_per_core(); + break; + case 40: + *value = 0; + break; + case 41: + *value = 0; + break; + case 75: // cudaDevAttrComputeCapabilityMajor + *value = prop->major; + break; + case 76: // cudaDevAttrComputeCapabilityMinor + *value = prop->minor; + break; + case 78: + *value = 0; // TODO: as of now, we dont support stream priorities. + break; + case 79: + *value = 0; + break; + case 80: + *value = 0; + break; +#if (CUDART_VERSION > 5050) + case 81: + *value = prop->sharedMemPerMultiprocessor; + break; + case 82: + *value = prop->regsPerMultiprocessor; + break; +#endif + case 83: + case 84: + case 85: + case 86: + *value = 0; + break; + case 87: + *value = 4; // dummy value + break; + case 88: + case 89: + *value = 0; + break; + default: + printf("ERROR: Attribute number %d unimplemented \n", attr); + abort(); } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorInvalidDevice; + } } +#endif +__host__ cudaError_t CUDARTAPI cudaBindTextureInternal( + size_t *offset, const struct textureReference *texref, const void *devPtr, + const struct cudaChannelFormatDesc *desc, size_t size __dv(UINT_MAX), + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + printf( + "GPGPU-Sim PTX: in cudaBindTexture: sizeof(struct textureReference) = " + "%zu\n", + sizeof(struct textureReference)); + struct cudaArray *array; + array = (struct cudaArray *)malloc(sizeof(struct cudaArray)); + array->desc = *desc; + array->size = size; + array->width = size; + array->height = 1; + array->dimensions = 1; + array->devPtr = (void *)devPtr; + array->devPtr32 = (int)(long long)devPtr; + offset = 0; + printf("GPGPU-Sim PTX: size = %zu\n", size); + printf("GPGPU-Sim PTX: texref = %p, array = %p\n", texref, array); + printf("GPGPU-Sim PTX: devPtr32 = %x\n", array->devPtr32); + printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", + gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); + printf("GPGPU-Sim PTX: ChannelFormatDesc: x=%d, y=%d, z=%d, w=%d\n", + desc->x, desc->y, desc->z, desc->w); + printf("GPGPU-Sim PTX: Texture Normalized? = %d\n", texref->normalized); + gpu->gpgpu_ptx_sim_bindTextureToArray(texref, array); + devPtr = (void *)(long long)array->devPtr32; + printf("GPGPU-Sim PTX: devPtr = %p\n", devPtr); + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpyFromArrayAsync(void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaBindTextureToArrayInternal( + const struct textureReference *texref, const struct cudaArray *array, + const struct cudaChannelFormatDesc *desc, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + printf("GPGPU-Sim PTX: in cudaBindTextureToArray: %p %p\n", texref, array); + printf("GPGPU-Sim PTX: devPtr32 = %x\n", array->devPtr32); + printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", + gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); + printf("GPGPU-Sim PTX: Texture Normalized? = %d\n", texref->normalized); + gpu->gpgpu_ptx_sim_bindTextureToArray(texref, array); + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaUnbindTextureInternal( + const struct textureReference *texref, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + printf( + "GPGPU-Sim PTX: in cudaUnbindTexture: sizeof(struct textureReference) = " + "%zu\n", + sizeof(struct textureReference)); + printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", + gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); -__host__ cudaError_t CUDARTAPI cudaMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; + gpu->gpgpu_ptx_sim_unbindTexture(texref); + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaLaunchKernelInternal( + const char *hostFun, dim3 gridDim, dim3 blockDim, const void **args, + size_t sharedMem, cudaStream_t stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } -__host__ cudaError_t CUDARTAPI cudaMemcpy2DToArrayAsync(struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + function_info *entry = context->get_kernel(hostFun); +#if CUDART_VERSION < 10000 + cudaConfigureCallInternal(gridDim, blockDim, sharedMem, stream, ctx); +#endif + for (unsigned i = 0; i < entry->num_args(); i++) { + std::pair<size_t, unsigned> p = entry->get_param_config(i); + cudaSetupArgumentInternal(args[i], p.first, p.second); + } + + cudaLaunchInternal(hostFun); + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI cudaStreamCreateInternal( + cudaStream_t *stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: cudaStreamCreate\n"); +#if (CUDART_VERSION >= 3000) + *stream = new struct CUstream_st(); + ctx->the_gpgpusim->g_stream_manager->add_stream(*stream); +#else + *stream = 0; + printf( + "GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported " + "(%s)\n", + __my_func__); +#endif + return g_last_cudaError = cudaSuccess; +} -__host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArrayAsync(void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream) +__host__ cudaError_t CUDARTAPI cudaStreamDestroyInternal( + cudaStream_t stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } +#if (CUDART_VERSION >= 3000) + // per-stream synchronization required for application using external + // libraries without explicit synchronization in the code to avoid the + // stream_manager from spinning forever to destroy non-empty streams without + // making any forward progress. + stream->synchronize(); + ctx->the_gpgpusim->g_stream_manager->destroy_stream(stream); +#endif + return g_last_cudaError = cudaSuccess; +} + +__host__ cudaError_t CUDARTAPI cudaStreamSynchronizeInternal( + cudaStream_t stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } +#if (CUDART_VERSION >= 3000) + if (stream == NULL) ctx->synchronize(); + return g_last_cudaError = cudaSuccess; + stream->synchronize(); +#else + printf( + "GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported " + "(%s)\n", + __my_func__); +#endif + return g_last_cudaError = cudaSuccess; +} + +void __cudaRegisterTextureInternal( + void **fatCubinHandle, const struct textureReference *hostVar, + const void **deviceAddress, const char *deviceName, int dim, int norm, + int ext, + gpgpu_context *gpgpu_ctx = + NULL) // passes in a newly created textureReference { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + std::string devStr(deviceName); +#if (CUDART_VERSION > 4020) + if (devStr.size() > 2 && devStr.data()[0] == ':' && devStr.data()[1] == ':') + devStr = devStr.replace(0, 2, ""); +#endif + CUctx_st *context = GPGPUSim_Context(ctx); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + printf("GPGPU-Sim PTX: in __cudaRegisterTexture:\n"); + gpu->gpgpu_ptx_sim_bindNameToTexture(devStr.data(), hostVar, dim, norm, ext); + printf("GPGPU-Sim PTX: int dim = %d\n", dim); + printf("GPGPU-Sim PTX: int norm = %d\n", norm); + printf("GPGPU-Sim PTX: int ext = %d\n", ext); + printf( + "GPGPU-Sim PTX: Execution warning: Not finished implementing \"%s\"\n", + __my_func__); } +cudaError_t cudaGLUnmapBufferObjectInternal(GLuint bufferObj, + gpgpu_context *gpgpu_ctx = NULL) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } +#ifdef OPENGL_SUPPORT + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + CUctx_st *ctx = GPGPUSim_Context(ctx); + glbmap_entry_t *p = ctx->api->g_glbmap; + while (p && p->m_bufferObj != bufferObj) p = p->m_next; + if (p == NULL) return g_last_cudaError = cudaErrorUnknown; + char *data = (char *)calloc(p->m_size, 1); + memcpy_from_gpu(data, (size_t)p->m_devPtr, p->m_size); + glBufferSubData(GL_ARRAY_BUFFER, 0, p->m_size, data); + free(data); -/******************************************************************************* - * * - * * - * * - *******************************************************************************/ + return g_last_cudaError = cudaSuccess; +#else + fflush(stdout); + fflush(stderr); + printf("GPGPU-Sim PTX: support for OpenGL integration disabled -- exiting\n"); + fflush(stdout); + exit(50); +#endif +} -__host__ cudaError_t CUDARTAPI cudaMemset(void *mem, int c, size_t count) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - gpu->gpu_memset((size_t)mem, c, count); - return g_last_cudaError = cudaSuccess; +#if CUDART_VERSION >= 3000 + +__host__ cudaError_t CUDARTAPI +cudaFuncSetCacheConfigInternal(const char *func, enum cudaFuncCache cacheConfig, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUctx_st *context = GPGPUSim_Context(ctx); + context->get_device()->get_gpgpu()->set_cache_config( + context->get_kernel(func)->get_name(), (FuncCache)cacheConfig); + return g_last_cudaError = cudaSuccess; } -//memset operation is done but i think its not async? -__host__ cudaError_t CUDARTAPI cudaMemsetAsync(void *mem, int c, size_t count, cudaStream_t stream=0) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: WARNING: Asynchronous memset not supported (%s)\n", __my_func__); - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - gpu->gpu_memset((size_t)mem, c, count); - return g_last_cudaError = cudaSuccess; +#endif + +#if CUDART_VERSION >= 4000 +CUresult CUDAAPI cuLaunchKernelInternal( + 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, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + if (extra != NULL) { + printf( + "GPGPU-Sim CUDA DRIVER API: ERROR: Currently do not support void** " + "extra.\n"); + abort(); + } + const char *hostFun = (const char *)f; + CUctx_st *context = GPGPUSim_Context(ctx); + function_info *entry = context->get_kernel(hostFun); + cudaConfigureCallInternal(dim3(gridDimX, gridDimY, gridDimZ), + dim3(blockDimX, blockDimY, blockDimZ), + sharedMemBytes, (cudaStream_t)hStream, ctx); + for (unsigned i = 0; i < entry->num_args(); i++) { + std::pair<size_t, unsigned> p = entry->get_param_config(i); + cudaSetupArgumentInternal(kernelParams[i], p.first, p.second, ctx); + } + cudaLaunchInternal(hostFun, ctx); + return CUDA_SUCCESS; } +#endif /* CUDART_VERSION >= 4000 */ -__host__ cudaError_t CUDARTAPI cudaMemset2D(void *mem, size_t pitch, int c, size_t width, size_t height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +CUevent_st *get_event(cudaEvent_t event) { + unsigned event_uid; +#if CUDART_VERSION >= 3000 + event_uid = event->get_uid(); +#else + event_uid = event; +#endif + event_tracker_t::iterator e = g_timer_events.find(event_uid); + if (e == g_timer_events.end()) return NULL; + return e->second; +} + +__host__ cudaError_t CUDARTAPI cudaEventRecordInternal( + cudaEvent_t event, cudaStream_t stream, gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUevent_st *e = get_event(event); + if (!e) return g_last_cudaError = cudaErrorUnknown; + struct CUstream_st *s = (struct CUstream_st *)stream; + stream_operation op(e, s); + ctx->the_gpgpusim->g_stream_manager->push(op); + return g_last_cudaError = cudaSuccess; +} + +__host__ cudaError_t CUDARTAPI cudaStreamWaitEventInternal( + cudaStream_t stream, cudaEvent_t event, unsigned int flags, + gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // reference: + // https://www.cs.cmu.edu/afs/cs/academic/class/15668-s11/www/cuda-doc/html/group__CUDART__STREAM_gfe68d207dc965685d92d3f03d77b0876.html + CUevent_st *e = get_event(event); + if (!e) { + printf( + "GPGPU-Sim API: Warning: cudaEventRecord has not been called on event " + "before calling cudaStreamWaitEvent.\nNothing to be done.\n"); + return g_last_cudaError = cudaSuccess; + } + if (!stream) { + ctx->the_gpgpusim->g_stream_manager->pushCudaStreamWaitEventToAllStreams( + e, flags); + } else { + struct CUstream_st *s = (struct CUstream_st *)stream; + stream_operation op(s, e, flags); + ctx->the_gpgpusim->g_stream_manager->push(op); + } + return g_last_cudaError = cudaSuccess; +} + +__host__ cudaError_t CUDARTAPI +cudaThreadExitInternal(gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + ctx->exit_simulation(); + return g_last_cudaError = cudaSuccess; } +__host__ cudaError_t CUDARTAPI +cudaThreadSynchronizeInternal(gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // Called on host side + ctx->synchronize(); + return g_last_cudaError = cudaSuccess; +} +cudaError_t CUDARTAPI +cudaDeviceSynchronizeInternal(gpgpu_context *gpgpu_ctx = NULL) { + gpgpu_context *ctx; + if (gpgpu_ctx) { + ctx = gpgpu_ctx; + } else { + ctx = GPGPU_Context(); + } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // Blocks until the device has completed all preceding requested tasks + ctx->synchronize(); + return g_last_cudaError = cudaSuccess; +} /******************************************************************************* * * @@ -924,694 +2289,476 @@ __host__ cudaError_t CUDARTAPI cudaMemset2D(void *mem, size_t pitch, int c, size * * *******************************************************************************/ -__host__ cudaError_t CUDARTAPI cudaGetSymbolAddress(void **devPtr, const char *symbol) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +extern "C" { + +/******************************************************************************* + * * + * * + * * + *******************************************************************************/ +cudaError_t cudaPeekAtLastError(void) { return g_last_cudaError; } + +__host__ cudaError_t CUDARTAPI cudaMalloc(void **devPtr, size_t size) { + return cudaMallocInternal(devPtr, size); } +__host__ cudaError_t CUDARTAPI cudaMallocHost(void **ptr, size_t size) { + return cudaMallocHostInternal(ptr, size); +} +__host__ cudaError_t CUDARTAPI cudaMallocPitch(void **devPtr, size_t *pitch, + size_t width, size_t height) { + return cudaMallocPitchInternal(devPtr, pitch, width, height); +} -__host__ cudaError_t CUDARTAPI cudaGetSymbolSize(size_t *size, const char *symbol) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaMallocArray( + struct cudaArray **array, const struct cudaChannelFormatDesc *desc, + size_t width, size_t height __dv(1)) { + return cudaMallocArrayInternal(array, desc, width, height); } +__host__ cudaError_t CUDARTAPI cudaFree(void *devPtr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // TODO... manage g_global_mem space? + return g_last_cudaError = cudaSuccess; +} +__host__ cudaError_t CUDARTAPI cudaFreeHost(void *ptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + free(ptr); // this will crash the system if called twice + return g_last_cudaError = cudaSuccess; +} +__host__ cudaError_t CUDARTAPI cudaFreeArray(struct cudaArray *array) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // TODO... manage g_global_mem space? + return g_last_cudaError = cudaSuccess; +}; /******************************************************************************* * * * * * * *******************************************************************************/ -__host__ cudaError_t CUDARTAPI cudaGetDeviceCount(int *count) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - _cuda_device_id *dev = GPGPUSim_Init(); - *count = dev->num_devices(); - return g_last_cudaError = cudaSuccess; + +__host__ cudaError_t CUDARTAPI cudaMemcpy(void *dst, const void *src, + size_t count, + enum cudaMemcpyKind kind) { + return cudaMemcpyInternal(dst, src, count, kind); } -__host__ cudaError_t CUDARTAPI cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - _cuda_device_id *dev = GPGPUSim_Init(); - if (device <= dev->num_devices() ) { - *prop= *dev->get_prop(); - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorInvalidDevice; - } +__host__ cudaError_t CUDARTAPI cudaMemcpyToArray(struct cudaArray *dst, + size_t wOffset, size_t hOffset, + const void *src, size_t count, + enum cudaMemcpyKind kind) { + return cudaMemcpyToArrayInternal(dst, wOffset, hOffset, src, count, kind); } -#if (CUDART_VERSION > 5000) -__host__ cudaError_t CUDARTAPI cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - const struct cudaDeviceProp *prop; - _cuda_device_id *dev = GPGPUSim_Init(); - if (device <= dev->num_devices() ) { - prop = dev->get_prop(); - switch (attr) { - case 1: - *value= prop->maxThreadsDim[0] * prop->maxThreadsDim[1] * prop->maxThreadsDim[2] * prop->maxGridSize[0] * prop->maxGridSize[1] * prop->maxGridSize[2]; - break; - case 2: - *value= prop->maxThreadsDim[0]; - break; - case 3: - *value= prop->maxThreadsDim[1]; - break; - case 4: - *value= prop->maxThreadsDim[2]; - break; - case 5: - *value= prop->maxGridSize[0]; - break; - case 6: - *value= prop->maxGridSize[1]; - break; - case 7: - *value= prop->maxGridSize[2]; - break; - case 8: - *value= prop->sharedMemPerBlock; - break; - case 9: - *value= prop->totalConstMem; - break; - case 10: - *value= prop->warpSize; - break; - case 11: - *value= 16;//dummy value - break; - case 12: - *value= prop->regsPerBlock; - break; - case 13: - *value= 1480000;//for 1080ti - break; - case 14: - *value= prop->textureAlignment ; - break; - case 15: - *value = 0; - break; - case 16: - *value= prop->multiProcessorCount ; - break; - case 17: - case 18: - case 19: - *value = 0; - break; - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 42: - case 45: - case 46: - case 47: - case 48: - case 49: - case 52: - case 53: - case 55: - case 56: - case 57: - case 58: - case 59: - case 60: - case 61: - case 62: - case 63: - case 64: - case 66: - case 67: - case 69: - case 70: - case 71: - case 73: - case 74: - case 77: - *value = 1000;//dummy value - break; - case 29: - case 43: - case 54: - case 65: - case 68: - case 72: - *value = 10;//dummy value - break; - case 30: - case 51: - *value = 128;//dummy value - break; - case 31: - *value = 1; - break; - case 32: - *value = 0; - break; - case 33: - case 50: - *value = 0;//dummy value - break; - case 34: - *value= 0; - break; - case 35: - *value = 0; - break; - case 36: - *value = 1250000;//CK value for 1080ti - break; - case 37: - *value = 352;//value for 1080ti - break; - case 38: - *value = 3000000;//value for 1080ti - break; - case 39: - *value= dev->get_gpgpu()->threads_per_core(); - break; - case 40: - *value= 0; - break; - case 41: - *value= 0; - break; - case 75://cudaDevAttrComputeCapabilityMajor - *value= prop->major ; - break; - case 76://cudaDevAttrComputeCapabilityMinor - *value= prop->minor ; - break; - case 78: - *value= 0 ; //TODO: as of now, we dont support stream priorities. - break; - case 79: - *value= 0; - break; - case 80: - *value= 0; - break; - #if (CUDART_VERSION > 5050) - case 81: - *value= prop->sharedMemPerMultiprocessor; - break; - case 82: - *value= prop->regsPerMultiprocessor; - break; - #endif - case 83: - case 84: - case 85: - case 86: - *value= 0; - break; - case 87: - *value= 4;//dummy value - break; - case 88: - case 89: - *value= 0; - break; - default: - printf("ERROR: Attribute number %d unimplemented \n",attr); - abort(); - } - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorInvalidDevice; - } +__host__ cudaError_t CUDARTAPI cudaMemcpyFromArray(void *dst, + const struct cudaArray *src, + size_t wOffset, + size_t hOffset, size_t count, + enum cudaMemcpyKind kind) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -#endif -__host__ cudaError_t CUDARTAPI cudaChooseDevice(int *device, const struct cudaDeviceProp *prop) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - _cuda_device_id *dev = GPGPUSim_Init(); - *device = dev->get_id(); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpyArrayToArray( + struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, + const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, + size_t count, enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaSetDevice(int device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //set the active device to run cuda - if ( device <= GPGPUSim_Init()->num_devices() ) { - g_active_device = device; - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorInvalidDevice; - } +__host__ cudaError_t CUDARTAPI cudaMemcpy2D(void *dst, size_t dpitch, + const void *src, size_t spitch, + size_t width, size_t height, + enum cudaMemcpyKind kind) { + return cudaMemcpy2DInternal(dst, dpitch, src, spitch, width, height, kind); } -__host__ cudaError_t CUDARTAPI cudaGetDevice(int *device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *device = g_active_device; - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpy2DToArray( + struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, + size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind) { + return cudaMemcpy2DToArrayInternal(dst, wOffset, hOffset, src, spitch, width, + height, kind); } -__host__ cudaError_t CUDARTAPI cudaDeviceGetLimit ( size_t* pValue, cudaLimit limit ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - _cuda_device_id *dev = GPGPUSim_Init(); - const struct cudaDeviceProp *prop = dev->get_prop(); - const gpgpu_sim_config& config=dev->get_gpgpu()->get_config(); - switch(limit) { - case 0: // cudaLimitStackSize - *pValue=config.stack_limit(); - break; - case 2: // cudaLimitMallocHeapSize - *pValue=config.heap_limit(); - break; -#if (CUDART_VERSION > 5050) - case 3: // cudaLimitDevRuntimeSyncDepth - if(prop->major > 2){ - *pValue=config.sync_depth_limit(); - break; - } - else{ - printf("ERROR:Limit %s is not supported on this architecture \n",limit); - abort(); - } - case 4: // cudaLimitDevRuntimePendingLaunchCount - if(prop->major > 2){ - *pValue=config.pending_launch_count_limit(); - break; - } - else{ - printf("ERROR:Limit %s is not supported on this architecture \n",limit); - abort(); - } -#endif - default: - printf("ERROR:Limit %s unimplemented \n",limit); - abort(); - } - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArray( + void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, + size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} +__host__ cudaError_t CUDARTAPI cudaMemcpy2DArrayToArray( + struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, + const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, + size_t width, size_t height, + enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToDevice)) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaStreamGetPriority ( cudaStream_t hStream, int* priority ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemcpyToSymbol( + const char *symbol, const void *src, size_t count, size_t offset __dv(0), + enum cudaMemcpyKind kind __dv(cudaMemcpyHostToDevice)) { + return cudaMemcpyToSymbolInternal(symbol, src, count, offset, kind); +} +__host__ cudaError_t CUDARTAPI cudaMemcpyFromSymbol( + void *dst, const char *symbol, size_t count, size_t offset __dv(0), + enum cudaMemcpyKind kind __dv(cudaMemcpyDeviceToHost)) { + return cudaMemcpyFromSymbolInternal(dst, symbol, count, offset, kind); } -__host__ cudaError_t CUDARTAPI cudaDeviceGetPCIBusId ( - char *pciBusId, - int len, - int device -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaMemGetInfo(size_t *free, size_t *total) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // placeholder; should interact with cudaMalloc and cudaFree? + *free = 10000000000; + *total = 10000000000; + + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaIpcGetMemHandle( cudaIpcMemHandle_t* handle, void* devPtr ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +/******************************************************************************* + * * + * * + * * + *******************************************************************************/ + +__host__ cudaError_t CUDARTAPI cudaMemcpyAsync(void *dst, const void *src, + size_t count, + enum cudaMemcpyKind kind, + cudaStream_t stream) { + return cudaMemcpyAsyncInternal(dst, src, count, kind, stream); } -__host__ cudaError_t cudaIpcOpenMemHandle( - void **devPtr, - cudaIpcMemHandle_t handle, - unsigned int flags -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaMemcpyToArrayAsync( + struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, + size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaDestroyTextureObject(cudaTextureObject_t texObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaMemcpyFromArrayAsync( + void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, + size_t count, enum cudaMemcpyKind kind, cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} + +__host__ cudaError_t CUDARTAPI cudaMemcpy2DAsync(void *dst, size_t dpitch, + const void *src, size_t spitch, + size_t width, size_t height, + enum cudaMemcpyKind kind, + cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } +__host__ cudaError_t CUDARTAPI cudaMemcpy2DToArrayAsync( + struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, + size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, + cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} + +__host__ cudaError_t CUDARTAPI cudaMemcpy2DFromArrayAsync( + void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, + size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, + cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} + +#if (CUDART_VERSION >= 8000) +cudaError_t CUDARTAPI cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, const char *hostFunc, int blockSize, size_t dynamicSMemSize, + unsigned int flags) { + return cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlagsInternal( + numBlocks, hostFunc, blockSize, dynamicSMemSize, flags); +} + +#endif /******************************************************************************* * * * * * * *******************************************************************************/ - -__host__ cudaError_t CUDARTAPI cudaBindTexture(size_t *offset, - const struct textureReference *texref, - const void *devPtr, - const struct cudaChannelFormatDesc *desc, - size_t size __dv(UINT_MAX)) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - printf("GPGPU-Sim PTX: in cudaBindTexture: sizeof(struct textureReference) = %zu\n", sizeof(struct textureReference)); - struct cudaArray *array; - array = (struct cudaArray*) malloc(sizeof(struct cudaArray)); - array->desc = *desc; - array->size = size; - array->width = size; - array->height = 1; - array->dimensions = 1; - array->devPtr = (void*)devPtr; - array->devPtr32 = (int)(long long)devPtr; - offset = 0; - printf("GPGPU-Sim PTX: size = %zu\n", size); - printf("GPGPU-Sim PTX: texref = %p, array = %p\n", texref, array); - printf("GPGPU-Sim PTX: devPtr32 = %x\n", array->devPtr32); - printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); - printf("GPGPU-Sim PTX: ChannelFormatDesc: x=%d, y=%d, z=%d, w=%d\n", desc->x, desc->y, desc->z, desc->w); - printf("GPGPU-Sim PTX: Texture Normalized? = %d\n", texref->normalized); - gpu->gpgpu_ptx_sim_bindTextureToArray(texref, array); - devPtr = (void*)(long long)array->devPtr32; - printf("GPGPU-Sim PTX: devPtr = %p\n", devPtr); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemset(void *mem, int c, size_t count) { + return cudaMemsetInternal(mem, c, count); } +// memset operation is done but i think its not async? +__host__ cudaError_t CUDARTAPI cudaMemsetAsync(void *mem, int c, size_t count, + cudaStream_t stream = 0) { + return cudaMemsetAsyncInternal(mem, c, count, stream = 0); +} -__host__ cudaError_t CUDARTAPI cudaBindTextureToArray(const struct textureReference *texref, const struct cudaArray *array, const struct cudaChannelFormatDesc *desc) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - printf("GPGPU-Sim PTX: in cudaBindTextureToArray: %p %p\n", texref, array); - printf("GPGPU-Sim PTX: devPtr32 = %x\n", array->devPtr32); - printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); - printf("GPGPU-Sim PTX: Texture Normalized? = %d\n", texref->normalized); - gpu->gpgpu_ptx_sim_bindTextureToArray(texref, array); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaMemset2D(void *mem, size_t pitch, int c, + size_t width, size_t height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaUnbindTexture(const struct textureReference *texref){ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - printf("GPGPU-Sim PTX: in cudaUnbindTexture: sizeof(struct textureReference) = %zu\n", sizeof(struct textureReference)); - printf("GPGPU-Sim PTX: Name corresponding to textureReference: %s\n", gpu->gpgpu_ptx_sim_findNamefromTexture(texref)); +/******************************************************************************* + * * + * * + * * + *******************************************************************************/ - gpu->gpgpu_ptx_sim_unbindTexture(texref); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaGetSymbolAddress(void **devPtr, + const char *symbol) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaGetTextureAlignmentOffset(size_t *offset, const struct textureReference *texref) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaGetSymbolSize(size_t *size, + const char *symbol) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaGetTextureReference(const struct textureReference **texref, const char *symbol) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +/******************************************************************************* + * * + * * + * * + *******************************************************************************/ +__host__ cudaError_t CUDARTAPI cudaGetDeviceCount(int *count) { + return cudaGetDeviceCountInternal(count); } -__host__ cudaError_t CUDARTAPI cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, const struct cudaArray *array) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *desc = array->desc; - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) { + return cudaGetDevicePropertiesInternal(prop, device); } - -__host__ struct cudaChannelFormatDesc CUDARTAPI cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - struct cudaChannelFormatDesc dummy; - dummy.x = x; - dummy.y = y; - dummy.z = z; - dummy.w = w; - dummy.f = f; - return dummy; +#if (CUDART_VERSION > 5000) +__host__ cudaError_t CUDARTAPI cudaDeviceGetAttribute(int *value, + enum cudaDeviceAttr attr, + int device) { + return cudaDeviceGetAttributeInternal(value, attr, device); } +#endif -__host__ cudaError_t CUDARTAPI cudaGetLastError(void) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return g_last_cudaError; +__host__ cudaError_t CUDARTAPI +cudaChooseDevice(int *device, const struct cudaDeviceProp *prop) { + return cudaChooseDeviceInternal(device, prop); } -__host__ const char *cudaGetErrorName(cudaError_t error) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return NULL; +__host__ cudaError_t CUDARTAPI cudaSetDevice(int device) { + return cudaSetDeviceInternal(device); } -__host__ const char* CUDARTAPI cudaGetErrorString(cudaError_t error) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - if( g_last_cudaError == cudaSuccess ) - return "no error"; - char buf[1024]; - snprintf(buf,1024,"<<GPGPU-Sim PTX: there was an error (code = %d)>>", g_last_cudaError); - return strdup(buf); +__host__ cudaError_t CUDARTAPI cudaGetDevice(int *device) { + return cudaGetDeviceInternal(device); } -__host__ cudaError_t CUDARTAPI cudaConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - struct CUstream_st *s = (struct CUstream_st *)stream; - g_cuda_launch_stack.push_back( kernel_config(gridDim,blockDim,sharedMem,s) ); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaDeviceGetLimit(size_t *pValue, + cudaLimit limit) { + return cudaDeviceGetLimitInternal(pValue, limit); } +__host__ cudaError_t CUDARTAPI cudaStreamGetPriority(cudaStream_t hStream, + int *priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaSuccess; +} -#if CUDART_VERSION >= 10000 -/* -* CUDA 10 requires a new CUDA kernel launch sequence -* A call to __cudaPushCallConfiguration() preceeds any call to cudaLaunchKernel() -* __cudaPushCallConfiguration is undocumented in the API but it simply sets up a buffer with the arguments which is accessed in cudaLaunchKernel() -* __cudaPopCallConfiguration is undocumented in the API but it simply pops the configuration set in cudaLaunchKernel() -* -* pushing more than 1 configuration without popping is currently not implemented in GPGPU-Sim and will result in an assert error -*/ -namespace g_cudaPushArgsBuffer -{ - bool g_is_initialized = false; - dim3 g_gridDim; - dim3 g_blockDim; - size_t g_sharedMem; - cudaStream_t g_stream; +__host__ cudaError_t CUDARTAPI cudaDeviceGetPCIBusId(char *pciBusId, int len, + int device) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI __cudaPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem, cudaStream_t stream) -{ - assert(g_cudaPushArgsBuffer::g_is_initialized == false); - printf("Pushing cuda call configuration \n"); - g_cudaPushArgsBuffer::g_is_initialized = true; - g_cudaPushArgsBuffer::g_gridDim = gridDim; - g_cudaPushArgsBuffer::g_blockDim = blockDim; - g_cudaPushArgsBuffer::g_sharedMem = sharedMem; - g_cudaPushArgsBuffer::g_stream = stream; +__host__ cudaError_t CUDARTAPI cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, + void *devPtr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} - return cudaSuccess; +__host__ cudaError_t cudaIpcOpenMemHandle(void **devPtr, + cudaIpcMemHandle_t handle, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI __cudaPopCallConfiguration() -{ - printf("Inside __cudaPopCallConfiguration\n"); - assert(g_cudaPushArgsBuffer::g_is_initialized == true); - printf("Poping cuda call configuration \n"); - g_cudaPushArgsBuffer::g_is_initialized = false; - return cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaDestroyTextureObject(cudaTextureObject_t texObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -#endif // #if CUDART_VERSION >= 10000 +/******************************************************************************* + * * + * * + * * + *******************************************************************************/ +__host__ cudaError_t CUDARTAPI cudaBindTexture( + size_t *offset, const struct textureReference *texref, const void *devPtr, + const struct cudaChannelFormatDesc *desc, size_t size __dv(UINT_MAX)) { + return cudaBindTextureInternal(offset, texref, devPtr, desc, + size __dv(UINT_MAX)); +} -__host__ cudaError_t CUDARTAPI cudaSetupArgument(const void *arg, size_t size, size_t offset) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - gpgpusim_ptx_assert( !g_cuda_launch_stack.empty(), "empty launch stack" ); - kernel_config &config = g_cuda_launch_stack.back(); - config.set_arg(arg,size,offset); - printf("GPGPU-Sim PTX: Setting up arguments for %zu bytes starting at 0x%llx..\n",size, (unsigned long long) arg); +__host__ cudaError_t CUDARTAPI cudaBindTextureToArray( + const struct textureReference *texref, const struct cudaArray *array, + const struct cudaChannelFormatDesc *desc) { + return cudaBindTextureToArrayInternal(texref, array, desc); +} - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaUnbindTexture(const struct textureReference *texref) { + return cudaUnbindTextureInternal(texref); } +__host__ cudaError_t CUDARTAPI cudaGetTextureAlignmentOffset( + size_t *offset, const struct textureReference *texref) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} -__host__ cudaError_t CUDARTAPI cudaLaunch( const char *hostFun ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st* context = GPGPUSim_Context(); - char *mode = getenv("PTX_SIM_MODE_FUNC"); - if( mode ) - sscanf(mode,"%u", &g_ptx_sim_mode); - gpgpusim_ptx_assert( !g_cuda_launch_stack.empty(), "empty launch stack" ); - kernel_config config = g_cuda_launch_stack.back(); - { - dim3 gridDim = config.grid_dim(); - dim3 blockDim = config.block_dim(); - if (gridDim.x * gridDim.y * gridDim.z == 0 || blockDim.x * blockDim.y * blockDim.z == 0) - { - //can't launch - printf("can't launch a empty kernel\n"); - g_cuda_launch_stack.pop_back(); - return g_last_cudaError = cudaErrorInvalidConfiguration; - } - } - struct CUstream_st *stream = config.get_stream(); - printf("\nGPGPU-Sim PTX: cudaLaunch for 0x%p (mode=%s) on stream %u\n", hostFun, - g_ptx_sim_mode?"functional simulation":"performance simulation", stream?stream->get_uid():0 ); - kernel_info_t *grid = gpgpu_cuda_ptx_sim_init_grid(hostFun,config.get_args(),config.grid_dim(),config.block_dim(),context); - //do dynamic PDOM analysis for performance simulation scenario - std::string kname = grid->name(); - function_info *kernel_func_info = grid->entry(); - if (kernel_func_info->is_pdom_set()) { - printf("GPGPU-Sim PTX: PDOM analysis already done for %s \n", kname.c_str() ); - } else { - printf("GPGPU-Sim PTX: finding reconvergence points for \'%s\'...\n", kname.c_str() ); - kernel_func_info->do_pdom(); - kernel_func_info->set_pdom(); - } - dim3 gridDim = config.grid_dim(); - dim3 blockDim = config.block_dim(); - - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - checkpoint *g_checkpoint; - g_checkpoint = new checkpoint(); - class memory_space *global_mem; - global_mem = gpu->get_global_memory(); +__host__ cudaError_t CUDARTAPI cudaGetTextureReference( + const struct textureReference **texref, const char *symbol) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; +} - if(gpu->resume_option ==1 && (grid->get_uid()==gpu->resume_kernel)) - { - - char f1name[2048]; - snprintf(f1name,2048,"checkpoint_files/global_mem_%d.txt", grid->get_uid()); +__host__ cudaError_t CUDARTAPI cudaGetChannelDesc( + struct cudaChannelFormatDesc *desc, const struct cudaArray *array) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *desc = array->desc; + return g_last_cudaError = cudaSuccess; +} - g_checkpoint->load_global_mem(global_mem, f1name); - for (int i=0;i<gpu->resume_CTA;i++) - grid->increment_cta_id(); - } - if(gpu->resume_option==1 && (grid->get_uid()<gpu->resume_kernel)) - { - char f1name[2048]; - snprintf(f1name,2048,"checkpoint_files/global_mem_%d.txt", grid->get_uid()); +__host__ struct cudaChannelFormatDesc CUDARTAPI cudaCreateChannelDesc( + int x, int y, int z, int w, enum cudaChannelFormatKind f) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + struct cudaChannelFormatDesc dummy; + dummy.x = x; + dummy.y = y; + dummy.z = z; + dummy.w = w; + dummy.f = f; + return dummy; +} - g_checkpoint->load_global_mem(global_mem, f1name); - printf("Skipping kernel %d as resuming from kernel %d\n",grid->get_uid(),gpu->resume_kernel ); - g_cuda_launch_stack.pop_back(); - return g_last_cudaError = cudaSuccess; - - } - if(gpu->checkpoint_option==1 && (grid->get_uid()>gpu->checkpoint_kernel)) - { - printf("Skipping kernel %d as checkpoint from kernel %d\n",grid->get_uid(),gpu->checkpoint_kernel ); - g_cuda_launch_stack.pop_back(); - return g_last_cudaError = cudaSuccess; - - } - printf("GPGPU-Sim PTX: pushing kernel \'%s\' to stream %u, gridDim= (%u,%u,%u) blockDim = (%u,%u,%u) \n", - kname.c_str(), stream?stream->get_uid():0, gridDim.x,gridDim.y,gridDim.z,blockDim.x,blockDim.y,blockDim.z ); - stream_operation op(grid,g_ptx_sim_mode,stream); - g_stream_manager->push(op); - g_cuda_launch_stack.pop_back(); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaGetLastError(void) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return g_last_cudaError; } -__host__ cudaError_t CUDARTAPI cudaLaunchKernel ( const char* hostFun, dim3 gridDim, dim3 blockDim, const void** args, size_t sharedMem, cudaStream_t stream ) -{ +__host__ const char *cudaGetErrorName(cudaError_t error) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return NULL; +} - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - function_info *entry = context->get_kernel(hostFun); +__host__ const char *CUDARTAPI cudaGetErrorString(cudaError_t error) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + if (g_last_cudaError == cudaSuccess) return "no error"; + char buf[1024]; + snprintf(buf, 1024, "<<GPGPU-Sim PTX: there was an error (code = %d)>>", + g_last_cudaError); + return strdup(buf); +} -#if CUDART_VERSION >= 10000 - assert(g_cudaPushArgsBuffer::g_is_initialized == false); - cudaConfigureCall(g_cudaPushArgsBuffer::g_gridDim, g_cudaPushArgsBuffer::g_blockDim, g_cudaPushArgsBuffer::g_sharedMem, g_cudaPushArgsBuffer::g_stream); -#else - cudaConfigureCall(gridDim, blockDim, sharedMem, stream); -#endif // #if CUDART_VERSION >= 10000 - - for(unsigned i = 0; i < entry->num_args(); i++){ - std::pair<size_t, unsigned> p = entry->get_param_config(i); - cudaSetupArgument(args[i], p.first, p.second); - } +__host__ cudaError_t CUDARTAPI cudaSetupArgument(const void *arg, size_t size, + size_t offset) { + return cudaSetupArgumentInternal(arg, size, offset); +} - cudaLaunch(hostFun); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaLaunch(const char *hostFun) { + return cudaLaunchInternal(hostFun); } +__host__ cudaError_t CUDARTAPI cudaLaunchKernel(const char *hostFun, + dim3 gridDim, dim3 blockDim, + const void **args, + size_t sharedMem, + cudaStream_t stream) { + return cudaLaunchKernelInternal(hostFun, gridDim, blockDim, args, sharedMem, + stream); +} /******************************************************************************* * * @@ -1619,86 +2766,57 @@ __host__ cudaError_t CUDARTAPI cudaLaunchKernel ( const char* hostFun, dim3 grid * * *******************************************************************************/ -__host__ cudaError_t CUDARTAPI cudaStreamCreate(cudaStream_t *stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: cudaStreamCreate\n"); -#if (CUDART_VERSION >= 3000) - *stream = new struct CUstream_st(); - g_stream_manager->add_stream(*stream); -#else - *stream = 0; - printf("GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported (%s)\n", __my_func__); -#endif - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaStreamCreate(cudaStream_t *stream) { + return cudaStreamCreateInternal(stream); } -//TODO: introduce priorities -__host__ cudaError_t CUDARTAPI cudaStreamCreateWithPriority(cudaStream_t *stream, unsigned int flags, int priority) { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return cudaStreamCreate(stream); +// TODO: introduce priorities +__host__ cudaError_t CUDARTAPI cudaStreamCreateWithPriority( + cudaStream_t *stream, unsigned int flags, int priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return cudaStreamCreate(stream); } -__host__ cudaError_t CUDARTAPI cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return cudaSuccess; } -__host__ __device__ cudaError_t CUDARTAPI cudaStreamCreateWithFlags(cudaStream_t *stream, unsigned int flags) { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return cudaStreamCreate(stream); +__host__ __device__ cudaError_t CUDARTAPI +cudaStreamCreateWithFlags(cudaStream_t *stream, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return cudaStreamCreate(stream); } -__host__ cudaError_t CUDARTAPI cudaStreamDestroy(cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -#if (CUDART_VERSION >= 3000) - //per-stream synchronization required for application using external libraries without explicit synchronization in the code to - //avoid the stream_manager from spinning forever to destroy non-empty streams without making any forward progress. - stream->synchronize(); - g_stream_manager->destroy_stream(stream); -#endif - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaStreamDestroy(cudaStream_t stream) { + return cudaStreamDestroyInternal(stream); } -__host__ cudaError_t CUDARTAPI cudaStreamSynchronize(cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -#if (CUDART_VERSION >= 3000) - if( stream == NULL ) - synchronize(); - return g_last_cudaError = cudaSuccess; - stream->synchronize(); -#else - printf("GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported (%s)\n", __my_func__); -#endif - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaStreamSynchronize(cudaStream_t stream) { + return cudaStreamSynchronizeInternal(stream); } -__host__ cudaError_t CUDARTAPI cudaStreamQuery(cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } +__host__ cudaError_t CUDARTAPI cudaStreamQuery(cudaStream_t stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } #if (CUDART_VERSION >= 3000) - if( stream == NULL ) - return g_last_cudaError = cudaErrorInvalidResourceHandle; - return g_last_cudaError = stream->empty()?cudaSuccess:cudaErrorNotReady; + if (stream == NULL) return g_last_cudaError = cudaErrorInvalidResourceHandle; + return g_last_cudaError = stream->empty() ? cudaSuccess : cudaErrorNotReady; #else - printf("GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported (%s)\n", __my_func__); - return g_last_cudaError = cudaSuccess; // it is always success because all cuda calls are synchronous + printf( + "GPGPU-Sim PTX: WARNING: Asynchronous kernel execution not supported " + "(%s)\n", + __my_func__); + return g_last_cudaError = cudaSuccess; // it is always success because all + // cuda calls are synchronous #endif } @@ -1708,170 +2826,107 @@ __host__ cudaError_t CUDARTAPI cudaStreamQuery(cudaStream_t stream) * * *******************************************************************************/ -__host__ cudaError_t CUDARTAPI cudaEventCreate(cudaEvent_t *event) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUevent_st *e = new CUevent_st(false); - g_timer_events[e->get_uid()] = e; -#if CUDART_VERSION >= 3000 - *event = e; -#else - *event = e->get_uid(); -#endif - return g_last_cudaError = cudaSuccess; -} - -CUevent_st *get_event(cudaEvent_t event) -{ - unsigned event_uid; +__host__ cudaError_t CUDARTAPI cudaEventCreate(cudaEvent_t *event) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUevent_st *e = new CUevent_st(false); + g_timer_events[e->get_uid()] = e; #if CUDART_VERSION >= 3000 - event_uid = event->get_uid(); + *event = e; #else - event_uid = event; + *event = e->get_uid(); #endif - event_tracker_t::iterator e = g_timer_events.find(event_uid); - if( e == g_timer_events.end() ) - return NULL; - return e->second; + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaEventRecord(cudaEvent_t event, cudaStream_t stream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUevent_st *e = get_event(event); - if( !e ) return g_last_cudaError = cudaErrorUnknown; - struct CUstream_st *s = (struct CUstream_st *)stream; - stream_operation op(e,s); - e->issue(); - g_stream_manager->push(op); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaEventRecord(cudaEvent_t event, + cudaStream_t stream) { + return cudaEventRecordInternal(event, stream); } -__host__ cudaError_t CUDARTAPI cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //reference: https://www.cs.cmu.edu/afs/cs/academic/class/15668-s11/www/cuda-doc/html/group__CUDART__STREAM_gfe68d207dc965685d92d3f03d77b0876.html - CUevent_st *e = get_event(event); - if( !e ){ - printf("GPGPU-Sim API: Error at cudaStreamWaitEvent. Event is not created .\n"); - return g_last_cudaError = cudaErrorInvalidResourceHandle; - } - else if(e->num_issued() == 0){ - printf("GPGPU-Sim API: Warning: cudaEventRecord has not been called on event before calling cudaStreamWaitEvent.\nNothing to be done.\n"); - return g_last_cudaError = cudaSuccess; - } - if (!stream){ - g_stream_manager->pushCudaStreamWaitEventToAllStreams(e, flags); - } else { - struct CUstream_st *s = (struct CUstream_st *)stream; - stream_operation op(s,e,flags); - g_stream_manager->push(op); - } - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaStreamWaitEvent(cudaStream_t stream, + cudaEvent_t event, + unsigned int flags) { + return cudaStreamWaitEventInternal(stream, event, flags); } -__host__ cudaError_t CUDARTAPI cudaEventQuery(cudaEvent_t event) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUevent_st *e = get_event(event); - if( e == NULL ) { - return g_last_cudaError = cudaErrorInvalidValue; - } else if( e->done() ) { - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorNotReady; - } +__host__ cudaError_t CUDARTAPI cudaEventQuery(cudaEvent_t event) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUevent_st *e = get_event(event); + if (e == NULL) { + return g_last_cudaError = cudaErrorInvalidValue; + } else if (e->done()) { + return g_last_cudaError = cudaSuccess; + } else { + return g_last_cudaError = cudaErrorNotReady; + } } -__host__ cudaError_t CUDARTAPI cudaEventSynchronize(cudaEvent_t event) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim API: cudaEventSynchronize ** waiting for event\n"); - fflush(stdout); - CUevent_st *e = (CUevent_st*) event; - while( !e->done() ) - ; - printf("GPGPU-Sim API: cudaEventSynchronize ** event detected\n"); - fflush(stdout); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaEventSynchronize(cudaEvent_t event) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim API: cudaEventSynchronize ** waiting for event\n"); + fflush(stdout); + CUevent_st *e = (CUevent_st *)event; + while (!e->done()) + ; + printf("GPGPU-Sim API: cudaEventSynchronize ** event detected\n"); + fflush(stdout); + return g_last_cudaError = cudaSuccess; } -__host__ cudaError_t CUDARTAPI cudaEventDestroy(cudaEvent_t event) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUevent_st *e = get_event(event); - unsigned event_uid = e->get_uid(); - event_tracker_t::iterator pe = g_timer_events.find(event_uid); - if( pe == g_timer_events.end() ) - return g_last_cudaError = cudaErrorInvalidValue; - g_timer_events.erase(pe); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaEventDestroy(cudaEvent_t event) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + CUevent_st *e = get_event(event); + unsigned event_uid = e->get_uid(); + event_tracker_t::iterator pe = g_timer_events.find(event_uid); + if (pe == g_timer_events.end()) + return g_last_cudaError = cudaErrorInvalidValue; + g_timer_events.erase(pe); + return g_last_cudaError = cudaSuccess; } - -__host__ cudaError_t CUDARTAPI cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - time_t elapsed_time; - CUevent_st *s = get_event(start); - CUevent_st *e = get_event(end); - if( s==NULL || e==NULL ) - return g_last_cudaError = cudaErrorUnknown; - elapsed_time = e->clock() - s->clock(); - *ms = 1000*elapsed_time; - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaEventElapsedTime(float *ms, + cudaEvent_t start, + cudaEvent_t end) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + time_t elapsed_time; + CUevent_st *s = get_event(start); + CUevent_st *e = get_event(end); + if (s == NULL || e == NULL) return g_last_cudaError = cudaErrorUnknown; + elapsed_time = e->clock() - s->clock(); + *ms = 1000 * elapsed_time; + return g_last_cudaError = cudaSuccess; } - - /******************************************************************************* * * * * * * *******************************************************************************/ -__host__ cudaError_t CUDARTAPI cudaThreadExit(void) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - exit_simulation(); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI cudaThreadExit(void) { + return cudaThreadExitInternal(); } -__host__ cudaError_t CUDARTAPI cudaThreadSynchronize(void) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //Called on host side - synchronize(); - return g_last_cudaError = cudaSuccess; -}; - -int CUDARTAPI __cudaSynchronizeThreads(void**, void*) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return cudaThreadExit(); +__host__ cudaError_t CUDARTAPI cudaThreadSynchronize(void) { + return cudaThreadSynchronizeInternal(); } - +int CUDARTAPI __cudaSynchronizeThreads(void **, void *) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return cudaThreadExit(); +} /******************************************************************************* * * @@ -1881,39 +2936,40 @@ int CUDARTAPI __cudaSynchronizeThreads(void**, void*) #if (CUDART_VERSION >= 3010) int dummy0() { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -return 0; } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return 0; +} int dummy1() { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -return 2 << 20; } + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return 2 << 20; +} typedef int (*ExportedFunction)(); static ExportedFunction exportTable[3] = {&dummy0, &dummy0, &dummy0}; -__host__ cudaError_t CUDARTAPI cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("cudaGetExportTable: UUID = "); - for (int s = 0; s < 16; s++) { - printf("%#2x ", (unsigned char) (pExportTableId->bytes[s])); - } - *ppExportTable = &exportTable; +__host__ cudaError_t CUDARTAPI cudaGetExportTable( + const void **ppExportTable, const cudaUUID_t *pExportTableId) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("cudaGetExportTable: UUID = "); + for (int s = 0; s < 16; s++) { + printf("%#2x ", (unsigned char)(pExportTableId->bytes[s])); + } + *ppExportTable = &exportTable; - printf("\n"); - return g_last_cudaError = cudaSuccess; + printf("\n"); + return g_last_cudaError = cudaSuccess; } #endif - /******************************************************************************* * * * * @@ -1922,1524 +2978,1115 @@ __host__ cudaError_t CUDARTAPI cudaGetExportTable(const void **ppExportTable, co //#include "../../cuobjdump_to_ptxplus/cuobjdump_parser.h" -enum cuobjdumpSectionType { - PTXSECTION=0, - ELFSECTION -}; - - -class cuobjdumpSection { -public: - //Constructor - cuobjdumpSection() { - arch = 0; - identifier = ""; - } - virtual ~cuobjdumpSection() {} - unsigned getArch() {return arch;} - void setArch(unsigned a) {arch = a;} - std::string getIdentifier() {return identifier;} - void setIdentifier(std::string i) {identifier = i;} - virtual void print(){std::cout << "cuobjdump Section: unknown type" << std::endl;} -private: - unsigned arch; - std::string identifier; -}; - -class cuobjdumpELFSection : public cuobjdumpSection -{ -public: - cuobjdumpELFSection() {} - virtual ~cuobjdumpELFSection() { - elffilename = ""; - sassfilename = ""; - } - std::string getELFfilename() {return elffilename;} - void setELFfilename(std::string f) {elffilename = f;} - std::string getSASSfilename() {return sassfilename;} - void setSASSfilename(std::string f) {sassfilename = f;} - virtual void print() { - std::cout << "ELF Section:" << std::endl; - std::cout << "arch: sm_" << getArch() << std::endl; - std::cout << "identifier: " << getIdentifier() << std::endl; - std::cout << "elf filename: " << getELFfilename() << std::endl; - std::cout << "sass filename: " << getSASSfilename() << std::endl; - std::cout << std::endl; - } -private: - std::string elffilename; - std::string sassfilename; -}; - -class cuobjdumpPTXSection : public cuobjdumpSection -{ -public: - cuobjdumpPTXSection(){ - ptxfilename = ""; - } - std::string getPTXfilename() {return ptxfilename;} - void setPTXfilename(std::string f) {ptxfilename = f;} - virtual void print() { - std::cout << "PTX Section:" << std::endl; - std::cout << "arch: sm_" << getArch() << std::endl; - std::cout << "identifier: " << getIdentifier() << std::endl; - std::cout << "ptx filename: " << getPTXfilename() << std::endl; - std::cout << std::endl; - } -private: - std::string ptxfilename; -}; - -std::list<cuobjdumpSection*> cuobjdumpSectionList; -std::list<cuobjdumpSection*> libSectionList; - -// sectiontype: 0 for ptx, 1 for elf -void addCuobjdumpSection(int sectiontype){ - if (sectiontype) - cuobjdumpSectionList.push_front(new cuobjdumpELFSection()); - else - cuobjdumpSectionList.push_front(new cuobjdumpPTXSection()); - printf("## Adding new section %s\n", sectiontype?"ELF":"PTX"); -} - -void setCuobjdumparch(const char* arch){ - unsigned archnum; - sscanf(arch, "sm_%u", &archnum); - assert (archnum && "cannot have sm_0"); - printf("Adding arch: %s\n", arch); - cuobjdumpSectionList.front()->setArch(archnum); -} - -void setCuobjdumpidentifier(const char* identifier){ - printf("Adding identifier: %s\n", identifier); - cuobjdumpSectionList.front()->setIdentifier(identifier); -} - -void setCuobjdumpptxfilename(const char* filename){ - printf("Adding ptx filename: %s\n", filename); - cuobjdumpSection* x = cuobjdumpSectionList.front(); - if (dynamic_cast<cuobjdumpPTXSection*>(x) == NULL){ - assert (0 && "You shouldn't be trying to add a ptxfilename to an elf section"); - } - (dynamic_cast<cuobjdumpPTXSection*>(x))->setPTXfilename(filename); -} - -void setCuobjdumpelffilename(const char* filename){ - if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){ - assert (0 && "You shouldn't be trying to add a elffilename to an ptx section"); - } - (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setELFfilename(filename); -} - -void setCuobjdumpsassfilename(const char* filename){ - if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){ - assert (0 && "You shouldn't be trying to add a sassfilename to an ptx section"); - } - (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setSASSfilename(filename); -} -extern int cuobjdump_parse(); -extern FILE *cuobjdump_in; - -//! Return the executable file of the process containing the PTX/SASS code -//! -//! This Function returns the executable file ran by the process. This -//! executable is supposed to contain the PTX/SASS code. It provides workaround -//! for processes running on valgrind by dereferencing /proc/<pid>/exe within the -//! GPGPU-Sim process before calling cuobjdump to extract PTX/SASS. This is -//! needed because valgrind uses x86 emulation to detect memory leak. Other -//! processes (e.g. cuobjdump) reading /proc/<pid>/exe will see the emulator -//! executable instead of the application binary. -//! -std::string get_app_binary(){ - char self_exe_path[1025]; -#ifdef __APPLE__ - uint32_t size = sizeof(self_exe_path); - if( _NSGetExecutablePath(self_exe_path,&size) != 0 ) { - printf("GPGPU-Sim ** ERROR: _NSGetExecutablePath input buffer too small\n"); - exit(1); - } -#else - std::stringstream exec_link; - exec_link << "/proc/self/exe"; +// extracts all ptx files from binary and dumps into +// prog_name.unique_no.sm_<>.ptx files +void cuda_runtime_api::extract_ptx_files_using_cuobjdump(CUctx_st *context) { + char command[1000]; + char *pytorch_bin = getenv("PYTORCH_BIN"); + std::string app_binary = get_app_binary(); - ssize_t path_length = readlink(exec_link.str().c_str(), self_exe_path, 1024); - assert(path_length != -1); - self_exe_path[path_length] = '\0'; -#endif + char ptx_list_file_name[1024]; + snprintf(ptx_list_file_name, 1024, "_cuobjdump_list_ptx_XXXXXX"); + int fd2 = mkstemp(ptx_list_file_name); + close(fd2); - printf("self exe links to: %s\n", self_exe_path); - return self_exe_path; -} + if (pytorch_bin != NULL && strlen(pytorch_bin) != 0) { + app_binary = std::string(pytorch_bin); + } -//above func gives abs path whereas this give just the name of application. -char* get_app_binary_name(std::string abs_path){ - char *self_exe_path; -#ifdef __APPLE__ - //TODO: get apple device and check the result. - printf("WARNING: not tested for Apple-mac devices \n"); - abort(); -#else - char* buf = strdup(abs_path.c_str()); - char *token = strtok(buf, "/"); - while(token !=NULL){ - self_exe_path = token; - token = strtok(NULL,"/"); - } -#endif - self_exe_path = strtok(self_exe_path, "."); - printf("self exe links to: %s\n", self_exe_path); - return self_exe_path; -} - -//extracts all ptx files from binary and dumps into prog_name.unique_no.sm_<>.ptx files -void extract_ptx_files_using_cuobjdump(){ - extern bool g_cdp_enabled; - char command[1000]; - char *pytorch_bin = getenv("PYTORCH_BIN"); - std::string app_binary = get_app_binary(); - - - char ptx_list_file_name[1024]; - snprintf(ptx_list_file_name,1024,"_cuobjdump_list_ptx_XXXXXX"); - int fd2=mkstemp(ptx_list_file_name); - close(fd2); - - if (pytorch_bin!=NULL && strlen(pytorch_bin)!=0){ - app_binary = std::string(pytorch_bin); - } - - //only want file names - snprintf(command,1000,"$CUDA_INSTALL_PATH/bin/cuobjdump -lptx %s | cut -d \":\" -f 2 | awk '{$1=$1}1' > %s", app_binary.c_str(), ptx_list_file_name); - if( system(command) != 0 ) { - printf("WARNING: Failed to execute cuobjdump to get list of ptx files \n"); - exit(0); - } - if(!g_cdp_enabled) { - //based on the list above, dump ptx files individually. Format of dumped ptx file is prog_name.unique_no.sm_<>.ptx - - std::ifstream infile(ptx_list_file_name); - std::string line; - while (std::getline(infile, line)) - { - //int pos = line.find(std::string(get_app_binary_name(app_binary))); - const char *ptx_file = line.c_str(); - printf("Extracting specific PTX file named %s \n",ptx_file); - snprintf(command,1000,"$CUDA_INSTALL_PATH/bin/cuobjdump -xptx %s %s", ptx_file, app_binary.c_str()); - if (system(command)!=0) { - printf("ERROR: command: %s failed \n",command); - exit(0); - } - no_of_ptx++; - } - } - - if(!no_of_ptx){ - printf("WARNING: Number of ptx in the executable file are 0. One of the reasons might be\n"); - printf("\t1. CDP is enabled\n"); - printf("\t2. When using PyTorch, PYTORCH_BIN is not set correctly\n"); - } + // only want file names + snprintf(command, 1000, + "$CUDA_INSTALL_PATH/bin/cuobjdump -lptx %s | cut -d \":\" -f 2 | " + "awk '{$1=$1}1' > %s", + app_binary.c_str(), ptx_list_file_name); + if (system(command) != 0) { + printf("WARNING: Failed to execute cuobjdump to get list of ptx files \n"); + exit(0); + } + if (!gpgpu_ctx->device_runtime->g_cdp_enabled) { + // based on the list above, dump ptx files individually. Format of dumped + // ptx file is prog_name.unique_no.sm_<>.ptx std::ifstream infile(ptx_list_file_name); std::string line; - while (std::getline(infile, line)) - { - //int pos = line.find(std::string(get_app_binary_name(app_binary))); - const char *ptx_file = line.c_str(); - int pos1 = line.find("sm_"); - int pos2 = line.find_last_of("."); - if (pos1==std::string::npos&&pos2==std::string::npos){ - printf("ERROR: PTX list is not in correct format"); - exit(0); - } - std::string vstr = line.substr(pos1+3,pos2-pos1-3); - int version = atoi(vstr.c_str()); - if (version_filename.find(version)==version_filename.end()){ - version_filename[version] = std::set<std::string>(); - } - version_filename[version].insert(line); + while (std::getline(infile, line)) { + // int pos = line.find(std::string(get_app_binary_name(app_binary))); + const char *ptx_file = line.c_str(); + printf("Extracting specific PTX file named %s \n", ptx_file); + snprintf(command, 1000, "$CUDA_INSTALL_PATH/bin/cuobjdump -xptx %s %s", + ptx_file, app_binary.c_str()); + if (system(command) != 0) { + printf("ERROR: command: %s failed \n", command); + exit(0); + } + context->no_of_ptx++; } + } -} + if (!context->no_of_ptx) { + printf( + "WARNING: Number of ptx in the executable file are 0. One of the " + "reasons might be\n"); + printf("\t1. CDP is enabled\n"); + printf("\t2. When using PyTorch, PYTORCH_BIN is not set correctly\n"); + } -static int get_app_cuda_version() { - int app_cuda_version = 0; - char fname[1024]; - snprintf(fname,1024,"_app_cuda_version_XXXXXX"); - int fd=mkstemp(fname); - close(fd); - std::string app_cuda_version_command = "ldd " + get_app_binary() + " | grep libcudart.so | sed 's/.*libcudart.so.\\(.*\\) =>.*/\\1/' > " + fname; - system(app_cuda_version_command.c_str()); - FILE * cmd = fopen(fname, "r"); - char buf[256]; - while (fgets(buf, sizeof(buf), cmd) != 0) { - std::cout << buf; - app_cuda_version = atoi(buf); + std::ifstream infile(ptx_list_file_name); + std::string line; + while (std::getline(infile, line)) { + // int pos = line.find(std::string(get_app_binary_name(app_binary))); + int pos1 = line.find("sm_"); + int pos2 = line.find_last_of("."); + if (pos1 == std::string::npos && pos2 == std::string::npos) { + printf("ERROR: PTX list is not in correct format"); + exit(0); } - fclose(cmd); - if ( app_cuda_version == 0 ) { - printf( "Error - Cannot detect the app's CUDA version.\n" ); - exit(1); + std::string vstr = line.substr(pos1 + 3, pos2 - pos1 - 3); + int version = atoi(vstr.c_str()); + if (version_filename.find(version) == version_filename.end()) { + version_filename[version] = std::set<std::string>(); } - return app_cuda_version; + version_filename[version].insert(line); + } } - //! Call cuobjdump to extract everything (-elf -sass -ptx) /*! * This Function extract the whole PTX (for all the files) using cuobjdump - * to _cuobjdump_complete_output_XXXXXX then runs a parser to chop it up with each binary in - * its own file - * It is also responsible for extracting the libraries linked to the binary if the option is - * enabled + * to _cuobjdump_complete_output_XXXXXX then runs a parser to chop it up + *with each binary in its own file It is also responsible for extracting the + *libraries linked to the binary if the option is enabled * */ -void extract_code_using_cuobjdump(){ - CUctx_st *context = GPGPUSim_Context(); - unsigned forced_max_capability = context->get_device()->get_gpgpu()->get_config().get_forced_max_capability(); +void cuda_runtime_api::extract_code_using_cuobjdump() { + CUctx_st *context = GPGPUSim_Context(gpgpu_ctx); - //prevent the dumping by cuobjdump everytime we execute the code! - const char *override_cuobjdump = getenv("CUOBJDUMP_SIM_FILE"); - char command[1000], ptx_file[1000]; - std::string app_binary = get_app_binary(); - //Running cuobjdump using dynamic link to current process - snprintf(command,1000,"md5sum %s ", app_binary.c_str()); - printf("Running md5sum using \"%s\"\n", command); - if(system(command)){ - std::cout << "Failed to execute: " << command << std::endl; - exit(1); - } - // Running cuobjdump using dynamic link to current process - // Needs the option '-all' to extract PTX from CDP-enabled binary - extern bool g_cdp_enabled; + // prevent the dumping by cuobjdump everytime we execute the code! + const char *override_cuobjdump = getenv("CUOBJDUMP_SIM_FILE"); + char command[1000]; + std::string app_binary = get_app_binary(); + // Running cuobjdump using dynamic link to current process + snprintf(command, 1000, "md5sum %s ", app_binary.c_str()); + printf("Running md5sum using \"%s\"\n", command); + if (system(command)) { + std::cout << "Failed to execute: " << command << std::endl; + exit(1); + } + // Running cuobjdump using dynamic link to current process + // Needs the option '-all' to extract PTX from CDP-enabled binary - //dump ptx for all individial ptx files into sepearte files which is later used by ptxas. - int result=0; + // dump ptx for all individial ptx files into sepearte files which is later + // used by ptxas. + int result = 0; #if (CUDART_VERSION >= 6000) - extract_ptx_files_using_cuobjdump(); - return; + extract_ptx_files_using_cuobjdump(context); + return; #endif - //TODO: redundant to dump twice. how can it be prevented? - //dump only for specific arch - char fname[1024]; - if ((override_cuobjdump == NULL) || (strlen(override_cuobjdump)==0)) { - snprintf(fname,1024,"_cuobjdump_complete_output_XXXXXX"); - int fd=mkstemp(fname); - close(fd); - if(!g_cdp_enabled) - snprintf(command,1000,"$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass %s > %s", app_binary.c_str(), fname); - else - snprintf(command,1000,"$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass -all %s > %s", app_binary.c_str(), fname); - bool parse_output = true; - result = system(command); - if(result) { - if (context->get_device()->get_gpgpu()->get_config().experimental_lib_support() && (result == 65280)) { - // Some CUDA application may exclusively use kernels provided by CUDA - // libraries (e.g. CUBLAS). Skipping cuobjdump extraction from the - // executable for this case. - // 65280 is the return code from cuobjdump denoting the specific error (tested on CUDA 4.0/4.1/4.2) - printf("WARNING: Failed to execute: %s\n", command); - printf(" Executable binary does not contain any GPU kernel.\n"); - parse_output = false; - } else { - printf("ERROR: Failed to execute: %s\n", command); - exit(1); - } - } + // TODO: redundant to dump twice. how can it be prevented? + // dump only for specific arch + char fname[1024]; + if ((override_cuobjdump == NULL) || (strlen(override_cuobjdump) == 0)) { + snprintf(fname, 1024, "_cuobjdump_complete_output_XXXXXX"); + int fd = mkstemp(fname); + close(fd); + if (!gpgpu_ctx->device_runtime->g_cdp_enabled) + snprintf(command, 1000, + "$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass %s > %s", + app_binary.c_str(), fname); + else + snprintf(command, 1000, + "$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass -all %s > %s", + app_binary.c_str(), fname); + bool parse_output = true; + result = system(command); + if (result) { + if (context->get_device() + ->get_gpgpu() + ->get_config() + .experimental_lib_support() && + (result == 65280)) { + // Some CUDA application may exclusively use kernels provided by CUDA + // libraries (e.g. CUBLAS). Skipping cuobjdump extraction from the + // executable for this case. + // 65280 is the return code from cuobjdump denoting the specific error + // (tested on CUDA 4.0/4.1/4.2) + printf("WARNING: Failed to execute: %s\n", command); + printf(" Executable binary does not contain any GPU kernel.\n"); + parse_output = false; + } else { + printf("ERROR: Failed to execute: %s\n", command); + exit(1); + } + } - if (parse_output) { - printf("Parsing file %s\n", fname); - cuobjdump_in = fopen(fname, "r"); + if (parse_output) { + printf("Parsing file %s\n", fname); + FILE *cuobjdump_in; + cuobjdump_in = fopen(fname, "r"); - cuobjdump_parse(); - fclose(cuobjdump_in); - printf("Done parsing!!!\n"); - } else { - printf("Parsing skipped for %s\n", fname); - } + struct cuobjdump_parser parser; + parser.elfserial = 1; + parser.ptxserial = 1; + cuobjdump_lex_init(&(parser.scanner)); + cuobjdump_set_in(cuobjdump_in, (parser.scanner)); + cuobjdump_parse(parser.scanner, &parser, cuobjdumpSectionList); + cuobjdump_lex_destroy(parser.scanner); + fclose(cuobjdump_in); + printf("Done parsing!!!\n"); + } else { + printf("Parsing skipped for %s\n", fname); + } - if (context->get_device()->get_gpgpu()->get_config().experimental_lib_support()){ - //Experimental library support - //Currently only for cufft + if (context->get_device() + ->get_gpgpu() + ->get_config() + .experimental_lib_support()) { + // Experimental library support + // Currently only for cufft - std::stringstream cmd; - cmd << "ldd " << app_binary << " | grep $CUDA_INSTALL_PATH | awk \'{print $3}\' > _tempfile_.txt"; - int result = system(cmd.str().c_str()); - if(result){ - std::cout << "Failed to execute: " << cmd.str() << std::endl; - exit(1); - } - std::ifstream libsf; - libsf.open("_tempfile_.txt"); - if(!libsf.is_open()) { - std::cout << "Failed to open: _tempfile_.txt" << std::endl; - exit(1); - } + std::stringstream cmd; + cmd << "ldd " << app_binary + << " | grep $CUDA_INSTALL_PATH | awk \'{print $3}\' > _tempfile_.txt"; + int result = system(cmd.str().c_str()); + if (result) { + std::cout << "Failed to execute: " << cmd.str() << std::endl; + exit(1); + } + std::ifstream libsf; + libsf.open("_tempfile_.txt"); + if (!libsf.is_open()) { + std::cout << "Failed to open: _tempfile_.txt" << std::endl; + exit(1); + } - //Save the original section list - std::list<cuobjdumpSection*> tmpsl = cuobjdumpSectionList; - cuobjdumpSectionList.clear(); + // Save the original section list + std::list<cuobjdumpSection *> tmpsl = cuobjdumpSectionList; + cuobjdumpSectionList.clear(); - std::string line; - std::getline(libsf, line); - std::cout << "DOING: " << line << std::endl; - int cnt=1; - while(libsf.good()){ - std::stringstream libcodfn; - libcodfn << "_cuobjdump_complete_lib_" << cnt << "_"; - cmd.str(""); //resetting - cmd << "$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass "; - cmd << line; - cmd << " > "; - cmd << libcodfn.str(); - std::cout << "Running cuobjdump on " << line << std::endl; - std::cout << "Using command: " << cmd.str() << std::endl; - result = system(cmd.str().c_str()); - if(result) {printf("ERROR: Failed to execute: %s\n", command); exit(1);} - std::cout << "Done" << std::endl; + std::string line; + std::getline(libsf, line); + std::cout << "DOING: " << line << std::endl; + int cnt = 1; + while (libsf.good()) { + std::stringstream libcodfn; + libcodfn << "_cuobjdump_complete_lib_" << cnt << "_"; + cmd.str(""); // resetting + cmd << "$CUDA_INSTALL_PATH/bin/cuobjdump -ptx -elf -sass "; + cmd << line; + cmd << " > "; + cmd << libcodfn.str(); + std::cout << "Running cuobjdump on " << line << std::endl; + std::cout << "Using command: " << cmd.str() << std::endl; + result = system(cmd.str().c_str()); + if (result) { + printf("ERROR: Failed to execute: %s\n", command); + exit(1); + } + std::cout << "Done" << std::endl; - std::cout << "Trying to parse " << libcodfn.str() << std::endl; - cuobjdump_in = fopen(libcodfn.str().c_str(), "r"); - cuobjdump_parse(); - fclose(cuobjdump_in); - std::getline(libsf, line); - } - libSectionList = cuobjdumpSectionList; + std::cout << "Trying to parse " << libcodfn.str() << std::endl; + FILE *cuobjdump_in; + cuobjdump_in = fopen(libcodfn.str().c_str(), "r"); + struct cuobjdump_parser parser; + parser.elfserial = 1; + parser.ptxserial = 1; + cuobjdump_lex_init(&(parser.scanner)); + cuobjdump_set_in(cuobjdump_in, (parser.scanner)); + cuobjdump_parse(parser.scanner, &parser, cuobjdumpSectionList); + cuobjdump_lex_destroy(parser.scanner); + fclose(cuobjdump_in); + std::getline(libsf, line); + } + libSectionList = cuobjdumpSectionList; - //Restore the original section list - cuobjdumpSectionList = tmpsl; - } - } else { - printf("GPGPU-Sim PTX: overriding cuobjdump with '%s' (CUOBJDUMP_SIM_FILE is set)\n", override_cuobjdump); - snprintf(fname,1024, "%s",override_cuobjdump); + // Restore the original section list + cuobjdumpSectionList = tmpsl; } + } else { + printf( + "GPGPU-Sim PTX: overriding cuobjdump with '%s' (CUOBJDUMP_SIM_FILE is " + "set)\n", + override_cuobjdump); + snprintf(fname, 1024, "%s", override_cuobjdump); + } } //! Read file into char* -//TODO: convert this to C++ streams, will be way cleaner -char* readfile (const std::string filename){ - assert (filename != ""); - FILE* fp = fopen(filename.c_str(),"r"); - if (!fp) { - std::cout << "ERROR: Could not open file %s for reading\n" << filename << std::endl; - assert (0); - } - // finding size of the file - int filesize= 0; - fseek (fp , 0 , SEEK_END); +// TODO: convert this to C++ streams, will be way cleaner +char *readfile(const std::string filename) { + assert(filename != ""); + FILE *fp = fopen(filename.c_str(), "r"); + if (!fp) { + std::cout << "ERROR: Could not open file %s for reading\n" + << filename << std::endl; + assert(0); + } + // finding size of the file + int filesize = 0; + fseek(fp, 0, SEEK_END); - filesize = ftell (fp); - fseek (fp, 0, SEEK_SET); - // allocate and copy the entire ptx - char* ret = (char*)malloc((filesize +1)* sizeof(char)); - fread(ret,1,filesize,fp); - ret[filesize]='\0'; - fclose(fp); - return ret; + filesize = ftell(fp); + fseek(fp, 0, SEEK_SET); + // allocate and copy the entire ptx + char *ret = (char *)malloc((filesize + 1) * sizeof(char)); + fread(ret, 1, filesize, fp); + ret[filesize] = '\0'; + fclose(fp); + return ret; } //! Function that helps debugging -void printSectionList(std::list<cuobjdumpSection*> sl) { - std::list<cuobjdumpSection*>::iterator iter; - for ( iter = sl.begin(); - iter != sl.end(); - iter++ - ){ - (*iter)->print(); - } +void printSectionList(std::list<cuobjdumpSection *> sl) { + std::list<cuobjdumpSection *>::iterator iter; + for (iter = sl.begin(); iter != sl.end(); iter++) { + (*iter)->print(); + } } //! Remove unecessary sm versions from the section list -std::list<cuobjdumpSection*> pruneSectionList(std::list<cuobjdumpSection*> cuobjdumpSectionList, CUctx_st *context) { - unsigned forced_max_capability = context->get_device()->get_gpgpu()->get_config().get_forced_max_capability(); +std::list<cuobjdumpSection *> cuda_runtime_api::pruneSectionList( + CUctx_st *context) { + unsigned forced_max_capability = context->get_device() + ->get_gpgpu() + ->get_config() + .get_forced_max_capability(); - //For ptxplus, force the max capability to 19 if it's higher or unspecified(0) - if (context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus()){ - if ( (forced_max_capability == 0) || - (forced_max_capability >= 20)){ - printf("GPGPU-Sim: WARNING: Capability >= 20 are not supported in PTXPlus\n\tSetting forced_max_capability to 19\n"); - forced_max_capability = 19; - } - } + // For ptxplus, force the max capability to 19 if it's higher or + // unspecified(0) + if (context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus()) { + if ((forced_max_capability == 0) || (forced_max_capability >= 20)) { + printf( + "GPGPU-Sim: WARNING: Capability >= 20 are not supported in " + "PTXPlus\n\tSetting forced_max_capability to 19\n"); + forced_max_capability = 19; + } + } - std::list<cuobjdumpSection*> prunedList; + std::list<cuobjdumpSection *> prunedList; - //Find the highest capability (that is lower than the forced maximum) for each cubin file - //and set it in cuobjdumpSectionMap. Do this only for ptx sections - std::map<std::string, unsigned> cuobjdumpSectionMap; - int min_ptx_capability_found=0; - for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin(); - iter != cuobjdumpSectionList.end(); - iter++){ - unsigned capability = (*iter)->getArch(); - if(dynamic_cast<cuobjdumpPTXSection*>(*iter) != NULL){ - if(capability<min_ptx_capability_found || min_ptx_capability_found==0) - min_ptx_capability_found=capability; - if (capability <= forced_max_capability || forced_max_capability==0) { - if((cuobjdumpSectionMap.find((*iter)->getIdentifier())==cuobjdumpSectionMap.end()) - || (cuobjdumpSectionMap[(*iter)->getIdentifier()] < capability)) - cuobjdumpSectionMap[(*iter)->getIdentifier()] = capability; - } - } - } + // Find the highest capability (that is lower than the forced maximum) for + // each cubin file and set it in cuobjdumpSectionMap. Do this only for ptx + // sections + std::map<std::string, unsigned> cuobjdumpSectionMap; + int min_ptx_capability_found = 0; + for (std::list<cuobjdumpSection *>::iterator iter = + cuobjdumpSectionList.begin(); + iter != cuobjdumpSectionList.end(); iter++) { + unsigned capability = (*iter)->getArch(); + if (dynamic_cast<cuobjdumpPTXSection *>(*iter) != NULL) { + if (capability < min_ptx_capability_found || + min_ptx_capability_found == 0) + min_ptx_capability_found = capability; + if (capability <= forced_max_capability || forced_max_capability == 0) { + if ((cuobjdumpSectionMap.find((*iter)->getIdentifier()) == + cuobjdumpSectionMap.end()) || + (cuobjdumpSectionMap[(*iter)->getIdentifier()] < capability)) + cuobjdumpSectionMap[(*iter)->getIdentifier()] = capability; + } + } + } - //Throw away the sections with the lower capabilites and push those with the highest in - //the pruned list - for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin(); - iter != cuobjdumpSectionList.end(); - iter++){ - unsigned capability = (*iter)->getArch(); - if(capability == cuobjdumpSectionMap[(*iter)->getIdentifier()]){ - prunedList.push_back(*iter); - } else { - delete *iter; - } - } - if(prunedList.empty()){ - printf("Error: No PTX sections found with sm capability that is lower than current forced maximum capability \n minimum ptx capability found = %u, maximum forced ptx capability = %u \n User might want to change either the forced maximum capability from gpgpusim configuration or update the compilation to generate the required PTX version\n",min_ptx_capability_found,forced_max_capability); - abort(); - } - return prunedList; + // Throw away the sections with the lower capabilites and push those with the + // highest in the pruned list + for (std::list<cuobjdumpSection *>::iterator iter = + cuobjdumpSectionList.begin(); + iter != cuobjdumpSectionList.end(); iter++) { + unsigned capability = (*iter)->getArch(); + if (capability == cuobjdumpSectionMap[(*iter)->getIdentifier()]) { + prunedList.push_back(*iter); + } else { + delete *iter; + } + } + if (prunedList.empty()) { + printf( + "Error: No PTX sections found with sm capability that is lower than " + "current forced maximum capability \n minimum ptx capability found = " + "%u, maximum forced ptx capability = %u \n User might want to change " + "either the forced maximum capability from gpgpusim configuration or " + "update the compilation to generate the required PTX version\n", + min_ptx_capability_found, forced_max_capability); + abort(); + } + return prunedList; } //! Merge all PTX sections that have a specific identifier into one file -std::list<cuobjdumpSection*> mergeMatchingSections(std::list<cuobjdumpSection*> cuobjdumpSectionList, std::string identifier){ - const char *ptxcode = ""; - std::list<cuobjdumpSection*>::iterator old_iter; - cuobjdumpPTXSection* old_ptxsection = NULL; - cuobjdumpPTXSection* ptxsection; - std::list<cuobjdumpSection*> mergedList; +std::list<cuobjdumpSection *> cuda_runtime_api::mergeMatchingSections( + std::string identifier) { + const char *ptxcode = ""; + std::list<cuobjdumpSection *>::iterator old_iter; + cuobjdumpPTXSection *old_ptxsection = NULL; + cuobjdumpPTXSection *ptxsection; + std::list<cuobjdumpSection *> mergedList; - for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin(); - iter != cuobjdumpSectionList.end(); - iter++){ - if((ptxsection=dynamic_cast<cuobjdumpPTXSection*>(*iter)) != NULL && - strcmp(ptxsection->getIdentifier().c_str(), identifier.c_str()) == 0){ - // Read and remove the last PTX section - if (old_ptxsection != NULL) { - ptxcode = readfile(old_ptxsection->getPTXfilename()); - // remove ptx file? - delete *old_iter; - } + for (std::list<cuobjdumpSection *>::iterator iter = + cuobjdumpSectionList.begin(); + iter != cuobjdumpSectionList.end(); iter++) { + if ((ptxsection = dynamic_cast<cuobjdumpPTXSection *>(*iter)) != NULL && + strcmp(ptxsection->getIdentifier().c_str(), identifier.c_str()) == 0) { + // Read and remove the last PTX section + if (old_ptxsection != NULL) { + ptxcode = readfile(old_ptxsection->getPTXfilename()); + // remove ptx file? + delete *old_iter; + } - // Append all the PTX from the last PTX section into the current PTX section - // Add 50 to ptxcode to ignore the information regarding version/target/address_size - if (strlen(ptxcode) >= 50) { - FILE *ptxfile = fopen((ptxsection->getPTXfilename()).c_str(), "a"); - fprintf(ptxfile, "%s", ptxcode + 50); - fclose(ptxfile); - } + // Append all the PTX from the last PTX section into the current PTX + // section Add 50 to ptxcode to ignore the information regarding + // version/target/address_size + if (strlen(ptxcode) >= 50) { + FILE *ptxfile = fopen((ptxsection->getPTXfilename()).c_str(), "a"); + fprintf(ptxfile, "%s", ptxcode + 50); + fclose(ptxfile); + } - old_iter = iter; - old_ptxsection = ptxsection; - } - // Store all non-PTX sections and PTX sections with non-matching identifiers - else { - mergedList.push_back(*iter); - } - } + old_iter = iter; + old_ptxsection = ptxsection; + } + // Store all non-PTX sections and PTX sections with non-matching identifiers + else { + mergedList.push_back(*iter); + } + } - // Store the final PTX section - mergedList.push_back(*old_iter); + // Store the final PTX section + mergedList.push_back(*old_iter); - return mergedList; + return mergedList; } //! Merge any PTX sections with matching identifiers -std::list<cuobjdumpSection*> mergeSections(std::list<cuobjdumpSection*> cuobjdumpSectionList){ - std::vector<std::string> identifier; - cuobjdumpPTXSection* ptxsection; +std::list<cuobjdumpSection *> cuda_runtime_api::mergeSections() { + std::vector<std::string> identifier; + cuobjdumpPTXSection *ptxsection; - // Add all identifiers present in PTX sections to a vector - for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin(); - iter != cuobjdumpSectionList.end(); - iter++){ - if((ptxsection=dynamic_cast<cuobjdumpPTXSection*>(*iter)) != NULL){ - std::string current_id = ptxsection->getIdentifier(); + // Add all identifiers present in PTX sections to a vector + for (std::list<cuobjdumpSection *>::iterator iter = + cuobjdumpSectionList.begin(); + iter != cuobjdumpSectionList.end(); iter++) { + if ((ptxsection = dynamic_cast<cuobjdumpPTXSection *>(*iter)) != NULL) { + std::string current_id = ptxsection->getIdentifier(); - // If we haven't yet seen a given identifier, add it to the vector - if (std::find(identifier.begin(), identifier.end(), current_id) == identifier.end()) { - identifier.push_back(current_id); - } - } - } + // If we haven't yet seen a given identifier, add it to the vector + if (std::find(identifier.begin(), identifier.end(), current_id) == + identifier.end()) { + identifier.push_back(current_id); + } + } + } - // Call mergeMatchingSections on all identifiers in the vector - for ( std::vector<std::string>::iterator iter = identifier.begin(); - iter != identifier.end(); - iter++) { - cuobjdumpSectionList = mergeMatchingSections(cuobjdumpSectionList, *iter); - } + // Call mergeMatchingSections on all identifiers in the vector + for (std::vector<std::string>::iterator iter = identifier.begin(); + iter != identifier.end(); iter++) { + cuobjdumpSectionList = mergeMatchingSections(*iter); + } - return cuobjdumpSectionList; + return cuobjdumpSectionList; } - -//! Within the section list, find the ELF section corresponding to a given identifier -cuobjdumpELFSection* findELFSectionInList(std::list<cuobjdumpSection*> sectionlist, const std::string identifier){ - - std::list<cuobjdumpSection*>::iterator iter; - for ( iter = sectionlist.begin(); - iter != sectionlist.end(); - iter++ - ){ - cuobjdumpELFSection* elfsection; - if((elfsection=dynamic_cast<cuobjdumpELFSection*>(*iter)) != NULL){ - if(elfsection->getIdentifier() == identifier) - return elfsection; - } - } - return NULL; +//! Within the section list, find the ELF section corresponding to a given +//! identifier +cuobjdumpELFSection *findELFSectionInList( + std::list<cuobjdumpSection *> sectionlist, const std::string identifier) { + std::list<cuobjdumpSection *>::iterator iter; + for (iter = sectionlist.begin(); iter != sectionlist.end(); iter++) { + cuobjdumpELFSection *elfsection; + if ((elfsection = dynamic_cast<cuobjdumpELFSection *>(*iter)) != NULL) { + if (elfsection->getIdentifier() == identifier) return elfsection; + } + } + return NULL; } //! Find an ELF section in all the known lists -cuobjdumpELFSection* findELFSection(const std::string identifier){ - cuobjdumpELFSection* sec = findELFSectionInList(cuobjdumpSectionList, identifier); - if (sec!=NULL)return sec; - sec = findELFSectionInList(libSectionList, identifier); - if (sec!=NULL)return sec; - std::cout << "Could not find " << identifier << std::endl; - assert(0 && "Could not find the required ELF section"); - return NULL; +cuobjdumpELFSection *cuda_runtime_api::findELFSection( + const std::string identifier) { + cuobjdumpELFSection *sec = + findELFSectionInList(cuobjdumpSectionList, identifier); + if (sec != NULL) return sec; + sec = findELFSectionInList(libSectionList, identifier); + if (sec != NULL) return sec; + std::cout << "Could not find " << identifier << std::endl; + assert(0 && "Could not find the required ELF section"); + return NULL; } -//! Within the section list, find the PTX section corresponding to a given identifier -cuobjdumpPTXSection* findPTXSectionInList(std::list<cuobjdumpSection*> sectionlist, const std::string identifier){ - std::list<cuobjdumpSection*>::iterator iter; - for ( iter = sectionlist.begin(); - iter != sectionlist.end(); - iter++ - ){ - cuobjdumpPTXSection* ptxsection; - if((ptxsection=dynamic_cast<cuobjdumpPTXSection*>(*iter)) != NULL){ - if(ptxsection->getIdentifier() == identifier) - return ptxsection; - else { - extern bool g_cdp_enabled; - if(g_cdp_enabled) { - printf("Warning: __cudaRegisterFatBinary needs %s, but find PTX section with %s\n", - identifier.c_str(), ptxsection->getIdentifier().c_str()); - return ptxsection; - } - } - } - } - return NULL; +//! Within the section list, find the PTX section corresponding to a given +//! identifier +cuobjdumpPTXSection *cuda_runtime_api::findPTXSectionInList( + std::list<cuobjdumpSection *> §ionlist, const std::string identifier) { + std::list<cuobjdumpSection *>::iterator iter; + for (iter = sectionlist.begin(); iter != sectionlist.end(); iter++) { + cuobjdumpPTXSection *ptxsection; + if ((ptxsection = dynamic_cast<cuobjdumpPTXSection *>(*iter)) != NULL) { + if (ptxsection->getIdentifier() == identifier) + return ptxsection; + else { + if (gpgpu_ctx->device_runtime->g_cdp_enabled) { + printf( + "Warning: __cudaRegisterFatBinary needs %s, but find PTX section " + "with %s\n", + identifier.c_str(), ptxsection->getIdentifier().c_str()); + return ptxsection; + } + } + } + } + return NULL; } //! Find an PTX section in all the known lists -cuobjdumpPTXSection* findPTXSection(const std::string identifier){ - cuobjdumpPTXSection* sec = findPTXSectionInList(cuobjdumpSectionList, identifier); - if (sec!=NULL)return sec; - sec = findPTXSectionInList(libSectionList, identifier); - if (sec!=NULL)return sec; - std::cout << "Could not find " << identifier << std::endl; - assert(0 && "Could not find the required PTX section"); - return NULL; +cuobjdumpPTXSection *cuda_runtime_api::findPTXSection( + const std::string identifier) { + cuobjdumpPTXSection *sec = + findPTXSectionInList(cuobjdumpSectionList, identifier); + if (sec != NULL) return sec; + sec = findPTXSectionInList(libSectionList, identifier); + if (sec != NULL) return sec; + std::cout << "Could not find " << identifier << std::endl; + assert(0 && "Could not find the required PTX section"); + return NULL; } - - //! Extract the code using cuobjdump and remove unnecessary sections -void cuobjdumpInit(){ - CUctx_st *context = GPGPUSim_Context(); - extract_code_using_cuobjdump(); //extract all the output of cuobjdump to _cuobjdump_*.* - const char* pre_load = getenv("CUOBJDUMP_SIM_FILE"); - if (pre_load ==NULL || strlen(pre_load)==0){ - cuobjdumpSectionList = pruneSectionList(cuobjdumpSectionList, context); - cuobjdumpSectionList = mergeSections(cuobjdumpSectionList); - } -} - -std::map<int, std::string> fatbinmap; -std::map<int, bool>fatbin_registered; -std::map<std::string, symbol_table*> name_symtab; - -//! Keep track of the association between filename and cubin handle -void cuobjdumpRegisterFatBinary(unsigned int handle, const char* filename){ - fatbinmap[handle] = filename; +void cuda_runtime_api::cuobjdumpInit() { + CUctx_st *context = GPGPUSim_Context(gpgpu_ctx); + extract_code_using_cuobjdump(); // extract all the output of cuobjdump to + // _cuobjdump_*.* + const char *pre_load = getenv("CUOBJDUMP_SIM_FILE"); + if (pre_load == NULL || strlen(pre_load) == 0) { + cuobjdumpSectionList = pruneSectionList(context); + cuobjdumpSectionList = mergeSections(); + } } //! Either submit PTX for simulation or convert SASS to PTXPlus and submit it -void cuobjdumpParseBinary(unsigned int handle){ - - if(fatbin_registered[handle]) return; - fatbin_registered[handle] = true; - CUctx_st *context = GPGPUSim_Context(); - std::string fname = fatbinmap[handle]; +void gpgpu_context::cuobjdumpParseBinary(unsigned int handle) { + CUctx_st *context = GPGPUSim_Context(this); + if (api->fatbin_registered[handle]) return; + api->fatbin_registered[handle] = true; + std::string fname = api->fatbinmap[handle]; - if (name_symtab.find(fname) != name_symtab.end()) { - symbol_table *symtab = name_symtab[fname]; - context->add_binary(symtab, handle); - return; - } - symbol_table *symtab; + if (api->name_symtab.find(fname) != api->name_symtab.end()) { + symbol_table *symtab = api->name_symtab[fname]; + context->add_binary(symtab, handle); + return; + } + symbol_table *symtab; #if (CUDART_VERSION >= 6000) - //loops through all ptx files from smallest sm version to largest - std::map<unsigned,std::set<std::string> >::iterator itr_m; - for (itr_m = version_filename.begin(); itr_m!=version_filename.end(); itr_m++){ - std::set<std::string>::iterator itr_s; - for (itr_s = itr_m->second.begin(); itr_s!=itr_m->second.end(); itr_s++){ - std::string ptx_filename = *itr_s; - printf("GPGPU-Sim PTX: Parsing %s\n",ptx_filename.c_str()); - symtab = gpgpu_ptx_sim_load_ptx_from_filename( ptx_filename.c_str() ); - } - } - name_symtab[fname] = symtab; - context->add_binary(symtab, handle); - load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu()); - load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu()); - for (itr_m = version_filename.begin(); itr_m!=version_filename.end(); itr_m++){ - std::set<std::string>::iterator itr_s; - for (itr_s = itr_m->second.begin(); itr_s!=itr_m->second.end(); itr_s++){ - std::string ptx_filename = *itr_s; - printf("GPGPU-Sim PTX: Loading PTXInfo from %s\n",ptx_filename.c_str()); - gpgpu_ptx_info_load_from_filename( ptx_filename.c_str(), itr_m->first ); - } - } - return; -#endif - - unsigned max_capability = 0; - for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin(); - iter != cuobjdumpSectionList.end(); - iter++){ - unsigned capability = (*iter)->getArch(); - if (capability > max_capability) max_capability = capability; - } - if (max_capability > 20) printf("WARNING: No guarantee that PTX will be parsed for SM version %u\n", max_capability); - if (max_capability == 0) max_capability=context->get_device()->get_gpgpu()->get_config().get_forced_max_capability(); - - cuobjdumpPTXSection* ptx = NULL; - const char* pre_load = getenv("CUOBJDUMP_SIM_FILE"); - if(pre_load==NULL || strlen(pre_load)==0) - ptx = findPTXSection(fname); - char *ptxcode; - const char *override_ptx_name = getenv("PTX_SIM_KERNELFILE"); - if (override_ptx_name == NULL or getenv("PTX_SIM_USE_PTX_FILE") == NULL or strlen(getenv("PTX_SIM_USE_PTX_FILE"))==0) { - ptxcode = readfile(ptx->getPTXfilename()); - } else { - printf("GPGPU-Sim PTX: overriding embedded ptx with '%s' (PTX_SIM_USE_PTX_FILE is set)\n", override_ptx_name); - ptxcode = readfile(override_ptx_name); - } - if(context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus() ) { - cuobjdumpELFSection* elfsection = findELFSection(ptx->getIdentifier()); - assert (elfsection!= NULL); - char *ptxplus_str = gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus( - ptx->getPTXfilename(), - elfsection->getELFfilename(), - elfsection->getSASSfilename()); - symtab=gpgpu_ptx_sim_load_ptx_from_string(ptxplus_str, handle); - printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), handle); - context->add_binary(symtab, handle); - gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability ); - delete[] ptxplus_str; - } else { - symtab=gpgpu_ptx_sim_load_ptx_from_string(ptxcode, handle); - //if CUOBJDUMP_SIM_FILE is not set, ptx is NULL. So comment below. - //printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), handle); - context->add_binary(symtab, handle); - gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability ); - } - load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu()); - load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu()); - name_symtab[fname] = symtab; - - //TODO: Remove temporarily files as per configurations -} - -void** CUDARTAPI __cudaRegisterFatBinary( void *fatCubin ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); + // loops through all ptx files from smallest sm version to largest + std::map<unsigned, std::set<std::string> >::iterator itr_m; + for (itr_m = api->version_filename.begin(); + itr_m != api->version_filename.end(); itr_m++) { + std::set<std::string>::iterator itr_s; + for (itr_s = itr_m->second.begin(); itr_s != itr_m->second.end(); itr_s++) { + std::string ptx_filename = *itr_s; + printf("GPGPU-Sim PTX: Parsing %s\n", ptx_filename.c_str()); + symtab = gpgpu_ptx_sim_load_ptx_from_filename(ptx_filename.c_str()); } -#if (CUDART_VERSION < 2010) - printf("GPGPU-Sim PTX: ERROR ** this version of GPGPU-Sim requires CUDA 2.1 or higher\n"); - exit(1); + } + api->name_symtab[fname] = symtab; + context->add_binary(symtab, handle); + api->load_static_globals(symtab, STATIC_ALLOC_LIMIT, 0xFFFFFFFF, + context->get_device()->get_gpgpu()); + api->load_constants(symtab, STATIC_ALLOC_LIMIT, + context->get_device()->get_gpgpu()); + for (itr_m = api->version_filename.begin(); + itr_m != api->version_filename.end(); itr_m++) { + std::set<std::string>::iterator itr_s; + for (itr_s = itr_m->second.begin(); itr_s != itr_m->second.end(); itr_s++) { + std::string ptx_filename = *itr_s; + printf("GPGPU-Sim PTX: Loading PTXInfo from %s\n", ptx_filename.c_str()); + gpgpu_ptx_info_load_from_filename(ptx_filename.c_str(), itr_m->first); + } + } + return; #endif - CUctx_st *context = GPGPUSim_Context(); - static unsigned next_fat_bin_handle = 1; - if(context->get_device()->get_gpgpu()->get_config().use_cuobjdump()) { - // The following workaround has only been verified on 64-bit systems. - if (sizeof(void*) == 4) - printf("GPGPU-Sim PTX: FatBin file name extraction has not been tested on 32-bit system.\n"); - // This code will get the CUDA version the app was compiled with. - // We need this to determine how to handle the parsing of the binary. - // Making this a runtime variable based on the app, enables GPGPU-Sim compiled - // with a newer version of CUDA to run apps compiled with older versions of - // CUDA. This is especially useful for PTXPLUS execution. - //Skip cuda version check for pytorch application - std::string app_binary_path = get_app_binary(); - int pos = app_binary_path.find("python"); - if (pos==std::string::npos){ - // Not pytorch app : checking cuda version - int app_cuda_version = get_app_cuda_version(); - assert( app_cuda_version == CUDART_VERSION / 1000 && "The app must be compiled with same major version as the simulator." ); - } + unsigned max_capability = 0; + for (std::list<cuobjdumpSection *>::iterator iter = + api->cuobjdumpSectionList.begin(); + iter != api->cuobjdumpSectionList.end(); iter++) { + unsigned capability = (*iter)->getArch(); + if (capability > max_capability) max_capability = capability; + } + if (max_capability > 20) + printf("WARNING: No guarantee that PTX will be parsed for SM version %u\n", + max_capability); + if (max_capability == 0) + max_capability = context->get_device() + ->get_gpgpu() + ->get_config() + .get_forced_max_capability(); - //int app_cuda_version = get_app_cuda_version(); - //assert( app_cuda_version == CUDART_VERSION / 1000 && "The app must be compiled with same major version as the simulator." ); - const char* filename; -#if CUDART_VERSION < 6000 - // FatBin handle from the .fatbin.c file (one of the intermediate files generated by NVCC) - typedef struct {int m; int v; const unsigned long long* d; char* f;} __fatDeviceText __attribute__ ((aligned (8))); - __fatDeviceText * fatDeviceText = (__fatDeviceText *) fatCubin; + cuobjdumpPTXSection *ptx = NULL; + const char *pre_load = getenv("CUOBJDUMP_SIM_FILE"); + if (pre_load == NULL || strlen(pre_load) == 0) + ptx = api->findPTXSection(fname); + char *ptxcode; + const char *override_ptx_name = getenv("PTX_SIM_KERNELFILE"); + if (override_ptx_name == NULL or getenv("PTX_SIM_USE_PTX_FILE") == NULL or + strlen(getenv("PTX_SIM_USE_PTX_FILE")) == 0) { + ptxcode = readfile(ptx->getPTXfilename()); + } else { + printf( + "GPGPU-Sim PTX: overriding embedded ptx with '%s' " + "(PTX_SIM_USE_PTX_FILE is set)\n", + override_ptx_name); + ptxcode = readfile(override_ptx_name); + } + if (context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus()) { + cuobjdumpELFSection *elfsection = api->findELFSection(ptx->getIdentifier()); + assert(elfsection != NULL); + char *ptxplus_str = ptxinfo->gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus( + ptx->getPTXfilename(), elfsection->getELFfilename(), + elfsection->getSASSfilename()); + symtab = gpgpu_ptx_sim_load_ptx_from_string(ptxplus_str, handle); + printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), + handle); + context->add_binary(symtab, handle); + gpgpu_ptxinfo_load_from_string(ptxcode, handle, max_capability, + context->no_of_ptx); + delete[] ptxplus_str; + } else { + symtab = gpgpu_ptx_sim_load_ptx_from_string(ptxcode, handle); + // if CUOBJDUMP_SIM_FILE is not set, ptx is NULL. So comment below. + // printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), + // handle); + context->add_binary(symtab, handle); + gpgpu_ptxinfo_load_from_string(ptxcode, handle, max_capability, + context->no_of_ptx); + } + api->load_static_globals(symtab, STATIC_ALLOC_LIMIT, 0xFFFFFFFF, + context->get_device()->get_gpgpu()); + api->load_constants(symtab, STATIC_ALLOC_LIMIT, + context->get_device()->get_gpgpu()); + api->name_symtab[fname] = symtab; - // Extract the source code file name that generate the given FatBin. - // - Obtains the pointer to the actual fatbin structure from the FatBin handle (fatCubin). - // - An integer inside the fatbin structure contains the relative offset to the source code file name. - // - This offset differs among different CUDA and GCC versions. - char * pfatbin = (char*) fatDeviceText->d; - int offset = *((int*)(pfatbin+48)); - filename = (pfatbin+16+offset); -#else - filename = "default"; -#endif + // TODO: Remove temporarily files as per configurations +} +} - // The extracted file name is associated with a fat_cubin_handle passed - // into cudaLaunch(). Inside cudaLaunch(), the associated file name is - // used to find the PTX/SASS section from cuobjdump, which contains the - // PTX/SASS code for the launched kernel function. - // This allows us to work around the fact that cuobjdump only outputs the - // file name associated with each section. - unsigned long long fat_cubin_handle = next_fat_bin_handle; - next_fat_bin_handle++; - printf("GPGPU-Sim PTX: __cudaRegisterFatBinary, fat_cubin_handle = %llu, filename=%s\n", fat_cubin_handle, filename); - /*! - * This function extracts all data from all files in first call - * then for next calls, only returns the appropriate number - */ - assert(fat_cubin_handle >= 1); - if (fat_cubin_handle==1) cuobjdumpInit(); - cuobjdumpRegisterFatBinary(fat_cubin_handle, filename); +extern "C" { - return (void**)fat_cubin_handle; - } -#if (CUDART_VERSION < 8000) - else { - static unsigned source_num=1; - unsigned long long fat_cubin_handle = next_fat_bin_handle++; - __cudaFatCudaBinary *info = (__cudaFatCudaBinary *)fatCubin; - assert( info->version >= 3 ); - unsigned num_ptx_versions=0; - unsigned max_capability=0; - unsigned selected_capability=0; - bool found=false; - unsigned forced_max_capability = context->get_device()->get_gpgpu()->get_config().get_forced_max_capability(); - if (!info->ptx){ - printf("ERROR: Cannot find ptx code in cubin file\n" - "\tIf you are using CUDA 4.0 or higher, please enable -gpgpu_ptx_use_cuobjdump or downgrade to CUDA 3.1\n"); - exit(1); - } - while( info->ptx[num_ptx_versions].gpuProfileName != NULL ) { - unsigned capability=0; - sscanf(info->ptx[num_ptx_versions].gpuProfileName,"compute_%u",&capability); - printf("GPGPU-Sim PTX: __cudaRegisterFatBinary found PTX versions for '%s', ", info->ident); - printf("capability = %s\n", info->ptx[num_ptx_versions].gpuProfileName ); - if( forced_max_capability ) { - if( capability > max_capability && capability <= forced_max_capability ) { - found = true; - max_capability=capability; - selected_capability = num_ptx_versions; - } - } else { - if( capability > max_capability ) { - found = true; - max_capability=capability; - selected_capability = num_ptx_versions; - } - } - num_ptx_versions++; - } - if( found ) { - printf("GPGPU-Sim PTX: Loading PTX for %s, capability = %s\n", - info->ident, info->ptx[selected_capability].gpuProfileName ); - symbol_table *symtab; - const char *ptx = info->ptx[selected_capability].ptx; - if(context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus() ) { - printf("GPGPU-Sim PTX: ERROR ** PTXPlus is only supported through cuobjdump\n" - "\tEither enable cuobjdump or disable PTXPlus in your configuration file\n"); - exit(1); - } else { - symtab=gpgpu_ptx_sim_load_ptx_from_string(ptx,source_num); - context->add_binary(symtab,fat_cubin_handle); - gpgpu_ptxinfo_load_from_string( ptx, source_num, max_capability ); - } - source_num++; - load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu()); - load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu()); - } else { - printf("GPGPU-Sim PTX: warning -- did not find an appropriate PTX in cubin\n"); - } - return (void**)fat_cubin_handle; - } -#else - else { - printf("ERROR ** __cudaRegisterFatBinary() needs to be updated\n"); - abort(); - } -#endif +void **CUDARTAPI __cudaRegisterFatBinary(void *fatCubin) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return cudaRegisterFatBinaryInternal(fatCubin); } -void __cudaUnregisterFatBinary(void **fatCubinHandle) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - ; +void CUDARTAPI __cudaRegisterFatBinaryEnd(void **fatCubinHandle) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } } -cudaError_t cudaDeviceReset ( void ) { - // Should reset the simulated GPU - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return g_last_cudaError = cudaSuccess; +unsigned CUDARTAPI __cudaPushCallConfiguration(dim3 gridDim, dim3 blockDim, + size_t sharedMem = 0, + struct CUstream_st *stream = 0) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cudaConfigureCallInternal(gridDim, blockDim, sharedMem, stream); } -cudaError_t CUDARTAPI cudaDeviceSynchronize(void){ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //Blocks until the device has completed all preceding requested tasks - synchronize(); - return g_last_cudaError = cudaSuccess; + +cudaError_t CUDARTAPI __cudaPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, + size_t *sharedMem, + void *stream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return g_last_cudaError = cudaSuccess; } -void CUDARTAPI __cudaRegisterFunction( - void **fatCubinHandle, - const char *hostFun, - char *deviceFun, - const char *deviceName, - int thread_limit, - uint3 *tid, - uint3 *bid, - dim3 *bDim, - dim3 *gDim -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - unsigned fat_cubin_handle = (unsigned)(unsigned long long)fatCubinHandle; - printf("GPGPU-Sim PTX: __cudaRegisterFunction %s : hostFun 0x%p, fat_cubin_handle = %u\n", - deviceFun, hostFun, fat_cubin_handle); - if(context->get_device()->get_gpgpu()->get_config().use_cuobjdump()) - cuobjdumpParseBinary(fat_cubin_handle); - context->register_function( fat_cubin_handle, hostFun, deviceFun ); +void CUDARTAPI __cudaRegisterFunction(void **fatCubinHandle, + const char *hostFun, char *deviceFun, + const char *deviceName, int thread_limit, + uint3 *tid, uint3 *bid, dim3 *bDim, + dim3 *gDim) { + cudaRegisterFunctionInternal(fatCubinHandle, hostFun, deviceFun, deviceName, + thread_limit, tid, bid, bDim, gDim); } extern void __cudaRegisterVar( - void **fatCubinHandle, - char *hostVar, //pointer to...something - char *deviceAddress, //name of variable - const char *deviceName, //name of variable (same as above) - int ext, - int size, - int constant, - int global ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: __cudaRegisterVar: hostVar = %p; deviceAddress = %s; deviceName = %s\n", hostVar, deviceAddress, deviceName); - printf("GPGPU-Sim PTX: __cudaRegisterVar: Registering const memory space of %d bytes\n", size); - if(GPGPUSim_Context()->get_device()->get_gpgpu()->get_config().use_cuobjdump()) - cuobjdumpParseBinary((unsigned)(unsigned long long)fatCubinHandle); - fflush(stdout); - if ( constant && !global && !ext ) { - gpgpu_ptx_sim_register_const_variable(hostVar,deviceName,size); - } else if ( !constant && !global && !ext ) { - gpgpu_ptx_sim_register_global_variable(hostVar,deviceName,size); - } else cuda_not_implemented(__my_func__,__LINE__); + void **fatCubinHandle, + char *hostVar, // pointer to...something + char *deviceAddress, // name of variable + const char *deviceName, // name of variable (same as above) + int ext, int size, int constant, int global) { + cudaRegisterVarInternal(fatCubinHandle, hostVar, deviceAddress, deviceName, + ext, size, constant, global); } - -void __cudaRegisterShared( - void **fatCubinHandle, - void **devicePtr -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - // we don't do anything here - printf("GPGPU-Sim PTX: __cudaRegisterShared\n" ); +__host__ cudaError_t CUDARTAPI cudaConfigureCall(dim3 gridDim, dim3 blockDim, + size_t sharedMem, + cudaStream_t stream) { + return cudaConfigureCallInternal(gridDim, blockDim, sharedMem, stream); } -void CUDARTAPI __cudaRegisterSharedVar( - void **fatCubinHandle, - void **devicePtr, - size_t size, - size_t alignment, - int storage -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - // we don't do anything here - printf("GPGPU-Sim PTX: __cudaRegisterSharedVar\n" ); +void __cudaUnregisterFatBinary(void **fatCubinHandle) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } } -void __cudaRegisterTexture( - void **fatCubinHandle, - const struct textureReference *hostVar, - const void **deviceAddress, - const char *deviceName, - int dim, - int norm, - int ext -) //passes in a newly created textureReference -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - std::string devStr (deviceName); - #if (CUDART_VERSION > 4020) - if (devStr.size() > 2 && devStr.data()[0] == ':' && devStr.data()[1] == ':') - devStr = devStr.replace(0, 2, ""); - #endif - CUctx_st *context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - printf("GPGPU-Sim PTX: in __cudaRegisterTexture:\n"); - gpu->gpgpu_ptx_sim_bindNameToTexture(devStr.data(), hostVar, dim, norm, ext); - printf("GPGPU-Sim PTX: int dim = %d\n", dim); - printf("GPGPU-Sim PTX: int norm = %d\n", norm); - printf("GPGPU-Sim PTX: int ext = %d\n", ext); - printf("GPGPU-Sim PTX: Execution warning: Not finished implementing \"%s\"\n", __my_func__ ); +cudaError_t cudaDeviceReset(void) { + // Should reset the simulated GPU + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return g_last_cudaError = cudaSuccess; } - -char __cudaInitModule( - void **fatCubinHandle -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +cudaError_t CUDARTAPI cudaDeviceSynchronize(void) { + return cudaDeviceSynchronizeInternal(); } - -#ifndef OPENGL_SUPPORT -typedef unsigned long GLuint; -#endif - -cudaError_t cudaGLRegisterBufferObject(GLuint bufferObj) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", __my_func__ ); - return g_last_cudaError = cudaSuccess; +void __cudaRegisterShared(void **fatCubinHandle, void **devicePtr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // we don't do anything here + printf("GPGPU-Sim PTX: __cudaRegisterShared\n"); } -struct glbmap_entry { - GLuint m_bufferObj; - void *m_devPtr; - size_t m_size; - struct glbmap_entry *m_next; -}; -typedef struct glbmap_entry glbmap_entry_t; - -glbmap_entry_t* g_glbmap = NULL; +void CUDARTAPI __cudaRegisterSharedVar(void **fatCubinHandle, void **devicePtr, + size_t size, size_t alignment, + int storage) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // we don't do anything here + printf("GPGPU-Sim PTX: __cudaRegisterSharedVar\n"); +} -cudaError_t cudaGLMapBufferObject(void** devPtr, GLuint bufferObj) +void __cudaRegisterTexture( + void **fatCubinHandle, const struct textureReference *hostVar, + const void **deviceAddress, const char *deviceName, int dim, int norm, + int ext) // passes in a newly created textureReference { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -#ifdef OPENGL_SUPPORT - GLint buffer_size=0; - CUctx_st* ctx = GPGPUSim_Context(); - - glbmap_entry_t *p = g_glbmap; - while ( p && p->m_bufferObj != bufferObj ) - p = p->m_next; - if ( p == NULL ) { - glBindBuffer(GL_ARRAY_BUFFER,bufferObj); - glGetBufferParameteriv(GL_ARRAY_BUFFER,GL_BUFFER_SIZE,&buffer_size); - assert( buffer_size != 0 ); - *devPtr = ctx->get_device()->get_gpgpu()->gpu_malloc(buffer_size); - - // create entry and insert to front of list - glbmap_entry_t *n = (glbmap_entry_t *) calloc(1,sizeof(glbmap_entry_t)); - n->m_next = g_glbmap; - g_glbmap = n; - - // initialize entry - n->m_bufferObj = bufferObj; - n->m_devPtr = *devPtr; - n->m_size = buffer_size; - - p = n; - } else { - buffer_size = p->m_size; - *devPtr = p->m_devPtr; - } - - if ( *devPtr ) { - char *data = (char *) calloc(p->m_size,1); - glGetBufferSubData(GL_ARRAY_BUFFER,0,buffer_size,data); - memcpy_to_gpu( (size_t) *devPtr, data, buffer_size ); - free(data); - printf("GPGPU-Sim PTX: cudaGLMapBufferObject %zu bytes starting at 0x%llx..\n", (size_t)buffer_size, - (unsigned long long) *devPtr); - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } + __cudaRegisterTextureInternal(fatCubinHandle, hostVar, deviceAddress, + deviceName, dim, norm, ext); +} - return g_last_cudaError = cudaSuccess; -#else - fflush(stdout); - fflush(stderr); - printf("GPGPU-Sim PTX: GPGPU-Sim support for OpenGL integration disabled -- exiting\n"); - fflush(stdout); - exit(50); -#endif +char __cudaInitModule(void **fatCubinHandle) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -cudaError_t cudaGLUnmapBufferObject(GLuint bufferObj) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } -#ifdef OPENGL_SUPPORT - glbmap_entry_t *p = g_glbmap; - while ( p && p->m_bufferObj != bufferObj ) - p = p->m_next; - if ( p == NULL ) - return g_last_cudaError = cudaErrorUnknown; +cudaError_t cudaGLRegisterBufferObject(GLuint bufferObj) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", + __my_func__); + return g_last_cudaError = cudaSuccess; +} - char *data = (char *) calloc(p->m_size,1); - memcpy_from_gpu( data,(size_t)p->m_devPtr,p->m_size ); - glBufferSubData(GL_ARRAY_BUFFER,0,p->m_size,data); - free(data); +cudaError_t cudaGLMapBufferObject(void **devPtr, GLuint bufferObj) { + return cudaGLMapBufferObjectInternal(devPtr, bufferObj); +} - return g_last_cudaError = cudaSuccess; -#else - fflush(stdout); - fflush(stderr); - printf("GPGPU-Sim PTX: support for OpenGL integration disabled -- exiting\n"); - fflush(stdout); - exit(50); -#endif +cudaError_t cudaGLUnmapBufferObject(GLuint bufferObj) { + return cudaGLUnmapBufferObjectInternal(bufferObj); } -cudaError_t cudaGLUnregisterBufferObject(GLuint bufferObj) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", __my_func__ ); - return g_last_cudaError = cudaSuccess; +cudaError_t cudaGLUnregisterBufferObject(GLuint bufferObj) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", + __my_func__); + return g_last_cudaError = cudaSuccess; } #if (CUDART_VERSION >= 2010) -cudaError_t CUDARTAPI cudaHostAlloc(void **pHost, size_t bytes, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *pHost = malloc(bytes); - //need to track the size allocated so that cudaHostGetDevicePointer() can function properly. - //TODO: vary this function behavior based on flags value (following nvidia documentation) - pinned_memory_size[*pHost]=bytes; - if( *pHost ) - return g_last_cudaError = cudaSuccess; - else - return g_last_cudaError = cudaErrorMemoryAllocation; -} - -cudaError_t CUDARTAPI cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //only cpu memory allocation happens in cudaHostAlloc. Linking with device pointer to pinned memory happens here. - //TODO: once kernel is executed, the contents in global pointer of GPU must be copied back to CPU host pointer! - flags=0; - CUctx_st* context = GPGPUSim_Context(); - gpgpu_t *gpu = context->get_device()->get_gpgpu(); - std::map<void *, size_t>::const_iterator i = pinned_memory_size.find(pHost); - assert(i != pinned_memory_size.end()); - size_t size = i->second; - *pDevice = gpu->gpu_malloc(size); - if(g_debug_execution >= 3){ - printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n",size, (unsigned long long) *pDevice); - g_mallocPtr_Size[(unsigned long long)*pDevice] = size; - } - if ( *pDevice ) { - pinned_memory[pHost]=pDevice; - //Copy contents in cpu to gpu - gpu->memcpy_to_gpu((size_t)*pDevice,pHost,size); - return g_last_cudaError = cudaSuccess; - } else { - return g_last_cudaError = cudaErrorMemoryAllocation; - } +cudaError_t CUDARTAPI cudaHostAlloc(void **pHost, size_t bytes, + unsigned int flags) { + return cudaHostAllocInternal(pHost, bytes, flags); } -__host__ cudaError_t CUDARTAPI cudaPointerGetAttributes( - cudaPointerAttributes *attributes, - const void *ptr -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +cudaError_t CUDARTAPI cudaHostGetDevicePointer(void **pDevice, void *pHost, + unsigned int flags) { + return cudaHostGetDevicePointerInternal(pDevice, pHost, flags); } -__host__ cudaError_t CUDARTAPI cudaDeviceCanAccessPeer( - int *canAccessPeer, - int device, - int peerDevice -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI +cudaPointerGetAttributes(cudaPointerAttributes *attributes, const void *ptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -__host__ cudaError_t CUDARTAPI cudaDeviceEnablePeerAccess( - int peerDevice, - unsigned int flags -) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaDeviceCanAccessPeer(int *canAccessPeer, + int device, + int peerDevice) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -cudaError_t CUDARTAPI cudaSetValidDevices(int *device_arr, int len) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +__host__ cudaError_t CUDARTAPI cudaDeviceEnablePeerAccess(int peerDevice, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -cudaError_t CUDARTAPI cudaSetDeviceFlags( int flags ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - // This flag is implicitly always on (unless you are using the driver API). It is safe for GPGPU-Sim to - // just ignore it. - if ( cudaDeviceMapHost == flags ) { - return g_last_cudaError = cudaSuccess; - } else { - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; - } +cudaError_t CUDARTAPI cudaSetValidDevices(int *device_arr, int len) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -size_t getMaxThreadsPerBlock(struct cudaFuncAttributes *attr) { - _cuda_device_id *dev = GPGPUSim_Init(); - struct cudaDeviceProp prop; - - prop = *dev->get_prop(); - - size_t max = prop.maxThreadsPerBlock; - - if ((prop.regsPerBlock / attr->numRegs) < max) - max = prop.regsPerBlock / attr->numRegs; - - return max; +cudaError_t CUDARTAPI cudaSetDeviceFlags(int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // This flag is implicitly always on (unless you are using the driver API). It + // is safe for GPGPU-Sim to just ignore it. + if (cudaDeviceMapHost == flags) { + return g_last_cudaError = cudaSuccess; + } else { + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; + } } -cudaError_t CUDARTAPI cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const char *hostFun ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - function_info *entry = context->get_kernel(hostFun); - if( entry ) { - const struct gpgpu_ptx_sim_info *kinfo = entry->get_kernel_info(); - attr->sharedSizeBytes = kinfo->smem; - attr->constSizeBytes = kinfo->cmem; - attr->localSizeBytes = kinfo->lmem; - attr->numRegs = kinfo->regs; - if(kinfo->maxthreads > 0) - attr->maxThreadsPerBlock = kinfo->maxthreads; - else - attr->maxThreadsPerBlock = getMaxThreadsPerBlock(attr); -#if CUDART_VERSION >= 3000 - attr->ptxVersion = kinfo->ptx_version; - attr->binaryVersion = kinfo->sm_target; -#endif - } - return g_last_cudaError = cudaSuccess; +cudaError_t CUDARTAPI cudaFuncGetAttributes(struct cudaFuncAttributes *attr, + const char *hostFun) { + return cudaFuncGetAttributesInternal(attr, hostFun); } cudaError_t CUDARTAPI cudaEventCreateWithFlags(cudaEvent_t *event, int flags) { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUevent_st *e = new CUevent_st(flags==cudaEventBlockingSync); - g_timer_events[e->get_uid()] = e; + CUevent_st *e = new CUevent_st(flags==cudaEventBlockingSync); + g_timer_events[e->get_uid()] = e; #if CUDART_VERSION >= 3000 - *event = e; + *event = e; #else - *event = e->get_uid(); + *event = e->get_uid(); #endif - return g_last_cudaError = cudaSuccess; + return g_last_cudaError = cudaSuccess; } -cudaError_t CUDARTAPI cudaDriverGetVersion(int *driverVersion) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *driverVersion = CUDART_VERSION; - return g_last_cudaError = cudaSuccess; +cudaError_t CUDARTAPI cudaDriverGetVersion(int *driverVersion) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *driverVersion = CUDART_VERSION; + return g_last_cudaError = cudaSuccess; } -cudaError_t CUDARTAPI cudaRuntimeGetVersion(int *runtimeVersion) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *runtimeVersion = CUDART_VERSION; - return g_last_cudaError = cudaSuccess; +cudaError_t CUDARTAPI cudaRuntimeGetVersion(int *runtimeVersion) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *runtimeVersion = CUDART_VERSION; + return g_last_cudaError = cudaSuccess; } #if CUDART_VERSION >= 3000 -__host__ cudaError_t CUDARTAPI cudaFuncSetCacheConfig(const char *func, enum cudaFuncCache cacheConfig ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - CUctx_st *context = GPGPUSim_Context(); - context->get_device()->get_gpgpu()->set_cache_config(context->get_kernel(func)->get_name(), (FuncCache)cacheConfig); - return g_last_cudaError = cudaSuccess; +__host__ cudaError_t CUDARTAPI +cudaFuncSetCacheConfig(const char *func, enum cudaFuncCache cacheConfig) { + return cudaFuncSetCacheConfigInternal(func, cacheConfig); } -//Jin: hack for cdp -__host__ cudaError_t CUDARTAPI cudaDeviceSetLimit(enum cudaLimit limit, size_t value) { - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - return g_last_cudaError = cudaSuccess; +// Jin: hack for cdp +__host__ cudaError_t CUDARTAPI cudaDeviceSetLimit(enum cudaLimit limit, + size_t value) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + return g_last_cudaError = cudaSuccess; } +//#if CUDART_VERSION >= 9000 +//__host__ cudaError_t cudaFuncSetAttribute ( const void* func, enum +// cudaFuncAttribute attr, int value ) { + +// ignore this Attribute for now, and the default is that carveout = +// cudaSharedmemCarveoutDefault; // (-1) +// return g_last_cudaError = cudaSuccess; +//} #endif #endif -cudaError_t CUDARTAPI cudaGLSetGLDevice(int device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", __my_func__ ); - return g_last_cudaError = cudaErrorUnknown; +#if CUDART_VERSION >= 9000 +/** + * \brief Set attributes for a given function + * + * This function sets the attributes of a function specified via \p entry. + * The parameter \p entry must be a pointer to a function that executes + * on the device. The parameter specified by \p entry must be declared as a \p + * __global__ function. The enumeration defined by \p attr is set to the value + * defined by \p value If the specified function does not exist, then + * ::cudaErrorInvalidDeviceFunction is returned. If the specified attribute + * cannot be written, or if the value is incorrect, then ::cudaErrorInvalidValue + * is returned. + * + * Valid values for \p attr are: + * ::cuFuncAttrMaxDynamicSharedMem - Maximum size of dynamic shared memory per + * block + * ::cudaFuncAttributePreferredSharedMemoryCarveout - Preferred shared memory-L1 + * cache split ratio + * + * \param entry - Function to get attributes of + * \param attr - Attribute to set + * \param value - Value to set + * + * \return + * ::cudaSuccess, + * ::cudaErrorInitializationError, + * ::cudaErrorInvalidDeviceFunction, + * ::cudaErrorInvalidValue + * \notefnerr + * + * \ref ::cudaLaunchKernel(const T *func, dim3 gridDim, dim3 blockDim, void + * **args, size_t sharedMem, cudaStream_t stream) "cudaLaunchKernel (C++ API)", + * \ref ::cudaFuncSetCacheConfig(T*, enum cudaFuncCache) "cudaFuncSetCacheConfig + * (C++ API)", \ref ::cudaFuncGetAttributes(struct cudaFuncAttributes*, const + * void*) "cudaFuncGetAttributes (C API)", + * ::cudaSetDoubleForDevice, + * ::cudaSetDoubleForHost, + * \ref ::cudaSetupArgument(T, size_t) "cudaSetupArgument (C++ API)" + */ +cudaError_t CUDARTAPI cudaFuncSetAttribute(const void *func, + enum cudaFuncAttribute attr, + int value) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf( + "GPGPU-Sim PTX: Execution warning: ignoring call to \"%s ( func=%p, " + "attr=%d, value=%d )\"\n", + __my_func__, func, attr, value); + return g_last_cudaError = cudaSuccess; } +#endif -typedef void* HGPUNV; - -cudaError_t CUDARTAPI cudaWGLGetDevice(int *device, HGPUNV hGpu) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaErrorUnknown; +cudaError_t CUDARTAPI cudaGLSetGLDevice(int device) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: Execution warning: ignoring call to \"%s\"\n", + __my_func__); + return g_last_cudaError = cudaErrorUnknown; } -void CUDARTAPI __cudaMutexOperation(int lock) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); +typedef void *HGPUNV; + +cudaError_t CUDARTAPI cudaWGLGetDevice(int *device, HGPUNV hGpu) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaErrorUnknown; } -void CUDARTAPI __cudaTextureFetch(const void *tex, void *index, int integer, void *val) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); +void CUDARTAPI __cudaMutexOperation(int lock) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); } +void CUDARTAPI __cudaTextureFetch(const void *tex, void *index, int integer, + void *val) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); +} } namespace cuda_math { -void CUDARTAPI __cudaMutexOperation(int lock) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); +void CUDARTAPI __cudaMutexOperation(int lock) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); } -void CUDARTAPI __cudaTextureFetch(const void *tex, void *index, int integer, void *val) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); +void CUDARTAPI __cudaTextureFetch(const void *tex, void *index, int integer, + void *val) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); } -int CUDARTAPI __cudaSynchronizeThreads(void**, void*) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //TODO This function should syncronize if we support Asyn kernel calls - return g_last_cudaError = cudaSuccess; +int CUDARTAPI __cudaSynchronizeThreads(void **, void *) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // TODO This function should syncronize if we support Asyn kernel calls + return g_last_cudaError = cudaSuccess; } -} +} // namespace cuda_math //////// -extern int ptx_parse(); -extern int ptx__scan_string(const char*); -extern FILE *ptx_in; - -extern int ptxinfo_parse(); -extern int ptxinfo_debug; -extern FILE *ptxinfo_in; - /// static functions -static int load_static_globals( symbol_table *symtab, unsigned min_gaddr, unsigned max_gaddr, gpgpu_t *gpu ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf( "GPGPU-Sim PTX: loading globals with explicit initializers... \n" ); - fflush(stdout); - int ng_bytes=0; - symbol_table::iterator g=symtab->global_iterator_begin(); - - for ( ; g!=symtab->global_iterator_end(); g++) { - symbol *global = *g; - if ( global->has_initializer() ) { - printf( "GPGPU-Sim PTX: initializing '%s' ... ", global->name().c_str() ); - unsigned addr=global->get_address(); - const type_info *type = global->type(); - type_info_key ti=type->get_key(); - size_t size; - int t; - ti.type_decode(size,t); - int nbytes = size/8; - int offset=0; - std::list<operand_info> init_list = global->get_initializer(); - for ( std::list<operand_info>::iterator i=init_list.begin(); i!=init_list.end(); i++ ) { - operand_info op = *i; - ptx_reg_t value = op.get_literal_value(); - assert( (addr+offset+nbytes) < min_gaddr ); // min_gaddr is start of "heap" for cudaMalloc - gpu->get_global_memory()->write(addr+offset,nbytes,&value,NULL,NULL); // assuming little endian here - offset+=nbytes; - ng_bytes+=nbytes; - } - printf(" wrote %u bytes\n", offset ); - } - } - printf( "GPGPU-Sim PTX: finished loading globals (%u bytes total).\n", ng_bytes ); - fflush(stdout); - return ng_bytes; -} +int cuda_runtime_api::load_static_globals(symbol_table *symtab, + unsigned min_gaddr, + unsigned max_gaddr, gpgpu_t *gpu) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: loading globals with explicit initializers... \n"); + fflush(stdout); + int ng_bytes = 0; + symbol_table::iterator g = symtab->global_iterator_begin(); -static int load_constants( symbol_table *symtab, addr_t min_gaddr, gpgpu_t *gpu ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); + for (; g != symtab->global_iterator_end(); g++) { + symbol *global = *g; + if (global->has_initializer()) { + printf("GPGPU-Sim PTX: initializing '%s' ... ", + global->name().c_str()); + unsigned addr = global->get_address(); + const type_info *type = global->type(); + type_info_key ti = type->get_key(); + size_t size; + int t; + ti.type_decode(size, t); + int nbytes = size / 8; + int offset = 0; + std::list<operand_info> init_list = global->get_initializer(); + for (std::list<operand_info>::iterator i = init_list.begin(); + i != init_list.end(); i++) { + operand_info op = *i; + ptx_reg_t value = op.get_literal_value(); + assert((addr + offset + nbytes) < + min_gaddr); // min_gaddr is start of "heap" for cudaMalloc + gpu->get_global_memory()->write(addr + offset, nbytes, &value, NULL, + NULL); // assuming little endian here + offset += nbytes; + ng_bytes += nbytes; + } + printf(" wrote %u bytes\n", offset); } - printf( "GPGPU-Sim PTX: loading constants with explicit initializers... " ); - fflush(stdout); - int nc_bytes = 0; - symbol_table::iterator g=symtab->const_iterator_begin(); + } + printf("GPGPU-Sim PTX: finished loading globals (%u bytes total).\n", + ng_bytes); + fflush(stdout); + return ng_bytes; +} - for ( ; g!=symtab->const_iterator_end(); g++) { - symbol *constant = *g; - if ( constant->is_const() && constant->has_initializer() ) { +int cuda_runtime_api::load_constants(symbol_table *symtab, addr_t min_gaddr, + gpgpu_t *gpu) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("GPGPU-Sim PTX: loading constants with explicit initializers... "); + fflush(stdout); + int nc_bytes = 0; + symbol_table::iterator g = symtab->const_iterator_begin(); - // get the constant element data size - int basic_type; - size_t num_bits; - constant->type()->get_key().type_decode(num_bits,basic_type); + for (; g != symtab->const_iterator_end(); g++) { + symbol *constant = *g; + if (constant->is_const() && constant->has_initializer()) { + // get the constant element data size + int basic_type; + size_t num_bits; + constant->type()->get_key().type_decode(num_bits, basic_type); - std::list<operand_info> init_list = constant->get_initializer(); - int nbytes_written = 0; - for ( std::list<operand_info>::iterator i=init_list.begin(); i!=init_list.end(); i++ ) { - operand_info op = *i; - ptx_reg_t value = op.get_literal_value(); - int nbytes = num_bits/8; - switch ( op.get_type() ) { - case int_t: assert(nbytes >= 1); break; - case float_op_t: assert(nbytes == 4); break; - case double_op_t: assert(nbytes >= 4); break; // account for double DEMOTING - default: - abort(); - } - unsigned addr=constant->get_address() + nbytes_written; - assert( addr+nbytes < min_gaddr ); + std::list<operand_info> init_list = constant->get_initializer(); + int nbytes_written = 0; + for (std::list<operand_info>::iterator i = init_list.begin(); + i != init_list.end(); i++) { + operand_info op = *i; + ptx_reg_t value = op.get_literal_value(); + int nbytes = num_bits / 8; + switch (op.get_type()) { + case int_t: + assert(nbytes >= 1); + break; + case float_op_t: + assert(nbytes == 4); + break; + case double_op_t: + assert(nbytes >= 4); + break; // account for double DEMOTING + default: + abort(); + } + unsigned addr = constant->get_address() + nbytes_written; + assert(addr + nbytes < min_gaddr); - gpu->get_global_memory()->write(addr,nbytes,&value,NULL,NULL); // assume little endian (so u8 is the first byte in u32) - nc_bytes+=nbytes; - nbytes_written += nbytes; - } - } - } - printf( " done.\n"); - fflush(stdout); - return nc_bytes; + gpu->get_global_memory()->write( + addr, nbytes, &value, NULL, + NULL); // assume little endian (so u8 is the first byte in u32) + nc_bytes += nbytes; + nbytes_written += nbytes; + } + } + } + printf(" done.\n"); + fflush(stdout); + return nc_bytes; } -kernel_info_t *gpgpu_cuda_ptx_sim_init_grid( const char *hostFun, - gpgpu_ptx_sim_arg_list_t args, - struct dim3 gridDim, - struct dim3 blockDim, - CUctx_st* context ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - function_info *entry = context->get_kernel(hostFun); - gpgpu_t* gpu= context->get_device()->get_gpgpu(); - /* - Passing a snapshot of the GPU's current texture mapping to the kernel's info - as kernels should use texture bindings present at the time of their launch. - */ - kernel_info_t *result = new kernel_info_t(gridDim,blockDim,entry,gpu->getNameArrayMapping(),gpu->getNameInfoMapping()); - if( entry == NULL ) { - printf("GPGPU-Sim PTX: ERROR launching kernel -- no PTX implementation found for %p\n", hostFun); - abort(); - } - unsigned argcount=args.size(); - unsigned argn=1; - for( gpgpu_ptx_sim_arg_list_t::iterator a = args.begin(); a != args.end(); a++ ) { - entry->add_param_data(argcount-argn,&(*a)); - argn++; - } +kernel_info_t *cuda_runtime_api::gpgpu_cuda_ptx_sim_init_grid( + const char *hostFun, gpgpu_ptx_sim_arg_list_t args, struct dim3 gridDim, + struct dim3 blockDim, CUctx_st *context) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + function_info *entry = context->get_kernel(hostFun); + gpgpu_t *gpu = context->get_device()->get_gpgpu(); + /* + Passing a snapshot of the GPU's current texture mapping to the kernel's info + as kernels should use texture bindings present at the time of their launch. + */ + kernel_info_t *result = + new kernel_info_t(gridDim, blockDim, entry, gpu->getNameArrayMapping(), + gpu->getNameInfoMapping()); + if (entry == NULL) { + printf( + "GPGPU-Sim PTX: ERROR launching kernel -- no PTX implementation found " + "for %p\n", + hostFun); + abort(); + } + unsigned argcount = args.size(); + unsigned argn = 1; + for (gpgpu_ptx_sim_arg_list_t::iterator a = args.begin(); a != args.end(); + a++) { + entry->add_param_data(argcount - argn, &(*a)); + argn++; + } - entry->finalize(result->get_param_memory()); - g_ptx_kernel_count++; - fflush(stdout); - - if(g_debug_execution >= 4){ - entry->ptx_jit_config(g_mallocPtr_Size, result->get_param_memory(), (gpgpu_t *) context->get_device()->get_gpgpu(), gridDim, blockDim); - } + entry->finalize(result->get_param_memory()); + gpgpu_ctx->func_sim->g_ptx_kernel_count++; + fflush(stdout); + + if (g_debug_execution >= 4) { + entry->ptx_jit_config(g_mallocPtr_Size, result->get_param_memory(), + (gpgpu_t *)context->get_device()->get_gpgpu(), + gridDim, blockDim); + } - return result; + return result; } /******************************************************************************* @@ -3449,2948 +4096,2912 @@ kernel_info_t *gpgpu_cuda_ptx_sim_init_grid( const char *hostFun, *******************************************************************************/ //***extra api for pytorch*** -CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGetErrorString(CUresult error, const char **pStr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGetErrorName(CUresult error, const char **pStr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuInit(unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuInit(unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDriverGetVersion(int *driverVersion) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cudaError_t e = cudaDriverGetVersion(driverVersion); - assert(e == cudaSuccess); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDriverGetVersion(int *driverVersion) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cudaError_t e = cudaDriverGetVersion(driverVersion); + assert(e == cudaSuccess); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - int deviceI = -1; - cudaError_t e = cudaGetDevice(&deviceI); - assert(e == cudaSuccess); - assert(deviceI!=-1); - *device = deviceI; - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGet(CUdevice *device, int ordinal) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + int deviceI = -1; + cudaError_t e = cudaGetDevice(&deviceI); + assert(e == cudaSuccess); + assert(deviceI != -1); + *device = deviceI; + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceGetCount(int *count) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cudaError_t e = cudaGetDeviceCount(count); - assert(e == cudaSuccess); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetCount(int *count) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cudaError_t e = cudaGetDeviceCount(count); + assert(e == cudaSuccess); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - assert(len>=10); - strcpy(name, "GPGPU-Sim"); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetName(char *name, int len, CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + assert(len >= 10); + strcpy(name, "GPGPU-Sim"); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - *bytes = 20000000000;//dummy value - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceTotalMem(size_t *bytes, CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + *bytes = 20000000000; // dummy value + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ #if (CUDART_VERSION > 5000) -CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cudaError_t e = cudaDeviceGetAttribute(pi, (cudaDeviceAttr)attrib, dev); - assert(e == cudaSuccess); +CUresult CUDAAPI cuDeviceGetAttribute(int *pi, CUdevice_attribute attrib, + CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cudaError_t e = cudaDeviceGetAttribute(pi, (cudaDeviceAttr)attrib, dev); + assert(e == cudaSuccess); - return CUDA_SUCCESS; + return CUDA_SUCCESS; } #endif -CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetProperties(CUdevprop *prop, CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceComputeCapability(int *major, int *minor, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceComputeCapability(int *major, int *minor, + CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 7000 -CUresult CUDAAPI cuDevicePrimaryCtxRetain(CUcontext *pctx, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDevicePrimaryCtxRetain(CUcontext *pctx, CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDevicePrimaryCtxRelease(CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, int *active) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int *flags, + int *active) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDevicePrimaryCtxReset(CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 7000 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxCreate(CUcontext *pctx, unsigned int flags, + CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuCtxDestroy(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxDestroy(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxSetCurrent(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetCurrent(CUcontext *pctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ -CUresult CUDAAPI cuCtxGetDevice(CUdevice *device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetDevice(CUdevice *device) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 7000 -CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetFlags(unsigned int *flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 7000 */ -CUresult CUDAAPI cuCtxSynchronize(void) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxSynchronize(void) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxSetLimit(CUlimit limit, size_t value) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetLimit(size_t *pvalue, CUlimit limit) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetCacheConfig(CUfunc_cache *pconfig) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxSetCacheConfig(CUfunc_cache config) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 4020 -CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetSharedMemConfig(CUsharedconfig *pConfig) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxSetSharedMemConfig(CUsharedconfig config) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif -CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetApiVersion(CUcontext ctx, unsigned int *version) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, int *greatestPriority) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxGetStreamPriorityRange(int *leastPriority, + int *greatestPriority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxAttach(CUcontext *pctx, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxDetach(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxDetach(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleLoad(CUmodule *module, const char *fname) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleLoad(CUmodule *module, const char *fname) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleLoadData(CUmodule *module, const void *image) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, unsigned int numOptions, CUjit_option *options, void **optionValues) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleLoadDataEx(CUmodule *module, const void *image, + unsigned int numOptions, + CUjit_option *options, + void **optionValues) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleLoadFatBinary(CUmodule *module, const void *fatCubin) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleLoadFatBinary(CUmodule *module, const void *fatCubin) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleUnload(CUmodule hmod) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleUnload(CUmodule hmod) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, const char *name) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleGetFunction(CUfunction *hfunc, CUmodule hmod, + const char *name) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char *name) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleGetGlobal(CUdeviceptr *dptr, size_t *bytes, + CUmodule hmod, const char *name) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, const char *name) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleGetTexRef(CUtexref *pTexRef, CUmodule hmod, + const char *name) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, const char *name) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuModuleGetSurfRef(CUsurfref *pSurfRef, CUmodule hmod, + const char *name) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 6050 -CUresult CUDAAPI -cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues, CUlinkState *stateOut) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //currently do not support options or multiple CUlinkStates - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options, + void **optionValues, CUlinkState *stateOut) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // currently do not support options or multiple CUlinkStates + return CUDA_SUCCESS; } -CUresult CUDAAPI -cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, const char *name, - unsigned int numOptions, CUjit_option *options, void **optionValues) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - assert(type==CU_JIT_INPUT_PTX); - cuda_not_implemented(__my_func__,__LINE__); - return CUDA_ERROR_UNKNOWN; +CUresult CUDAAPI cuLinkAddData(CUlinkState state, CUjitInputType type, + void *data, size_t size, const char *name, + unsigned int numOptions, CUjit_option *options, + void **optionValues) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + assert(type == CU_JIT_INPUT_PTX); + cuda_not_implemented(__my_func__, __LINE__); + return CUDA_ERROR_UNKNOWN; } -CUresult CUDAAPI -cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path, - unsigned int numOptions, CUjit_option *options, void **optionValues) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - static bool addedFile = false; - if (addedFile){ - printf("GPGPU-Sim PTX: ERROR: cuLinkAddFile does not support multiple files\n"); - abort(); - } - - //blocking - assert(type==CU_JIT_INPUT_PTX); - CUctx_st *context = GPGPUSim_Context(); - char *file = getenv("PTX_JIT_PATH"); - if(file==NULL){ - printf("GPGPU-Sim PTX: ERROR: PTX_JIT_PATH has not been set\n"); - abort(); - } - strcat(file,"/"); - strcat(file,path); - symbol_table *symtab = gpgpu_ptx_sim_load_ptx_from_filename( file ); - std::string fname(path); - name_symtab[fname] = symtab; - context->add_binary(symtab, 1); - load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu()); - load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu()); - addedFile = true; - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkAddFile(CUlinkState state, CUjitInputType type, + const char *path, unsigned int numOptions, + CUjit_option *options, void **optionValues) { + return cuLinkAddFileInternal(state, type, path, numOptions, options, + optionValues); } #endif #if CUDART_VERSION >= 5050 -CUresult CUDAAPI -cuLinkComplete(CUlinkState state, void **cubinOut, size_t *sizeOut) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //all cuLink* function are implemented to block until completion so nothing to do here - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkComplete(CUlinkState state, void **cubinOut, + size_t *sizeOut) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // all cuLink* function are implemented to block until completion so nothing + // to do here + return CUDA_SUCCESS; } -CUresult CUDAAPI -cuLinkDestroy(CUlinkState state) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - //currently do not support options or multiple CUlinkStates - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkDestroy(CUlinkState state) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + // currently do not support options or multiple CUlinkStates + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 5050 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemGetInfo(size_t *free, size_t *total) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemAlloc(CUdeviceptr *dptr, size_t bytesize) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemAllocPitch(CUdeviceptr *dptr, size_t *pPitch, + size_t WidthInBytes, size_t Height, + unsigned int ElementSizeBytes) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemFree(CUdeviceptr dptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemFree(CUdeviceptr dptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, CUdeviceptr dptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemGetAddressRange(CUdeviceptr *pbase, size_t *psize, + CUdeviceptr dptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemAllocHost(void **pp, size_t bytesize) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuMemFreeHost(void *p) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemFreeHost(void *p) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemHostAlloc(void **pp, size_t bytesize, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemHostGetDevicePointer(CUdeviceptr *pdptr, void *p, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemHostGetFlags(unsigned int *pFlags, void *p) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 6000 -CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemAllocManaged(CUdeviceptr *dptr, size_t bytesize, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 6000 */ #if CUDART_VERSION >= 4010 -CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetByPCIBusId(CUdevice *dev, const char *pciBusId) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceGetPCIBusId(char *pciBusId, int len, CUdevice dev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetPCIBusId(char *pciBusId, int len, CUdevice dev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuIpcGetEventHandle(CUipcEventHandle *pHandle, CUevent event) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent, CUipcEventHandle handle) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuIpcOpenEventHandle(CUevent *phEvent, + CUipcEventHandle handle) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuIpcGetMemHandle(CUipcMemHandle *pHandle, CUdeviceptr dptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuIpcOpenMemHandle(CUdeviceptr *pdptr, CUipcMemHandle handle, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuIpcCloseMemHandle(CUdeviceptr dptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4010 */ #if CUDART_VERSION >= 6050 -CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; +} +__host__ cudaError_t cudaHostRegister(void *ptr, size_t size, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return g_last_cudaError = cudaSuccess; } + +__host__ cudaError_t cudaProfilerStart() { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return g_last_cudaError = cudaSuccess; +} + +__host__ cudaError_t cudaProfilerStop() { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return g_last_cudaError = cudaSuccess; +} + #endif #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuMemHostUnregister(void *p) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemHostUnregister(void *p) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoD(CUdeviceptr dstDevice, const void *srcHost, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoH(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, + CUdeviceptr srcDevice, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, + size_t srcOffset, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoH(void *dstHost, CUarray srcArray, size_t srcOffset, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, + CUarray srcArray, size_t srcOffset, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2D(const CUDA_MEMCPY2D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2DUnaligned(const CUDA_MEMCPY2D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3D(const CUDA_MEMCPY3D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void *srcHost, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoHAsync(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoHAsync(void *dstHost, CUarray srcArray, + size_t srcOffset, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2DAsync(const CUDA_MEMCPY2D *pCopy, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DAsync(const CUDA_MEMCPY3D *pCopy, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, + size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, + unsigned short us, size_t Width, size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, + unsigned int ui, size_t Width, size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned short us, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned int ui, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, const CUDA_ARRAY_DESCRIPTOR *pAllocateArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuArrayCreate(CUarray *pHandle, + const CUDA_ARRAY_DESCRIPTOR *pAllocateArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, CUarray hArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR *pArrayDescriptor, + CUarray hArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ - -CUresult CUDAAPI cuArrayDestroy(CUarray hArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuArrayDestroy(CUarray hArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuArray3DCreate(CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuArray3DCreate( + CUarray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pAllocateArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuArray3DGetDescriptor( + CUDA_ARRAY3D_DESCRIPTOR *pArrayDescriptor, CUarray hArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ #if CUDART_VERSION >= 5000 -CUresult CUDAAPI cuMipmappedArrayCreate(CUmipmappedArray *pHandle, const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI +cuMipmappedArrayCreate(CUmipmappedArray *pHandle, + const CUDA_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, + unsigned int numMipmapLevels) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMipmappedArrayGetLevel(CUarray *pLevelArray, + CUmipmappedArray hMipmappedArray, + unsigned int level) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 5000 */ /** @} */ /* END CUDA_MEM */ - #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuPointerGetAttribute(void *data, CUpointer_attribute attribute, CUdeviceptr ptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuPointerGetAttribute(void *data, + CUpointer_attribute attribute, + CUdeviceptr ptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ #if CUDART_VERSION >= 8000 -__host__ cudaError_t CUDARTAPI cudaCreateTextureObject ( cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cuda_not_implemented(__my_func__,__LINE__); - return g_last_cudaError = cudaSuccess; - +__host__ cudaError_t CUDARTAPI cudaCreateTextureObject( + cudaTextureObject_t *pTexObject, const cudaResourceDesc *pResDesc, + const cudaTextureDesc *pTexDesc, const cudaResourceViewDesc *pResViewDesc) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cuda_not_implemented(__my_func__, __LINE__); + return g_last_cudaError = cudaSuccess; } -CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, + CUdevice dstDevice, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUdevice device) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemAdvise(CUdeviceptr devPtr, size_t count, + CUmem_advise advice, CUdevice device) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, CUmem_range_attribute attribute, CUdeviceptr devPtr, size_t count) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemRangeGetAttribute(void *data, size_t dataSize, + CUmem_range_attribute attribute, + CUdeviceptr devPtr, size_t count) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, CUmem_range_attribute *attributes, size_t numAttributes, CUdeviceptr devPtr, size_t count) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemRangeGetAttributes(void **data, size_t *dataSizes, + CUmem_range_attribute *attributes, + size_t numAttributes, + CUdeviceptr devPtr, size_t count) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 8000 */ #if CUDART_VERSION >= 6000 -CUresult CUDAAPI cuPointerSetAttribute(const void *value, CUpointer_attribute attribute, CUdeviceptr ptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuPointerSetAttribute(const void *value, + CUpointer_attribute attribute, + CUdeviceptr ptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 6000 */ #if CUDART_VERSION >= 7000 -CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attribute *attributes, void **data, CUdeviceptr ptr) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuPointerGetAttributes(unsigned int numAttributes, + CUpointer_attribute *attributes, + void **data, CUdeviceptr ptr) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 7000 */ /** @} */ /* END CUDA_UNIFIED */ - -CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamCreate(CUstream *phStream, unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, unsigned int flags, int priority) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamCreateWithPriority(CUstream *phStream, + unsigned int flags, int priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, + CUstreamCallback callback, void *userData, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 6000 -CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, + size_t length, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 6000 */ -CUresult CUDAAPI cuStreamQuery(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamQuery(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamSynchronize(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamSynchronize(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuStreamDestroy(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamDestroy(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ /** @} */ /* END CUDA_STREAM */ - - -CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventCreate(CUevent *phEvent, unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuEventQuery(CUevent hEvent) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventQuery(CUevent hEvent) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuEventSynchronize(CUevent hEvent) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventSynchronize(CUevent hEvent) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuEventDestroy(CUevent hEvent) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventDestroy(CUevent hEvent) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 4000 */ -CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, CUevent hEnd) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventElapsedTime(float *pMilliseconds, CUevent hStart, + CUevent hEnd) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 8000 -CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, + CUstreamBatchMemOpParams *paramArray, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 8000 */ /** @} */ /* END CUDA_EVENT */ - -CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, CUfunction hfunc) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuFuncGetAttribute(int *pi, CUfunction_attribute attrib, + CUfunction hfunc) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 4020 -CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuFuncSetSharedMemConfig(CUfunction hfunc, + CUsharedconfig config) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuLaunchKernel(CUfunction f, - unsigned int gridDimX, - unsigned int gridDimY, - unsigned int gridDimZ, - unsigned int blockDimX, - unsigned int blockDimY, +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) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - if (extra!=NULL){ - printf("GPGPU-Sim CUDA DRIVER API: ERROR: Currently do not support void** extra.\n"); - abort(); - } - const char *hostFun = (const char*) f; - CUctx_st *context = GPGPUSim_Context(); - function_info *entry = context->get_kernel(hostFun); - cudaConfigureCall(dim3(gridDimX, gridDimY, gridDimZ), dim3(blockDimX, blockDimY, blockDimZ), sharedMemBytes, (cudaStream_t) hStream); - for(unsigned i = 0; i < entry->num_args(); i++){ - std::pair<size_t, unsigned> p = entry->get_param_config(i); - cudaSetupArgument(kernelParams[i], p.first, p.second); - } - cudaLaunch(hostFun); - return CUDA_SUCCESS; + unsigned int sharedMemBytes, CUstream hStream, + void **kernelParams, void **extra) { + return cuLaunchKernelInternal(f, gridDimX, gridDimY, gridDimZ, blockDimX, + blockDimY, blockDimZ, sharedMemBytes, hStream, + kernelParams, extra); } #endif /* CUDART_VERSION >= 4000 */ /** @} */ /* END CUDA_EXEC */ - -CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuFuncSetSharedSize(CUfunction hfunc, unsigned int bytes) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, unsigned int numbytes) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuParamSetSize(CUfunction hfunc, unsigned int numbytes) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, unsigned int value) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuParamSeti(CUfunction hfunc, int offset, unsigned int value) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, float value) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuParamSetf(CUfunction hfunc, int offset, float value) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, void *ptr, unsigned int numbytes) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuParamSetv(CUfunction hfunc, int offset, void *ptr, + unsigned int numbytes) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuLaunch(CUfunction f) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuLaunch(CUfunction f) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuLaunchGrid(CUfunction f, int grid_width, int grid_height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuLaunchGridAsync(CUfunction f, int grid_width, + int grid_height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuParamSetTexRef(CUfunction hfunc, int texunit, + CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_EXEC_DEPRECATED */ - #if CUDART_VERSION >= 6050 -CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessor( + int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags( + int *numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; + +CUresult CUDAAPI cuOccupancyMaxPotentialBlockSize( + int *minGridSize, int *blockSize, CUfunction func, + CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, + int blockSizeLimit) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags(int *minGridSize, int *blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuOccupancyMaxPotentialBlockSizeWithFlags( + int *minGridSize, int *blockSize, CUfunction func, + CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, + int blockSizeLimit, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_OCCUPANCY */ -#endif /* CUDART_VERSION >= 6050 */ +#endif /* CUDART_VERSION >= 6050 */ -CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetMipmappedArray(CUtexref hTexRef, + CUmipmappedArray hMipmappedArray, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t bytes) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetAddress(size_t *ByteOffset, CUtexref hTexRef, + CUdeviceptr dptr, size_t bytes) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetAddress2D(CUtexref hTexRef, + const CUDA_ARRAY_DESCRIPTOR *desc, + CUdeviceptr dptr, size_t Pitch) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, + int NumPackedComponents) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetAddressMode(CUtexref hTexRef, int dim, + CUaddress_mode am) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetMipmapFilterMode(CUtexref hTexRef, + CUfilter_mode fm) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, + float minMipmapLevelClamp, + float maxMipmapLevelClamp) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetMaxAnisotropy(CUtexref hTexRef, + unsigned int maxAniso) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetBorderColor(CUtexref hTexRef, float *pBorderColor) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetAddress(CUdeviceptr *pdptr, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetArray(CUarray *phArray, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetMipmappedArray(CUmipmappedArray *phMipmappedArray, + CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, int dim) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetAddressMode(CUaddress_mode *pam, CUtexref hTexRef, + int dim) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetFilterMode(CUfilter_mode *pfm, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetFormat(CUarray_format *pFormat, int *pNumChannels, + CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetMipmapFilterMode(CUfilter_mode *pfm, + CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetMipmapLevelBias(float *pbias, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, + float *pmaxMipmapLevelClamp, + CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetMaxAnisotropy(int *pmaxAniso, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; -} +CUresult CUDAAPI cuTexRefGetBorderColor(float *pBorderColor, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; +} -CUresult CUDAAPI cuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefGetFlags(unsigned int *pFlags, CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefCreate(CUtexref *pTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefCreate(CUtexref *pTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexRefDestroy(CUtexref hTexRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuSurfRefGetArray(CUarray *phArray, CUsurfref hSurfRef) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_SURFREF */ #if CUDART_VERSION >= 5000 -CUresult CUDAAPI cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_DESC *pResDesc, const CUDA_TEXTURE_DESC *pTexDesc, const CUDA_RESOURCE_VIEW_DESC *pResViewDesc) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI +cuTexObjectCreate(CUtexObject *pTexObject, const CUDA_RESOURCE_DESC *pResDesc, + const CUDA_TEXTURE_DESC *pTexDesc, + const CUDA_RESOURCE_VIEW_DESC *pResViewDesc) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexObjectDestroy(CUtexObject texObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUtexObject texObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, + CUtexObject texObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, CUtexObject texObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC *pTexDesc, + CUtexObject texObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuTexObjectGetResourceViewDesc( + CUDA_RESOURCE_VIEW_DESC *pResViewDesc, CUtexObject texObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_TEXOBJECT */ - -CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, const CUDA_RESOURCE_DESC *pResDesc) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuSurfObjectCreate(CUsurfObject *pSurfObject, + const CUDA_RESOURCE_DESC *pResDesc) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuSurfObjectDestroy(CUsurfObject surfObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, CUsurfObject surfObject) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC *pResDesc, + CUsurfObject surfObject) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 5000 */ #if CUDART_VERSION >= 4000 -CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev, CUdevice peerDev) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceCanAccessPeer(int *canAccessPeer, CUdevice dev, + CUdevice peerDev) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib, CUdevice srcDevice, CUdevice dstDevice) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuDeviceGetP2PAttribute(int *value, + CUdevice_P2PAttribute attrib, + CUdevice srcDevice, + CUdevice dstDevice) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxEnablePeerAccess(CUcontext peerContext, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxDisablePeerAccess(CUcontext peerContext) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_PEER_ACCESS */ -#endif /* CUDART_VERSION >= 4000 */ +#endif /* CUDART_VERSION >= 4000 */ - -CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsUnregisterResource(CUgraphicsResource resource) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsSubResourceGetMappedArray( + CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, + unsigned int mipLevel) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #if CUDART_VERSION >= 5000 -CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsResourceGetMappedMipmappedArray( + CUmipmappedArray *pMipmappedArray, CUgraphicsResource resource) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 5000 */ #if CUDART_VERSION >= 3020 -CUresult CUDAAPI cuGraphicsResourceGetMappedPointer(CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsResourceGetMappedPointer( + CUdeviceptr *pDevPtr, size_t *pSize, CUgraphicsResource resource) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION >= 3020 */ -CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } /** @} */ /* END CUDA_GRAPHICS */ -CUresult CUDAAPI cuGetExportTable(const void **ppExportTable, const CUuuid *pExportTableId) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - cudaError_t e = cudaGetExportTable(ppExportTable, pExportTableId); - assert(e == cudaSuccess); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGetExportTable(const void **ppExportTable, + const CUuuid *pExportTableId) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + cudaError_t e = cudaGetExportTable(ppExportTable, pExportTableId); + assert(e == cudaSuccess); + return CUDA_SUCCESS; } - -#if defined(CUDART_VERSION_INTERNAL) || (CUDART_VERSION >= 4000 && CUDART_VERSION < 6050) -CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +#if defined(CUDART_VERSION_INTERNAL) || \ + (CUDART_VERSION >= 4000 && CUDART_VERSION < 6050) +CUresult CUDAAPI cuMemHostRegister(void *p, size_t bytesize, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -#endif /* defined(CUDART_VERSION_INTERNAL) || (CUDART_VERSION >= 4000 && CUDART_VERSION < 6050) */ +#endif /* defined(CUDART_VERSION_INTERNAL) || (CUDART_VERSION >= 4000 && \ + CUDART_VERSION < 6050) */ -#if defined(CUDART_VERSION_INTERNAL) || (CUDART_VERSION >= 5050 && CUDART_VERSION < 6050) -CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options, void **optionValues, CUlinkState *stateOut) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +#if defined(CUDART_VERSION_INTERNAL) || \ + (CUDART_VERSION >= 5050 && CUDART_VERSION < 6050) +CUresult CUDAAPI cuLinkCreate(unsigned int numOptions, CUjit_option *options, + void **optionValues, CUlinkState *stateOut) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuLinkAddData(CUlinkState state, CUjitInputType type, void *data, size_t size, const char *name, - unsigned int numOptions, CUjit_option *options, void **optionValues) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkAddData(CUlinkState state, CUjitInputType type, + void *data, size_t size, const char *name, + unsigned int numOptions, CUjit_option *options, + void **optionValues) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path, - unsigned int numOptions, CUjit_option *options, void **optionValues) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuLinkAddFile(CUlinkState state, CUjitInputType type, + const char *path, unsigned int numOptions, + CUjit_option *options, void **optionValues) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -#endif /* CUDART_VERSION_INTERNAL || (CUDART_VERSION >= 5050 && CUDART_VERSION < 6050) */ +#endif /* CUDART_VERSION_INTERNAL || (CUDART_VERSION >= 5050 && CUDART_VERSION \ + < 6050) */ -#if defined(CUDART_VERSION_INTERNAL) || (CUDART_VERSION >= 3020 && CUDART_VERSION < 4010) -CUresult CUDAAPI cuTexRefSetAddress2D_v2(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR *desc, CUdeviceptr dptr, size_t Pitch) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +#if defined(CUDART_VERSION_INTERNAL) || \ + (CUDART_VERSION >= 3020 && CUDART_VERSION < 4010) +CUresult CUDAAPI cuTexRefSetAddress2D_v2(CUtexref hTexRef, + const CUDA_ARRAY_DESCRIPTOR *desc, + CUdeviceptr dptr, size_t Pitch) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -#endif /* CUDART_VERSION_INTERNAL || (CUDART_VERSION >= 3020 && CUDART_VERSION < 4010) */ +#endif /* CUDART_VERSION_INTERNAL || (CUDART_VERSION >= 3020 && CUDART_VERSION \ + < 4010) */ #if defined(CUDART_VERSION_INTERNAL) || CUDART_VERSION < 4000 -CUresult CUDAAPI cuCtxDestroy(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxDestroy(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxPopCurrent(CUcontext *pctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuCtxPushCurrent(CUcontext ctx) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuStreamDestroy(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamDestroy(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult CUDAAPI cuEventDestroy(CUevent hEvent) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventDestroy(CUevent hEvent) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif /* CUDART_VERSION_INTERNAL || CUDART_VERSION < 4000 */ #if defined(CUDART_VERSION_INTERNAL) - CUresult CUDAAPI cuMemcpyHtoD_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoD_v2(CUdeviceptr dstDevice, const void *srcHost, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyDtoH_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoH_v2(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyDtoD_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoD_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyDtoA_v2(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoA_v2(CUarray dstArray, size_t dstOffset, + CUdeviceptr srcDevice, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyAtoD_v2(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoD_v2(CUdeviceptr dstDevice, CUarray srcArray, + size_t srcOffset, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyHtoA_v2(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoA_v2(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyAtoH_v2(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoH_v2(void *dstHost, CUarray srcArray, + size_t srcOffset, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyAtoA_v2(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoA_v2(CUarray dstArray, size_t dstOffset, + CUarray srcArray, size_t srcOffset, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyHtoAAsync_v2(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoAAsync_v2(CUarray dstArray, size_t dstOffset, + const void *srcHost, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyAtoHAsync_v2(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAtoHAsync_v2(void *dstHost, CUarray srcArray, + size_t srcOffset, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy2D_v2(const CUDA_MEMCPY2D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2D_v2(const CUDA_MEMCPY2D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy3D_v2(const CUDA_MEMCPY3D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3D_v2(const CUDA_MEMCPY3D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyHtoDAsync_v2(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyHtoDAsync_v2(CUdeviceptr dstDevice, + const void *srcHost, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyDtoHAsync_v2(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoHAsync_v2(void *dstHost, CUdeviceptr srcDevice, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyDtoDAsync_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyDtoDAsync_v2(CUdeviceptr dstDevice, + CUdeviceptr srcDevice, size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD8_v2(CUdeviceptr dstDevice, unsigned char uc, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD8_v2(CUdeviceptr dstDevice, unsigned char uc, + size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD16_v2(CUdeviceptr dstDevice, unsigned short us, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD16_v2(CUdeviceptr dstDevice, unsigned short us, + size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD32_v2(CUdeviceptr dstDevice, unsigned int ui, size_t N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD32_v2(CUdeviceptr dstDevice, unsigned int ui, + size_t N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D8_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D8_v2(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, + size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D16_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D16_v2(CUdeviceptr dstDevice, size_t dstPitch, + unsigned short us, size_t Width, + size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D32_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D32_v2(CUdeviceptr dstDevice, size_t dstPitch, + unsigned int ui, size_t Width, + size_t Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, + CUdeviceptr srcDevice, CUcontext srcContext, + size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, + size_t N, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned char uc, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned short us, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, + unsigned int ui, size_t Width, + size_t Height, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamGetPriority(CUstream hStream, int *priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamGetFlags(CUstream hStream, unsigned int *flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWaitEvent(CUstream hStream, CUevent hEvent, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamAddCallback(CUstream hStream, + CUstreamCallback callback, void *userData, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, + size_t length, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamQuery(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamQuery(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamSynchronize(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamSynchronize(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuEventRecord(CUevent hEvent, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - 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) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +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) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsMapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuGraphicsUnmapResources(unsigned int count, + CUgraphicsResource *resources, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, + CUdevice dstDevice, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, + cuuint32_t value, unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult CUDAAPI cuStreamBatchMemOp(CUstream stream, unsigned int count, + CUstreamBatchMemOpParams *paramArray, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } #endif -CUresult cuProfilerInitialize ( const char* configFile, const char* outputFile, CUoutput_mode outputMode ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult cuProfilerInitialize(const char *configFile, const char *outputFile, + CUoutput_mode outputMode) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult cuProfilerStart ( void ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult cuProfilerStart(void) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -CUresult cuProfilerStop ( void ) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +CUresult cuProfilerStop(void) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } //_ptds -extern "C" CUresult CUDAAPI cuMemcpy_ptds(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpy_ptds(CUdeviceptr dst, CUdeviceptr src, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemcpyPeer_ptds(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyPeer_ptds(CUdeviceptr dstDevice, + CUcontext dstContext, + CUdeviceptr srcDevice, + CUcontext srcContext, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyHtoD_v2_ptds(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyHtoD_v2_ptds(CUdeviceptr dstDevice, + const void *srcHost, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyDtoH_v2_ptds(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyDtoH_v2_ptds(void *dstHost, + CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyDtoD_v2_ptds(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyDtoD_v2_ptds(CUdeviceptr dstDevice, + CUdeviceptr srcDevice, + size_t ByteCount) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI +cuMemcpy2DUnaligned_v2_ptds(const CUDA_MEMCPY2D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpy3D_v2_ptds(const CUDA_MEMCPY3D *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI +cuMemcpy3DPeer_ptds(const CUDA_MEMCPY3D_PEER *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD8_v2_ptds(CUdeviceptr dstDevice, unsigned char uc, unsigned int N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD8_v2_ptds(CUdeviceptr dstDevice, + unsigned char uc, + unsigned int N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD16_v2_ptds(CUdeviceptr dstDevice, unsigned short us, unsigned int N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD16_v2_ptds(CUdeviceptr dstDevice, + unsigned short us, + unsigned int N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD32_v2_ptds(CUdeviceptr dstDevice, unsigned int ui, unsigned int N) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD32_v2_ptds(CUdeviceptr dstDevice, + unsigned int ui, + unsigned int N) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD2D8_v2_ptds(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned char uc, unsigned int Width, unsigned int Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD2D8_v2_ptds(CUdeviceptr dstDevice, + unsigned int dstPitch, + unsigned char uc, + unsigned int Width, + unsigned int Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD2D16_v2_ptds(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned short us, unsigned int Width, unsigned int Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD2D16_v2_ptds(CUdeviceptr dstDevice, + unsigned int dstPitch, + unsigned short us, + unsigned int Width, + unsigned int Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemsetD2D32_v2_ptds(CUdeviceptr dstDevice, unsigned int dstPitch, unsigned int ui, unsigned int Width, unsigned int Height) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD2D32_v2_ptds(CUdeviceptr dstDevice, + unsigned int dstPitch, + unsigned int ui, + unsigned int Width, + unsigned int Height) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } //_ptsz -extern "C" CUresult CUDAAPI cuMemcpy3DPeer_ptsz(const CUDA_MEMCPY3D_PEER *pCopy) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI +cuMemcpy3DPeer_ptsz(const CUDA_MEMCPY3D_PEER *pCopy) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemcpyAsync_ptsz(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyAsync_ptsz(CUdeviceptr dst, CUdeviceptr src, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuMemcpyPeerAsync_ptsz(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyPeerAsync_ptsz( + CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, + CUcontext srcContext, size_t ByteCount, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyHtoAAsync_v2_ptsz(CUarray dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyHtoAAsync_v2_ptsz(CUarray dstArray, + size_t dstOffset, + const void *srcHost, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyAtoHAsync_v2_ptsz(void *dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyAtoHAsync_v2_ptsz(void *dstHost, + CUarray srcArray, + size_t srcOffset, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyHtoDAsync_v2_ptsz(CUdeviceptr dstDevice, + const void *srcHost, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyDtoHAsync_v2_ptsz(void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyDtoHAsync_v2_ptsz(void *dstHost, + CUdeviceptr srcDevice, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpyDtoDAsync_v2_ptsz(CUdeviceptr dstDevice, + CUdeviceptr srcDevice, + size_t ByteCount, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpy2DAsync_v2_ptsz(const CUDA_MEMCPY2D *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemcpy3DAsync_v2_ptsz(const CUDA_MEMCPY3D *pCopy, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI +cuMemcpy3DPeerAsync_ptsz(const CUDA_MEMCPY3D_PEER *pCopy, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemsetD8Async_ptsz(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD8Async_ptsz(CUdeviceptr dstDevice, + unsigned char uc, size_t N, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemsetD2D8Async_ptsz(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemsetD2D8Async_ptsz(CUdeviceptr dstDevice, + size_t dstPitch, + unsigned char uc, + size_t Width, size_t Height, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuLaunchKernel_ptsz(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) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuLaunchKernel_ptsz( + 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) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuEventRecord_ptsz(CUevent hEvent, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuEventRecord_ptsz(CUevent hEvent, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuStreamWriteValue32_ptsz(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamWriteValue32_ptsz(CUstream stream, + CUdeviceptr addr, + cuuint32_t value, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuStreamWaitValue32_ptsz(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamWaitValue32_ptsz(CUstream stream, + CUdeviceptr addr, + cuuint32_t value, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuStreamBatchMemOp_ptsz(CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamBatchMemOp_ptsz( + CUstream stream, unsigned int count, CUstreamBatchMemOpParams *paramArray, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuStreamGetPriority_ptsz(CUstream hStream, int *priority) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamGetPriority_ptsz(CUstream hStream, + int *priority) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuStreamGetFlags_ptsz(CUstream hStream, unsigned int *flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamGetFlags_ptsz(CUstream hStream, + unsigned int *flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -extern "C" CUresult CUDAAPI cuStreamWaitEvent_ptsz(CUstream hStream, CUevent hEvent, unsigned int Flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamWaitEvent_ptsz(CUstream hStream, + CUevent hEvent, + unsigned int Flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuStreamAddCallback_ptsz(CUstream hStream, CUstreamCallback callback, void *userData, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamAddCallback_ptsz(CUstream hStream, + CUstreamCallback callback, + void *userData, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuStreamSynchronize_ptsz(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamSynchronize_ptsz(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuStreamQuery_ptsz(CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamQuery_ptsz(CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuStreamAttachMemAsync_ptsz(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuStreamAttachMemAsync_ptsz(CUstream hStream, + CUdeviceptr dptr, + size_t length, + unsigned int flags) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } -extern "C" CUresult CUDAAPI cuGraphicsMapResources_ptsz(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuGraphicsMapResources_ptsz( + unsigned int count, CUgraphicsResource *resources, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - -extern "C" CUresult CUDAAPI cuGraphicsUnmapResources_ptsz(unsigned int count, CUgraphicsResource *resources, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuGraphicsUnmapResources_ptsz( + unsigned int count, CUgraphicsResource *resources, CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } - extern "C" CUresult CUDAAPI cuMemPrefetchAsync_ptsz(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream) -{ - if(g_debug_execution >= 3){ - announce_call(__my_func__); - } - printf("WARNING: this function has not been implemented yet."); - return CUDA_SUCCESS; +extern "C" CUresult CUDAAPI cuMemPrefetchAsync_ptsz(CUdeviceptr devPtr, + size_t count, + CUdevice dstDevice, + CUstream hStream) { + if (g_debug_execution >= 3) { + announce_call(__my_func__); + } + printf("WARNING: this function has not been implemented yet."); + return CUDA_SUCCESS; } diff --git a/libcuda/cuobjdump.h b/libcuda/cuobjdump.h new file mode 100644 index 0000000..38afa4c --- /dev/null +++ b/libcuda/cuobjdump.h @@ -0,0 +1,81 @@ +#ifndef __cuobjdump_h__ +#define __cuobjdump_h__ +#include <iostream> +#include <list> +#include <string> + +typedef void *yyscan_t; +struct cuobjdump_parser { + yyscan_t scanner; + int elfserial; + int ptxserial; + FILE *ptxfile; + FILE *elffile; + FILE *sassfile; + char filename[1024]; +}; + +class cuobjdumpSection { + public: + // Constructor + cuobjdumpSection() { + arch = 0; + identifier = ""; + } + virtual ~cuobjdumpSection() {} + unsigned getArch() { return arch; } + void setArch(unsigned a) { arch = a; } + std::string getIdentifier() { return identifier; } + void setIdentifier(std::string i) { identifier = i; } + virtual void print() { + std::cout << "cuobjdump Section: unknown type" << std::endl; + } + + private: + unsigned arch; + std::string identifier; +}; + +class cuobjdumpELFSection : public cuobjdumpSection { + public: + cuobjdumpELFSection() {} + virtual ~cuobjdumpELFSection() { + elffilename = ""; + sassfilename = ""; + } + std::string getELFfilename() { return elffilename; } + void setELFfilename(std::string f) { elffilename = f; } + std::string getSASSfilename() { return sassfilename; } + void setSASSfilename(std::string f) { sassfilename = f; } + virtual void print() { + std::cout << "ELF Section:" << std::endl; + std::cout << "arch: sm_" << getArch() << std::endl; + std::cout << "identifier: " << getIdentifier() << std::endl; + std::cout << "elf filename: " << getELFfilename() << std::endl; + std::cout << "sass filename: " << getSASSfilename() << std::endl; + std::cout << std::endl; + } + + private: + std::string elffilename; + std::string sassfilename; +}; + +class cuobjdumpPTXSection : public cuobjdumpSection { + public: + cuobjdumpPTXSection() { ptxfilename = ""; } + std::string getPTXfilename() { return ptxfilename; } + void setPTXfilename(std::string f) { ptxfilename = f; } + virtual void print() { + std::cout << "PTX Section:" << std::endl; + std::cout << "arch: sm_" << getArch() << std::endl; + std::cout << "identifier: " << getIdentifier() << std::endl; + std::cout << "ptx filename: " << getPTXfilename() << std::endl; + std::cout << std::endl; + } + + private: + std::string ptxfilename; +}; + +#endif /* __cuobjdump_h__ */ diff --git a/libcuda/cuobjdump.l b/libcuda/cuobjdump.l index 2b0dac8..5a19d65 100644 --- a/libcuda/cuobjdump.l +++ b/libcuda/cuobjdump.l @@ -30,6 +30,7 @@ %{ #include <stdio.h> #include <string.h> +#include "cuobjdump.h" #include "cuobjdump_parser.h" #define YY_NEVER_INTERACTIVE 1 @@ -38,9 +39,9 @@ #define YYDEBUG 1 -#define yylval cuobjdump_lval - -void cuobjdump_error(const char*); +void cuobjdump_error(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg); +#define YY_DECL int cuobjdump_lex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList) %} %option stack @@ -48,6 +49,8 @@ void cuobjdump_error(const char*); %option yylineno %option nounput +%option bison-bridge +%option reentrant %s ptxcode %s sasscode @@ -69,54 +72,54 @@ newlines {newline}+ "ptxasOptions"{notnewline}*{newline} -[1-9]{numeric}* yylval.string_value = strdup(yytext); return DECIMAL; +[1-9]{numeric}* yylval->string_value = strdup(yytext); return DECIMAL; "has debug info"{newline} "Fatbin ptx code:"{newline} { - yy_push_state(ptxcode); - yy_push_state(identifier); - yy_push_state(ptxheader); - yylval.string_value = strdup(yytext); + yy_push_state(ptxcode, yyscanner); + yy_push_state(identifier, yyscanner); + yy_push_state(ptxheader, yyscanner); + yylval->string_value = strdup(yytext); return PTXHEADER; } "Fatbin elf code:"{newline} { - yy_push_state(elfcode); - yy_push_state(identifier); - yy_push_state(elfheader); - yylval.string_value = strdup(yytext); + yy_push_state(elfcode, yyscanner); + yy_push_state(identifier, yyscanner); + yy_push_state(elfheader, yyscanner); + yylval->string_value = strdup(yytext); return ELFHEADER; } /*PTX code tokens*/ -<ptxcode>{notnewline}*{newline} yylval.string_value = strdup(yytext); return PTXLINE; +<ptxcode>{notnewline}*{newline} yylval->string_value = strdup(yytext); return PTXLINE; /*ELF code tokens*/ <elfcode>{whitespace}*"code for sm_"{numeric}+{newline} { BEGIN(sasscode); - yylval.string_value = strdup(yytext); + yylval->string_value = strdup(yytext); return SASSLINE; } -<elfcode>{notnewline}*{newline} yylval.string_value = strdup(yytext); return ELFLINE; +<elfcode>{notnewline}*{newline} yylval->string_value = strdup(yytext); return ELFLINE; /*SASS code tokens*/ -<sasscode>{notnewline}*{newline} yylval.string_value = strdup(yytext); return SASSLINE; +<sasscode>{notnewline}*{newline} yylval->string_value = strdup(yytext); return SASSLINE; <identifier>{newline}"compressed"{newline} BEGIN(conidentifier); return H_COMPRESSED; <identifier>{newline}"identifier = " BEGIN(endidentifier); return H_IDENTIFIER; -<identifier>{newline}{newline} yy_pop_state(); +<identifier>{newline}{newline} yy_pop_state(yyscanner); <conidentifier>"identifier = " BEGIN(endidentifier); return H_IDENTIFIER; -<conidentifier>{newline} yy_pop_state(); +<conidentifier>{newline} yy_pop_state(yyscanner); -<endidentifier>{notnewline}+ yylval.string_value = strdup(yytext); yy_pop_state(); return FILENAME; +<endidentifier>{notnewline}+ yylval->string_value = strdup(yytext); yy_pop_state(yyscanner); return FILENAME; /*Header tokens*/ -<elfheader>[[:alnum:]_]+ yylval.string_value = strdup(yytext); return IDENTIFIER; +<elfheader>[[:alnum:]_]+ yylval->string_value = strdup(yytext); return IDENTIFIER; <elfheader>"================" return H_SEPARATOR; <elfheader>"arch = " return H_ARCH; <elfheader>"code version = " return H_CODEVERSION; @@ -128,7 +131,7 @@ newlines {newline}+ /*Header tokens*/ -<ptxheader>[[:alnum:]_]+ yylval.string_value = strdup(yytext); return IDENTIFIER; +<ptxheader>[[:alnum:]_]+ yylval->string_value = strdup(yytext); return IDENTIFIER; <ptxheader>"================" return H_SEPARATOR; <ptxheader>"arch = " return H_ARCH; <ptxheader>"code version = " return H_CODEVERSION; @@ -143,7 +146,7 @@ newlines {newline}+ /* Looking for the identifier (filename) then the header is done */ -<endheader>{notnewline}+ yylval.string_value = strdup(yytext); yy_pop_state(); return IDENTIFIER; +<endheader>{notnewline}+ yylval->string_value = strdup(yytext); yy_pop_state(yyscanner); return IDENTIFIER; @@ -153,11 +156,12 @@ newlines {newline}+ <<EOF>> BEGIN(INITIAL);return 0; /*No other rule matched. Throw an error*/ -. cuobjdump_error("Invalid token"); +. cuobjdump_error(yyscanner, parser, cuobjdumpSectionList, "Invalid token"); %% -void cuobjdump_error(const char* message) +void cuobjdump_error(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg) { - printf(" %s near \"%s\"",message, yytext); - printf(" on line %i\n",yylineno); + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + printf(" %s near \"%s\"",msg, yytext); + printf(" on line %i\n",yylineno); } diff --git a/libcuda/cuobjdump.y b/libcuda/cuobjdump.y index 31760f7..8d1bca6 100644 --- a/libcuda/cuobjdump.y +++ b/libcuda/cuobjdump.y @@ -29,24 +29,31 @@ %{ #include <stdio.h> -int yylex(void); -void yyerror(const char*); -extern void addCuobjdumpSection(int sectiontype); -void setCuobjdumparch(const char* arch); -void setCuobjdumpidentifier(const char* identifier); -void setCuobjdumpptxfilename(const char* filename); -void setCuobjdumpelffilename(const char* filename); -void setCuobjdumpsassfilename(const char* filename); -int elfserial = 1; -int ptxserial = 1; -FILE *ptxfile; -FILE *elffile; -FILE *sassfile; -char filename [1024]; +typedef void * yyscan_t; +#include "cuobjdump.h" + +extern void addCuobjdumpSection(int sectiontype, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void setCuobjdumparch(const char* arch, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void setCuobjdumpidentifier(const char* identifier, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void setCuobjdumpptxfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void setCuobjdumpelffilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void setCuobjdumpsassfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList); %} +%define api.pure full +%parse-param {yyscan_t scanner} +%parse-param {struct cuobjdump_parser* parser} +%parse-param {std::list<cuobjdumpSection*> &cuobjdumpSectionList} +%lex-param {yyscan_t scanner} +%lex-param {struct cuobjdump_parser* parser} +%lex-param {std::list<cuobjdumpSection*> &cuobjdumpSectionList} + %union { char* string_value; } +%{ +int yylex(YYSTYPE * yylval_param, yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList); +void yyerror(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg); +%} %token <string_value> H_SEPARATOR H_ARCH H_CODEVERSION H_PRODUCER H_HOST H_COMPILESIZE H_IDENTIFIER H_UNKNOWN H_COMPRESSED %token <string_value> CODEVERSION %token <string_value> STRING @@ -70,25 +77,25 @@ emptylines : emptylines NEWLINE | ; section : PTXHEADER { - addCuobjdumpSection(0); - snprintf(filename, 1024, "_cuobjdump_%d.ptx", ptxserial++); - ptxfile = fopen(filename, "w"); - setCuobjdumpptxfilename(filename); + addCuobjdumpSection(0, cuobjdumpSectionList); + snprintf(parser->filename, 1024, "_cuobjdump_%d.ptx", parser->ptxserial++); + parser->ptxfile = fopen(parser->filename, "w"); + setCuobjdumpptxfilename(parser->filename, cuobjdumpSectionList); } headerinfo compressedkeyword identifier ptxcode { - fclose(ptxfile); + fclose(parser->ptxfile); } | ELFHEADER { - addCuobjdumpSection(1); - snprintf(filename, 1024, "_cuobjdump_%d.elf", elfserial); - elffile = fopen(filename, "w"); - setCuobjdumpelffilename(filename); + addCuobjdumpSection(1, cuobjdumpSectionList); + snprintf(parser->filename, 1024, "_cuobjdump_%d.elf", parser->elfserial); + parser->elffile = fopen(parser->filename, "w"); + setCuobjdumpelffilename(parser->filename, cuobjdumpSectionList); } headerinfo compressedkeyword identifier elfcode { - fclose(elffile); - snprintf(filename, 1024, "_cuobjdump_%d.sass", elfserial++); - sassfile = fopen(filename, "w"); - setCuobjdumpsassfilename(filename); + fclose(parser->elffile); + snprintf(parser->filename, 1024, "_cuobjdump_%d.sass", parser->elfserial++); + parser->sassfile = fopen(parser->filename, "w"); + setCuobjdumpsassfilename(parser->filename, cuobjdumpSectionList); } sasscode { - fclose(sassfile); + fclose(parser->sassfile); }; headerinfo : H_SEPARATOR NEWLINE @@ -96,27 +103,27 @@ headerinfo : H_SEPARATOR NEWLINE H_CODEVERSION CODEVERSION NEWLINE H_PRODUCER H_UNKNOWN NEWLINE H_HOST IDENTIFIER NEWLINE - H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4);}; + H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4, cuobjdumpSectionList);}; | H_SEPARATOR NEWLINE H_ARCH IDENTIFIER NEWLINE H_CODEVERSION CODEVERSION NEWLINE H_PRODUCER IDENTIFIER NEWLINE H_HOST IDENTIFIER NEWLINE - H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4);}; + H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4, cuobjdumpSectionList);}; -identifier : H_IDENTIFIER FILENAME emptylines {setCuobjdumpidentifier($2);} - | {setCuobjdumpidentifier("default");}; +identifier : H_IDENTIFIER FILENAME emptylines {setCuobjdumpidentifier($2, cuobjdumpSectionList);} + | {setCuobjdumpidentifier("default", cuobjdumpSectionList);}; compressedkeyword : H_COMPRESSED emptylines | ; -ptxcode : ptxcode PTXLINE {fprintf(ptxfile, "%s", $2);} +ptxcode : ptxcode PTXLINE {fprintf(parser->ptxfile, "%s", $2);} | ; -elfcode : elfcode ELFLINE {fprintf(elffile, "%s", $2);} +elfcode : elfcode ELFLINE {fprintf(parser->elffile, "%s", $2);} | ; -sasscode : sasscode SASSLINE {fprintf(sassfile, "%s", $2);} +sasscode : sasscode SASSLINE {fprintf(parser->sassfile, "%s", $2);} | ; diff --git a/libcuda/gpgpu_context.h b/libcuda/gpgpu_context.h new file mode 100644 index 0000000..d0cd7c4 --- /dev/null +++ b/libcuda/gpgpu_context.h @@ -0,0 +1,83 @@ +#ifndef __gpgpu_context_h__ +#define __gpgpu_context_h__ +#include "../src/cuda-sim/cuda-sim.h" +#include "../src/cuda-sim/cuda_device_runtime.h" +#include "../src/cuda-sim/ptx-stats.h" +#include "../src/cuda-sim/ptx_loader.h" +#include "../src/cuda-sim/ptx_parser.h" +#include "../src/gpgpusim_entrypoint.h" +#include "cuda_api_object.h" + +class gpgpu_context { + public: + gpgpu_context() { + g_global_allfiles_symbol_table = NULL; + sm_next_access_uid = 0; + warp_inst_sm_next_uid = 0; + operand_info_sm_next_uid = 1; + kernel_info_m_next_uid = 1; + g_num_ptx_inst_uid = 0; + g_ptx_cta_info_uid = 1; + symbol_sm_next_uid = 1; + function_info_sm_next_uid = 1; + debug_tensorcore = 0; + api = new cuda_runtime_api(this); + ptxinfo = new ptxinfo_data(this); + ptx_parser = new ptx_recognizer(this); + the_gpgpusim = new GPGPUsim_ctx(this); + func_sim = new cuda_sim(this); + device_runtime = new cuda_device_runtime(this); + stats = new ptx_stats(this); + } + // global list + symbol_table *g_global_allfiles_symbol_table; + const char *g_filename; + unsigned sm_next_access_uid; + unsigned warp_inst_sm_next_uid; + unsigned operand_info_sm_next_uid; // uid for operand_info + unsigned kernel_info_m_next_uid; // uid for kernel_info_t + unsigned g_num_ptx_inst_uid; // uid for ptx inst inside ptx_instruction + unsigned long long g_ptx_cta_info_uid; + unsigned symbol_sm_next_uid; // uid for symbol + unsigned function_info_sm_next_uid; + std::vector<ptx_instruction *> + s_g_pc_to_insn; // a direct mapping from PC to instruction + bool debug_tensorcore; + + // objects pointers for each file + cuda_runtime_api *api; + ptxinfo_data *ptxinfo; + ptx_recognizer *ptx_parser; + GPGPUsim_ctx *the_gpgpusim; + cuda_sim *func_sim; + cuda_device_runtime *device_runtime; + ptx_stats *stats; + // member function list + void synchronize(); + void exit_simulation(); + void print_simulation_time(); + int gpgpu_opencl_ptx_sim_main_perf(kernel_info_t *grid); + void cuobjdumpParseBinary(unsigned int handle); + class symbol_table *gpgpu_ptx_sim_load_ptx_from_string(const char *p, + unsigned source_num); + class symbol_table *gpgpu_ptx_sim_load_ptx_from_filename( + const char *filename); + void gpgpu_ptx_info_load_from_filename(const char *filename, + unsigned sm_version); + void gpgpu_ptxinfo_load_from_string(const char *p_for_info, + unsigned source_num, + unsigned sm_version = 20, + int no_of_ptx = 0); + void print_ptx_file(const char *p, unsigned source_num, const char *filename); + class symbol_table *init_parser(const char *); + class gpgpu_sim *gpgpu_ptx_sim_init_perf(); + void start_sim_thread(int api); + struct _cuda_device_id *GPGPUSim_Init(); + void ptx_reg_options(option_parser_t opp); + const ptx_instruction *pc_to_instruction(unsigned pc); + const warp_inst_t *ptx_fetch_inst(address_type pc); + unsigned translate_pc_to_ptxlineno(unsigned pc); +}; +gpgpu_context *GPGPU_Context(); + +#endif /* __gpgpu_context_h__ */ |