Evgeny Mankov
865c6f23c7
+ for all CUDA versions + add missing types + fix typos + sync with HIP + update CUDA_Driver_API_functions_supported_by_HIP.md + formatting, annotating
4243 lines
443 KiB
C++
4243 lines
443 KiB
C++
#include "CUDA2HipMap.h"
|
|
|
|
// Maps CUDA HEADER names to HIP HEADER names.
|
|
const std::map <llvm::StringRef, hipCounter> CUDA_INCLUDE_MAP{
|
|
// CUDA includes
|
|
{"cuda.h", {"hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_DRIVER}},
|
|
{"cuda_runtime.h", {"hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_RUNTIME}},
|
|
{"cuda_runtime_api.h", {"hip/hip_runtime_api.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"channel_descriptor.h", {"hip/channel_descriptor.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"device_functions.h", {"hip/device_functions.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"driver_types.h", {"hip/driver_types.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"cuda_fp16.h", {"hip/hip_fp16.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"cuda_texture_types.h", {"hip/hip_texture_types.h", CONV_INCLUDE, API_RUNTIME}},
|
|
{"vector_types.h", {"hip/hip_vector_types.h", CONV_INCLUDE, API_RUNTIME}},
|
|
// cuBLAS includes
|
|
{"cublas.h", {"hipblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS}},
|
|
{"cublas_v2.h", {"hipblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS}},
|
|
// cuRAND includes
|
|
{"curand.h", {"hiprand.h", CONV_INCLUDE_CUDA_MAIN_H, API_RAND}},
|
|
{"curand_kernel.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_discrete.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_discrete2.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_globals.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_lognormal.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_mrg32k3a.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_mtgp32.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_mtgp32_host.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_mtgp32_kernel.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_mtgp32dc_p_11213.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_normal.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_normal_static.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_philox4x32_x.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_poisson.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_precalc.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
{"curand_uniform.h", {"hiprand_kernel.h", CONV_INCLUDE, API_RAND}},
|
|
// cuDNN includes
|
|
{"cudnn.h", {"hipDNN.h", CONV_INCLUDE_CUDA_MAIN_H, API_DNN}},
|
|
// cuFFT includes
|
|
{"cufft.h", {"hipfft.h", CONV_INCLUDE_CUDA_MAIN_H, API_FFT}},
|
|
// cuComplex includes
|
|
{"cuComplex.h", {"hip/hip_complex.h", CONV_INCLUDE_CUDA_MAIN_H, API_COMPLEX}},
|
|
};
|
|
|
|
// Maps the names of CUDA TYPES to the corresponding HIP TYPES.
|
|
const std::map<llvm::StringRef, hipCounter> CUDA_TYPE_NAME_MAP{
|
|
|
|
/////////////////////////////////////////////////////// CUDA DRIVER API ///////////////////////////////////////////////////////
|
|
|
|
// 1. Structs
|
|
{"CUDA_ARRAY3D_DESCRIPTOR_st", {"HIP_ARRAY3D_DESCRIPTOR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_ARRAY3D_DESCRIPTOR", {"HIP_ARRAY3D_DESCRIPTOR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_ARRAY_DESCRIPTOR_st", {"HIP_ARRAY_DESCRIPTOR", CONV_TYPE, API_DRIVER}},
|
|
{"CUDA_ARRAY_DESCRIPTOR", {"HIP_ARRAY_DESCRIPTOR", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st", {"HIP_EXTERNAL_MEMORY_BUFFER_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_MEMORY_BUFFER_DESC", {"HIP_EXTERNAL_MEMORY_BUFFER_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st", {"HIP_EXTERNAL_MEMORY_HANDLE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_MEMORY_HANDLE_DESC", {"HIP_EXTERNAL_MEMORY_HANDLE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st", {"HIP_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC", {"HIP_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st", {"HIP_EXTERNAL_SEMAPHORE_HANDLE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC", {"HIP_EXTERNAL_SEMAPHORE_HANDLE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st", {"HIP_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS", {"HIP_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st", {"HIP_EXTERNAL_SEMAPHORE_WAIT_PARAMS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS", {"HIP_EXTERNAL_SEMAPHORE_WAIT_PARAMS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_HOST_NODE_PARAMS_st", {"hipHostNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_HOST_NODE_PARAMS", {"hipHostNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_KERNEL_NODE_PARAMS_st", {"hipKernelNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_KERNEL_NODE_PARAMS", {"hipKernelNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_LAUNCH_PARAMS_st", {"hipLaunchParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_LAUNCH_PARAMS", {"hipLaunchParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_MEMCPY2D_st", {"hip_Memcpy2D", CONV_TYPE, API_DRIVER}},
|
|
{"CUDA_MEMCPY2D", {"hip_Memcpy2D", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUDA_MEMCPY3D_st", {"hip_Memcpy3D", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_MEMCPY3D", {"hip_Memcpy3D", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_MEMCPY3D_PEER_st", {"hip_Memcpy3D_Peer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_MEMCPY3D_PEER", {"hip_Memcpy3D_Peer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_MEMSET_NODE_PARAMS_st", {"hipMemsetNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_MEMSET_NODE_PARAMS", {"hipMemsetNodeParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st", {"HIP_POINTER_ATTRIBUTE_P2P_TOKENS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_POINTER_ATTRIBUTE_P2P_TOKENS", {"HIP_POINTER_ATTRIBUTE_P2P_TOKENS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_RESOURCE_DESC_st", {"HIP_RESOURCE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_RESOURCE_DESC", {"HIP_RESOURCE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_RESOURCE_VIEW_DESC_st", {"HIP_RESOURCE_VIEW_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_RESOURCE_VIEW_DESC", {"HIP_RESOURCE_VIEW_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUDA_TEXTURE_DESC_st", {"HIP_TEXTURE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_TEXTURE_DESC", {"HIP_TEXTURE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUdevprop_st", {"hipDeviceProp_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUdevprop", {"hipDeviceProp_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUipcEventHandle_st", {"hipIpcEventHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUipcEventHandle", {"hipIpcEventHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUipcMemHandle_st", {"hipIpcMemHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUipcMemHandle", {"hipIpcMemHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// CUDA: "The types CUarray and cudaArray * represent the same data type and may be used interchangeably by casting the two types between each other."
|
|
// cudaArray
|
|
{"CUarray_st", {"hipArray", CONV_TYPE, API_DRIVER}},
|
|
// cudaArray_t
|
|
{"CUarray", {"hipArray *", CONV_TYPE, API_DRIVER}},
|
|
|
|
// no analogue
|
|
{"CUctx_st", {"ihipCtx_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUcontext", {"hipCtx_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// cudaEglStreamConnection
|
|
{"CUeglStreamConnection_st", {"hipEglStreamConnection", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUeglStreamConnection", {"hipEglStreamConnection", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// the same - CUevent_st
|
|
{"CUevent_st", {"ihipEvent_t", CONV_TYPE, API_DRIVER}},
|
|
// cudaEvent_t
|
|
{"CUevent", {"hipEvent_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// CUexternalMemory_st
|
|
{"CUextMemory_st", {"hipExtMemory_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaExternalMemory_t
|
|
{"CUexternalMemory", {"hipExternalMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// CUexternalSemaphore_st
|
|
{"CUextSemaphore_st", {"hipExtSemaphore_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaExternalSemaphore_t
|
|
{"CUexternalSemaphore", {"hipExternalSemaphore", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// no analogue
|
|
{"CUfunc_st", {"ihipModuleSymbol_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUfunction", {"hipFunction_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// the same - CUgraph_st
|
|
{"CUgraph_st", {"hipGraph_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraph_t
|
|
{"CUgraph", {"hipGraph", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// the same -CUgraphExec_st
|
|
{"CUgraphExec_st", {"hipGraphExec_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraphExec_t
|
|
{"CUgraphExec", {"hipGraphExec", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaGraphicsResource
|
|
{"CUgraphicsResource_st", {"hipGraphicsResource_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraphicsResource_t
|
|
{"CUgraphicsResource", {"hipGraphicsResource_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// the same - CUgraphNode_st
|
|
{"CUgraphNode_st", {"hipGraphNode_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraphNode_t
|
|
{"CUgraphNode", {"hipGraphNode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaMipmappedArray
|
|
{"CUmipmappedArray_st", {"hipMipmappedArray_st", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaMipmappedArray_t
|
|
{"CUmipmappedArray", {"hipMipmappedArray_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// no analogue
|
|
{"CUmod_st", {"ihipModule_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUmodule", {"hipModule_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// the same - CUstream_st
|
|
{"CUstream_st", {"ihipStream_t", CONV_TYPE, API_DRIVER}},
|
|
// cudaStream_t
|
|
{"CUstream", {"hipStream_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// surfaceReference
|
|
{"CUsurfref_st", {"ihipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// no analogue
|
|
{"CUsurfref", {"hipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// surfaceReference
|
|
{"CUtexref_st", {"textureReference", CONV_TYPE, API_DRIVER}},
|
|
{"CUtexref", {"hipTextureReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// 2. Unions
|
|
{"CUstreamBatchMemOpParams", {"hipStreamBatchMemOpParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstreamBatchMemOpParams_union", {"hipStreamBatchMemOpParams", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// 3. Enums
|
|
{"CUaddress_mode", {"hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUaddress_mode_enum", {"hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUaddress_mode enum values
|
|
{"CU_TR_ADDRESS_MODE_WRAP", {"HIP_TR_ADDRESS_MODE_WRAP", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
{"CU_TR_ADDRESS_MODE_CLAMP", {"HIP_TR_ADDRESS_MODE_CLAMP", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
{"CU_TR_ADDRESS_MODE_MIRROR", {"HIP_TR_ADDRESS_MODE_MIRROR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
{"CU_TR_ADDRESS_MODE_BORDER", {"HIP_TR_ADDRESS_MODE_BORDER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
|
|
{"CUarray_cubemap_face", {"hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUarray_cubemap_face_enum", {"hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUarray_cubemap_face enum values
|
|
{"CU_CUBEMAP_FACE_POSITIVE_X", {"HIP_CUBEMAP_FACE_POSITIVE_X", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_X", {"HIP_CUBEMAP_FACE_NEGATIVE_X", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_CUBEMAP_FACE_POSITIVE_Y", {"HIP_CUBEMAP_FACE_POSITIVE_Y", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_Y", {"HIP_CUBEMAP_FACE_NEGATIVE_Y", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
{"CU_CUBEMAP_FACE_POSITIVE_Z", {"HIP_CUBEMAP_FACE_POSITIVE_Z", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_Z", {"HIP_CUBEMAP_FACE_NEGATIVE_Z", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x05
|
|
|
|
{"CUarray_format", {"hipArray_format", CONV_TYPE, API_DRIVER}},
|
|
{"CUarray_format_enum", {"hipArray_format", CONV_TYPE, API_DRIVER}},
|
|
// CUarray_format enum values
|
|
{"CU_AD_FORMAT_UNSIGNED_INT8", {"HIP_AD_FORMAT_UNSIGNED_INT8", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x01
|
|
{"CU_AD_FORMAT_UNSIGNED_INT16", {"HIP_AD_FORMAT_UNSIGNED_INT16", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
{"CU_AD_FORMAT_UNSIGNED_INT32", {"HIP_AD_FORMAT_UNSIGNED_INT32", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x03
|
|
{"CU_AD_FORMAT_SIGNED_INT8", {"HIP_AD_FORMAT_SIGNED_INT8", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x08
|
|
{"CU_AD_FORMAT_SIGNED_INT16", {"HIP_AD_FORMAT_SIGNED_INT16", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x09
|
|
{"CU_AD_FORMAT_SIGNED_INT32", {"HIP_AD_FORMAT_SIGNED_INT32", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0a
|
|
{"CU_AD_FORMAT_HALF", {"HIP_AD_FORMAT_HALF", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x10
|
|
{"CU_AD_FORMAT_FLOAT", {"HIP_AD_FORMAT_FLOAT", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x20
|
|
|
|
// cudaComputeMode
|
|
{"CUcomputemode", {"hipComputeMode", CONV_TYPE, API_DRIVER}},
|
|
{"CUcomputemode_enum", {"hipComputeMode", CONV_TYPE, API_DRIVER}},
|
|
// CUcomputemode enum values
|
|
// cudaComputeModeDefault
|
|
{"CU_COMPUTEMODE_DEFAULT", {"hipComputeModeDefault", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0
|
|
// Deprecated since CUDA 10.0
|
|
// cudaComputeModeExclusive
|
|
{"CU_COMPUTEMODE_EXCLUSIVE", {"hipComputeModeExclusive", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 1
|
|
// cudaComputeModeProhibited
|
|
{"CU_COMPUTEMODE_PROHIBITED", {"hipComputeModeProhibited", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 2
|
|
// cudaComputeModeExclusiveProcess
|
|
{"CU_COMPUTEMODE_EXCLUSIVE_PROCESS", {"hipComputeModeExclusiveProcess", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 3
|
|
|
|
{"CUctx_flags", {"hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUctx_flags_enum", {"hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUctx_flags enum values
|
|
{"CU_CTX_SCHED_AUTO", {"HIP_CTX_SCHED_AUTO", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
{"CU_CTX_SCHED_SPIN", {"HIP_CTX_SCHED_SPIN", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_CTX_SCHED_YIELD", {"HIP_CTX_SCHED_YIELD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_CTX_SCHED_BLOCKING_SYNC", {"HIP_CTX_SCHED_BLOCKING_SYNC", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CTX_BLOCKING_SYNC", {"HIP_CTX_BLOCKING_SYNC", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CTX_SCHED_MASK", {"HIP_CTX_SCHED_MASK", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x07
|
|
{"CU_CTX_MAP_HOST", {"HIP_CTX_MAP_HOST", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
{"CU_CTX_LMEM_RESIZE_TO_MAX", {"HIP_CTX_LMEM_RESIZE_TO_MAX", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
{"CU_CTX_FLAGS_MASK", {"HIP_CTX_FLAGS_MASK", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1f
|
|
|
|
// cudaDeviceAttr
|
|
{"CUdevice_attribute", {"hipDeviceAttribute_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUdevice_attribute_enum", {"hipDeviceAttribute_t", CONV_TYPE, API_DRIVER}},
|
|
// CUdevice_attribute enum values
|
|
// cudaDevAttrMaxThreadsPerBlock
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK", {"hipDeviceAttributeMaxThreadsPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 1
|
|
// cudaDevAttrMaxBlockDimX
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X", {"hipDeviceAttributeMaxBlockDimX", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 2
|
|
// cudaDevAttrMaxBlockDimY
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y", {"hipDeviceAttributeMaxBlockDimY", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 3
|
|
// cudaDevAttrMaxBlockDimZ
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z", {"hipDeviceAttributeMaxBlockDimZ", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 4
|
|
// cudaDevAttrMaxGridDimX
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X", {"hipDeviceAttributeMaxGridDimX", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 5
|
|
// cudaDevAttrMaxGridDimY
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y", {"hipDeviceAttributeMaxGridDimY", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 6
|
|
// cudaDevAttrMaxGridDimZ
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z", {"hipDeviceAttributeMaxGridDimZ", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 7
|
|
// cudaDevAttrMaxSharedMemoryPerBlock
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK", {"hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 8
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
|
|
{"CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK", {"hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 8
|
|
// cudaDevAttrTotalConstantMemory
|
|
{"CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY", {"hipDeviceAttributeTotalConstantMemory", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 9
|
|
// cudaDevAttrWarpSize
|
|
{"CU_DEVICE_ATTRIBUTE_WARP_SIZE", {"hipDeviceAttributeWarpSize", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 10
|
|
// cudaDevAttrMaxPitch
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_PITCH", {"hipDeviceAttributeMaxPitch", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 11
|
|
// cudaDevAttrMaxRegistersPerBlock
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK", {"hipDeviceAttributeMaxRegistersPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 12
|
|
// no analogue
|
|
{"CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK", {"hipDeviceAttributeMaxRegistersPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 12
|
|
// cudaDevAttrClockRate
|
|
{"CU_DEVICE_ATTRIBUTE_CLOCK_RATE", {"hipDeviceAttributeClockRate", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 13
|
|
// cudaDevAttrTextureAlignment
|
|
{"CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT", {"hipDeviceAttributeTextureAlignment", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 14
|
|
// Deprecated, use instead CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT
|
|
// cudaDevAttrGpuOverlap
|
|
{"CU_DEVICE_ATTRIBUTE_GPU_OVERLAP", {"hipDeviceAttributeAsyncEngineCount", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 15
|
|
// cudaDevAttrMultiProcessorCount
|
|
{"CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT", {"hipDeviceAttributeMultiprocessorCount", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 16
|
|
// cudaDevAttrKernelExecTimeout
|
|
{"CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT", {"hipDeviceAttributeKernelExecTimeout", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 17
|
|
// cudaDevAttrIntegrated
|
|
{"CU_DEVICE_ATTRIBUTE_INTEGRATED", {"hipDeviceAttributeIntegrated", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 18
|
|
// cudaDevAttrCanMapHostMemory
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY", {"hipDeviceAttributeCanMapHostMemory", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 19
|
|
// cudaDevAttrComputeMode
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_MODE", {"hipDeviceAttributeComputeMode", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 20
|
|
// cudaDevAttrMaxTexture1DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH", {"hipDeviceAttributeMaxTexture1DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 21
|
|
// cudaDevAttrMaxTexture2DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH", {"hipDeviceAttributeMaxTexture2DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 22
|
|
// cudaDevAttrMaxTexture2DHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT", {"hipDeviceAttributeMaxTexture2DHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 23
|
|
// cudaDevAttrMaxTexture3DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH", {"hipDeviceAttributeMaxTexture3DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 24
|
|
// cudaDevAttrMaxTexture3DHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT", {"hipDeviceAttributeMaxTexture3DHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 25
|
|
// cudaDevAttrMaxTexture3DDepth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH", {"hipDeviceAttributeMaxTexture3DDepth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 26
|
|
// cudaDevAttrMaxTexture2DLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH", {"hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 27
|
|
// cudaDevAttrMaxTexture2DLayeredHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT", {"hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 28
|
|
// cudaDevAttrMaxTexture2DLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS", {"hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 29
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
|
|
// cudaDevAttrMaxTexture2DLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH", {"hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 27
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
|
|
// cudaDevAttrMaxTexture2DLayeredHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT", {"hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 28
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
|
|
// cudaDevAttrMaxTexture2DLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES", {"hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 29
|
|
// cudaDevAttrSurfaceAlignment
|
|
{"CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT", {"hipDeviceAttributeSurfaceAlignment", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 30
|
|
// cudaDevAttrConcurrentKernels
|
|
{"CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS", {"hipDeviceAttributeConcurrentKernels", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 31
|
|
// cudaDevAttrEccEnabled
|
|
{"CU_DEVICE_ATTRIBUTE_ECC_ENABLED", {"hipDeviceAttributeEccEnabled", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 32
|
|
// cudaDevAttrPciBusId
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_BUS_ID", {"hipDeviceAttributePciBusId", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 33
|
|
// cudaDevAttrPciDeviceId
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID", {"hipDeviceAttributePciDeviceId", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 34
|
|
// cudaDevAttrTccDriver
|
|
{"CU_DEVICE_ATTRIBUTE_TCC_DRIVER", {"hipDeviceAttributeTccDriver", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 35
|
|
// cudaDevAttrMemoryClockRate
|
|
{"CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE", {"hipDeviceAttributeMemoryClockRate", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 36
|
|
// cudaDevAttrGlobalMemoryBusWidth
|
|
{"CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH", {"hipDeviceAttributeMemoryBusWidth", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 37
|
|
// cudaDevAttrL2CacheSize
|
|
{"CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE", {"hipDeviceAttributeL2CacheSize", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 38
|
|
// cudaDevAttrMaxThreadsPerMultiProcessor
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR", {"hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 39
|
|
// cudaDevAttrAsyncEngineCount
|
|
{"CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT", {"hipDeviceAttributeAsyncEngineCount", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 40
|
|
// cudaDevAttrUnifiedAddressing
|
|
{"CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING", {"hipDeviceAttributeUnifiedAddressing", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 41
|
|
// cudaDevAttrMaxTexture1DLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH", {"hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 42
|
|
// cudaDevAttrMaxTexture1DLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS", {"hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 43
|
|
// Deprecated, do not use
|
|
// no analogue
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER", {"hipDeviceAttributeCanTex2DGather", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 44
|
|
// cudaDevAttrMaxTexture2DGatherWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH", {"hipDeviceAttributeMaxTexture2DGatherWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 45
|
|
// cudaDevAttrMaxTexture2DGatherHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT", {"hipDeviceAttributeMaxTexture2DGatherHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 46
|
|
// cudaDevAttrMaxTexture3DWidthAlt
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE", {"hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 47
|
|
// cudaDevAttrMaxTexture3DHeightAlt
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE", {"hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 48
|
|
// cudaDevAttrMaxTexture3DDepthAlt
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE", {"hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 49
|
|
// cudaDevAttrPciDomainId
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID", {"hipDeviceAttributePciDomainId", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 50
|
|
// cudaDevAttrTexturePitchAlignment
|
|
{"CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT", {"hipDeviceAttributeTexturePitchAlignment", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 51
|
|
// cudaDevAttrMaxTextureCubemapWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH", {"hipDeviceAttributeMaxTextureCubemapWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 52
|
|
// cudaDevAttrMaxTextureCubemapLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH", {"hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 53
|
|
// cudaDevAttrMaxTextureCubemapLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS", {"hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 54
|
|
// cudaDevAttrMaxSurface1DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH", {"hipDeviceAttributeMaxSurface1DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 55
|
|
// cudaDevAttrMaxSurface2DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH", {"hipDeviceAttributeMaxSurface2DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 56
|
|
// cudaDevAttrMaxSurface2DHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT", {"hipDeviceAttributeMaxSurface2DHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 57
|
|
// cudaDevAttrMaxSurface3DWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH", {"hipDeviceAttributeMaxSurface3DWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 58
|
|
// cudaDevAttrMaxSurface3DHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT", {"hipDeviceAttributeMaxSurface3DHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 59
|
|
// cudaDevAttrMaxSurface3DDepth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH", {"hipDeviceAttributeMaxSurface3DDepth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 60
|
|
// cudaDevAttrMaxSurface1DLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH", {"hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 61
|
|
// cudaDevAttrMaxSurface1DLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS", {"hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 62
|
|
// cudaDevAttrMaxSurface2DLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH", {"hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 63
|
|
// cudaDevAttrMaxSurface2DLayeredHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT", {"hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 64
|
|
// cudaDevAttrMaxSurface2DLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS", {"hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 65
|
|
// cudaDevAttrMaxSurfaceCubemapWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH", {"hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 66
|
|
// cudaDevAttrMaxSurfaceCubemapLayeredWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH", {"hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 67
|
|
// cudaDevAttrMaxSurfaceCubemapLayeredLayers
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS", {"hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 68
|
|
// cudaDevAttrMaxTexture1DLinearWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH", {"hipDeviceAttributeMaxTexture1DLinearWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 69
|
|
// cudaDevAttrMaxTexture2DLinearWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH", {"hipDeviceAttributeMaxTexture2DLinearWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 70
|
|
// cudaDevAttrMaxTexture2DLinearHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT", {"hipDeviceAttributeMaxTexture2DLinearHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 71
|
|
// cudaDevAttrMaxTexture2DLinearPitch
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH", {"hipDeviceAttributeMaxTexture2DLinearPitch", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 72
|
|
// cudaDevAttrMaxTexture2DMipmappedWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH", {"hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 73
|
|
// cudaDevAttrMaxTexture2DMipmappedHeight
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT", {"hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 74
|
|
// cudaDevAttrComputeCapabilityMajor
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR", {"hipDeviceAttributeComputeCapabilityMajor", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 75
|
|
// cudaDevAttrComputeCapabilityMinor
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR", {"hipDeviceAttributeComputeCapabilityMinor", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 76
|
|
// cudaDevAttrMaxTexture1DMipmappedWidth
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH", {"hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 77
|
|
// cudaDevAttrStreamPrioritiesSupported
|
|
{"CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED", {"hipDeviceAttributeStreamPrioritiesSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 78
|
|
// cudaDevAttrGlobalL1CacheSupported
|
|
{"CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED", {"hipDeviceAttributeGlobalL1CacheSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 79
|
|
// cudaDevAttrLocalL1CacheSupported
|
|
{"CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED", {"hipDeviceAttributeLocalL1CacheSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 80
|
|
// cudaDevAttrMaxSharedMemoryPerMultiprocessor
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR", {"hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 81
|
|
// cudaDevAttrMaxRegistersPerMultiprocessor
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR", {"hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 82
|
|
// cudaDevAttrManagedMemory
|
|
{"CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY", {"hipDeviceAttributeManagedMemory", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 83
|
|
// cudaDevAttrIsMultiGpuBoard
|
|
{"CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD", {"hipDeviceAttributeIsMultiGpuBoard", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 84
|
|
// cudaDevAttrMultiGpuBoardGroupID
|
|
{"CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID", {"hipDeviceAttributeMultiGpuBoardGroupId", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 85
|
|
// cudaDevAttrHostNativeAtomicSupported
|
|
{"CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED", {"hipDeviceAttributeHostNativeAtomicSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 86
|
|
// cudaDevAttrSingleToDoublePrecisionPerfRatio
|
|
{"CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO", {"hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 87
|
|
// cudaDevAttrPageableMemoryAccess
|
|
{"CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS", {"hipDeviceAttributePageableMemoryAccess", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 88
|
|
// cudaDevAttrConcurrentManagedAccess
|
|
{"CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS", {"hipDeviceAttributeConcurrentManagedAccess", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 89
|
|
// cudaDevAttrComputePreemptionSupported
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED", {"hipDeviceAttributeComputePreemptionSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 90
|
|
// cudaDevAttrCanUseHostPointerForRegisteredMem
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM", {"hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 91
|
|
// no analogue: cudaDevAttrReserved92
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS", {"hipDeviceAttributeCanUseStreamMemOps", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 92
|
|
// no analogue: cudaDevAttrReserved93
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS", {"hipDeviceAttributeCanUse64BitStreamMemOps", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 93
|
|
// no analogue: cudaDevAttrReserved94
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR", {"hipDeviceAttributeCanUseStreamWaitValueNor", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 94
|
|
// cudaDevAttrCooperativeLaunch
|
|
{"CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH", {"hipDeviceAttributeCooperativeLaunch", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 95
|
|
// cudaDevAttrCooperativeMultiDeviceLaunch
|
|
{"CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH", {"hipDeviceAttributeCooperativeMultiDeviceLaunch", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 96
|
|
// cudaDevAttrMaxSharedMemoryPerBlockOptin
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN", {"hipDeviceAttributeMaxSharedMemoryPerBlockOptin", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 97
|
|
// cudaDevAttrCanFlushRemoteWrites
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES", {"hipDeviceAttributeCanFlushRemoteWrites", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 98
|
|
// cudaDevAttrHostRegisterSupported
|
|
{"CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED", {"hipDeviceAttributeHostRegisterSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 99
|
|
// cudaDevAttrPageableMemoryAccessUsesHostPageTables
|
|
{"CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES", {"hipDeviceAttributePageableMemoryAccessUsesHostPageTables", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 100
|
|
// cudaDevAttrDirectManagedMemAccessFromHost
|
|
{"CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST", {"hipDeviceAttributeDirectManagedMemAccessFromHost", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 101
|
|
// no analogue
|
|
{"CU_DEVICE_ATTRIBUTE_MAX", {"hipDeviceAttributeMax", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 102
|
|
|
|
// cudaDeviceP2PAttr
|
|
{"CUdevice_P2PAttribute", {"hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUdevice_P2PAttribute_enum", {"hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUdevice_P2PAttribute enum values
|
|
// cudaDevP2PAttrPerformanceRank = 1
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK", {"hipDeviceP2PAttributePerformanceRank", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaDevP2PAttrAccessSupported = 2
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED", {"hipDeviceP2PAttributeAccessSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaDevP2PAttrNativeAtomicSupported = 3
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED", {"hipDeviceP2PAttributeNativeAtomicSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
// cudaDevP2PAttrCudaArrayAccessSupported = 4
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_ARRAY_ACCESS_ACCESS_SUPPORTED", {"hipDeviceP2PAttributeArrayAccessSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
// cudaDevP2PAttrCudaArrayAccessSupported = 4
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED", {"hipDeviceP2PAttributeArrayAccessSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
|
|
// cudaEGL.h - presented only on Linux in nvidia-cuda-dev package
|
|
// cudaEglColorFormat
|
|
{"CUeglColorFormat", {"hipEglColorFormat", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUeglColorFormate_enum", {"hipEglColorFormat", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUeglColorFormat enum values
|
|
// cudaEglColorFormatYUV420Planar = 0
|
|
{"CU_EGL_COLOR_FORMAT_YUV420_PLANAR", {"hipEglColorFormatYUV420Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaEglColorFormatYUV420SemiPlanar = 1
|
|
{"CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR", {"hipEglColorFormatYUV420SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaEglColorFormatYUV422Planar = 2
|
|
{"CU_EGL_COLOR_FORMAT_YUV422_PLANAR", {"hipEglColorFormatYUV422Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaEglColorFormatYUV422SemiPlanar = 3
|
|
{"CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR", {"hipEglColorFormatYUV422SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
// cudaEglColorFormatRGB = 4
|
|
{"CU_EGL_COLOR_FORMAT_RGB", {"hipEglColorFormatRGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
// cudaEglColorFormatBGR = 5
|
|
{"CU_EGL_COLOR_FORMAT_BGR", {"hipEglColorFormatBGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x05
|
|
// cudaEglColorFormatARGB = 6
|
|
{"CU_EGL_COLOR_FORMAT_ARGB", {"hipEglColorFormatARGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x06
|
|
// cudaEglColorFormatRGBA = 7
|
|
{"CU_EGL_COLOR_FORMAT_RGBA", {"hipEglColorFormatRGBA", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x07
|
|
// cudaEglColorFormatL = 8
|
|
{"CU_EGL_COLOR_FORMAT_L", {"hipEglColorFormatL", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
// cudaEglColorFormatR = 9
|
|
{"CU_EGL_COLOR_FORMAT_R", {"hipEglColorFormatR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x09
|
|
// cudaEglColorFormatYUV444Planar = 10
|
|
{"CU_EGL_COLOR_FORMAT_YUV444_PLANAR", {"hipEglColorFormatYUV444Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0A
|
|
// cudaEglColorFormatYUV444SemiPlanar = 11
|
|
{"CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR", {"hipEglColorFormatYUV444SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0B
|
|
// cudaEglColorFormatYUYV422 = 12
|
|
{"CU_EGL_COLOR_FORMAT_YUYV_422", {"hipEglColorFormatYUYV422", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0C
|
|
// cudaEglColorFormatUYVY422 = 13
|
|
{"CU_EGL_COLOR_FORMAT_UYVY_422", {"hipEglColorFormatUYVY422", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0D
|
|
// cudaEglColorFormatABGR = 14
|
|
{"CU_EGL_COLOR_FORMAT_ABGR", {"hipEglColorFormatABGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0E
|
|
// cudaEglColorFormatBGRA = 15
|
|
{"CU_EGL_COLOR_FORMAT_BGRA", {"hipEglColorFormatBGRA", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0F
|
|
// cudaEglColorFormatA = 16
|
|
{"CU_EGL_COLOR_FORMAT_A", {"hipEglColorFormatA", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
// cudaEglColorFormatRG = 17
|
|
{"CU_EGL_COLOR_FORMAT_RG", {"hipEglColorFormatRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x11
|
|
// cudaEglColorFormatAYUV = 18
|
|
{"CU_EGL_COLOR_FORMAT_AYUV", {"hipEglColorFormatAYUV", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x12
|
|
// cudaEglColorFormatYVU444SemiPlanar = 19
|
|
{"CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR", {"hipEglColorFormatYVU444SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x13
|
|
// cudaEglColorFormatYVU422SemiPlanar = 20
|
|
{"CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR", {"hipEglColorFormatYVU422SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x14
|
|
// cudaEglColorFormatYVU420SemiPlanar = 21
|
|
{"CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR", {"hipEglColorFormatYVU420SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x15
|
|
// cudaEglColorFormatYVU420SemiPlanar = 22
|
|
{"CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR", {"hipEglColorFormatY10V10U10_444SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x16
|
|
// cudaEglColorFormatY10V10U10_420SemiPlanar = 23
|
|
{"CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR", {"hipEglColorFormatY10V10U10_420SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x17
|
|
// cudaEglColorFormatY12V12U12_444SemiPlanar = 24
|
|
{"CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR", {"hipEglColorFormatY12V12U12_444SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x18
|
|
// cudaEglColorFormatY12V12U12_420SemiPlanar = 25
|
|
{"CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR", {"hipEglColorFormatY12V12U12_420SemiPlanar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x19
|
|
// cudaEglColorFormatVYUY_ER = 26
|
|
{"CU_EGL_COLOR_FORMAT_VYUY_ER", {"hipEglColorFormatVYUY_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1A
|
|
// cudaEglColorFormatUYVY_ER = 27
|
|
{"CU_EGL_COLOR_FORMAT_UYVY_ER", {"hipEglColorFormatUYVY_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1B
|
|
// cudaEglColorFormatYUYV_ER = 28
|
|
{"CU_EGL_COLOR_FORMAT_YUYV_ER", {"hipEglColorFormatYUYV_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1C
|
|
// cudaEglColorFormatYVYU_ER = 29
|
|
{"CU_EGL_COLOR_FORMAT_YVYU_ER", {"hipEglColorFormatYVYU_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1D
|
|
// cudaEglColorFormatYUV_ER = 30
|
|
{"CU_EGL_COLOR_FORMAT_YUV_ER", {"hipEglColorFormatYUV_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1E
|
|
// cudaEglColorFormatYUVA_ER = 31
|
|
{"CU_EGL_COLOR_FORMAT_YUVA_ER", {"hipEglColorFormatYUVA_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1F
|
|
// cudaEglColorFormatAYUV_ER = 32
|
|
{"CU_EGL_COLOR_FORMAT_AYUV_ER", {"hipEglColorFormatAYUV_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x20
|
|
// cudaEglColorFormatYUV444Planar_ER = 33
|
|
{"CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER", {"hipEglColorFormatYUV444Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x21
|
|
// cudaEglColorFormatYUV422Planar_ER = 34
|
|
{"CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER", {"hipEglColorFormatYUV422Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x22
|
|
// cudaEglColorFormatYUV420Planar_ER = 35
|
|
{"CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER", {"hipEglColorFormatYUV420Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x23
|
|
// cudaEglColorFormatYUV444SemiPlanar_ER = 36
|
|
{"CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER", {"hipEglColorFormatYUV444SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x24
|
|
// cudaEglColorFormatYUV422SemiPlanar_ER = 37
|
|
{"CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER", {"hipEglColorFormatYUV422SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x25
|
|
// cudaEglColorFormatYUV420SemiPlanar_ER = 38
|
|
{"CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER", {"hipEglColorFormatYUV420SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x26
|
|
// cudaEglColorFormatYVU444Planar_ER = 39
|
|
{"CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER", {"hipEglColorFormatYVU444Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x27
|
|
// cudaEglColorFormatYVU422Planar_ER = 40
|
|
{"CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER", {"hipEglColorFormatYVU422Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x28
|
|
// cudaEglColorFormatYVU420Planar_ER = 41
|
|
{"CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER", {"hipEglColorFormatYVU420Planar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x29
|
|
// cudaEglColorFormatYVU444SemiPlanar_ER = 42
|
|
{"CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER", {"hipEglColorFormatYVU444SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2A
|
|
// cudaEglColorFormatYVU422SemiPlanar_ER = 43
|
|
{"CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER", {"hipEglColorFormatYVU422SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2B
|
|
// cudaEglColorFormatYVU420SemiPlanar_ER = 44
|
|
{"CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER", {"hipEglColorFormatYVU420SemiPlanar_ER", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2C
|
|
// cudaEglColorFormatBayerRGGB = 45
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_RGGB", {"hipEglColorFormatBayerRGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2D
|
|
// cudaEglColorFormatBayerBGGR = 46
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_BGGR", {"hipEglColorFormatBayerBGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2E
|
|
// cudaEglColorFormatBayerGRBG = 47
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_GRBG", {"hipEglColorFormatBayerGRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2F
|
|
// cudaEglColorFormatBayerGBRG = 48
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_GBRG", {"hipEglColorFormatBayerGBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x30
|
|
// cudaEglColorFormatBayer10RGGB = 49
|
|
{"CU_EGL_COLOR_FORMAT_BAYER10_RGGB", {"hipEglColorFormatBayer10RGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x31
|
|
// cudaEglColorFormatBayer10BGGR = 50
|
|
{"CU_EGL_COLOR_FORMAT_BAYER10_BGGR", {"hipEglColorFormatBayer10BGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x32
|
|
// cudaEglColorFormatBayer10GRBG = 51
|
|
{"CU_EGL_COLOR_FORMAT_BAYER10_GRBG", {"hipEglColorFormatBayer10GRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x33
|
|
// cudaEglColorFormatBayer10GBRG = 52
|
|
{"CU_EGL_COLOR_FORMAT_BAYER10_GBRG", {"hipEglColorFormatBayer10GBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x34
|
|
// cudaEglColorFormatBayer12RGGB = 53
|
|
{"CU_EGL_COLOR_FORMAT_BAYER12_RGGB", {"hipEglColorFormatBayer12RGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x35
|
|
// cudaEglColorFormatBayer12BGGR = 54
|
|
{"CU_EGL_COLOR_FORMAT_BAYER12_BGGR", {"hipEglColorFormatBayer12BGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x36
|
|
// cudaEglColorFormatBayer12GRBG = 55
|
|
{"CU_EGL_COLOR_FORMAT_BAYER12_GRBG", {"hipEglColorFormatBayer12GRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x37
|
|
// cudaEglColorFormatBayer12GBRG = 56
|
|
{"CU_EGL_COLOR_FORMAT_BAYER12_GBRG", {"hipEglColorFormatBayer12GBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x38
|
|
// cudaEglColorFormatBayer14RGGB = 57
|
|
{"CU_EGL_COLOR_FORMAT_BAYER14_RGGB", {"hipEglColorFormatBayer14RGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x39
|
|
// cudaEglColorFormatBayer14BGGR = 58
|
|
{"CU_EGL_COLOR_FORMAT_BAYER14_BGGR", {"hipEglColorFormatBayer14BGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3A
|
|
// cudaEglColorFormatBayer14GRBG = 59
|
|
{"CU_EGL_COLOR_FORMAT_BAYER14_GRBG", {"hipEglColorFormatBayer14GRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3B
|
|
// cudaEglColorFormatBayer14GBRG = 60
|
|
{"CU_EGL_COLOR_FORMAT_BAYER14_GBRG", {"hipEglColorFormatBayer14GBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3C
|
|
// cudaEglColorFormatBayer20RGGB = 61
|
|
{"CU_EGL_COLOR_FORMAT_BAYER20_RGGB", {"hipEglColorFormatBayer20RGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3D
|
|
// cudaEglColorFormatBayer20BGGR = 62
|
|
{"CU_EGL_COLOR_FORMAT_BAYER20_BGGR", {"hipEglColorFormatBayer20BGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3E
|
|
// cudaEglColorFormatBayer20GRBG = 63
|
|
{"CU_EGL_COLOR_FORMAT_BAYER20_GRBG", {"hipEglColorFormatBayer20GRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x3F
|
|
// cudaEglColorFormatBayer20GBRG = 64
|
|
{"CU_EGL_COLOR_FORMAT_BAYER20_GBRG", {"hipEglColorFormatBayer20GBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x40
|
|
// cudaEglColorFormatYVU444Planar = 65
|
|
{"CU_EGL_COLOR_FORMAT_YVU444_PLANAR", {"hipEglColorFormatYVU444Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x41
|
|
// cudaEglColorFormatYVU422Planar = 66
|
|
{"CU_EGL_COLOR_FORMAT_YVU422_PLANAR", {"hipEglColorFormatYVU422Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x42
|
|
// cudaEglColorFormatYVU420Planar = 67
|
|
{"CU_EGL_COLOR_FORMAT_YVU420_PLANAR", {"hipEglColorFormatYVU420Planar", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x43
|
|
// cudaEglColorFormatBayerIspRGGB = 68
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB", {"hipEglColorFormatBayerIspRGGB", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x44
|
|
// cudaEglColorFormatBayerIspBGGR = 69
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR", {"hipEglColorFormatBayerIspBGGR", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x45
|
|
// cudaEglColorFormatBayerIspGRBG = 70
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG", {"hipEglColorFormatBayerIspGRBG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x46
|
|
// cudaEglColorFormatBayerIspGBRG = 71
|
|
{"CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG", {"hipEglColorFormatBayerIspGBRG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x47
|
|
// no analogue
|
|
{"CU_EGL_COLOR_FORMAT_MAX", {"hipEglColorFormatMax", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x48
|
|
|
|
// cudaEglFrameType
|
|
{"CUeglFrameType", {"hipEglFrameType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUeglFrameType_enum", {"hipEglFrameType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUeglFrameType enum values
|
|
// cudaEglFrameTypeArray
|
|
{"CU_EGL_FRAME_TYPE_ARRAY", {"hipEglFrameTypeArray", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// cudaEglFrameTypePitch
|
|
{"CU_EGL_FRAME_TYPE_PITCH", {"hipEglFrameTypePitch", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
|
|
// cudaEglResourceLocationFlags
|
|
{"CUeglResourceLocationFlags", {"hipEglResourceLocationFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUeglResourceLocationFlags_enum", {"hipEglResourceLocationFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUeglResourceLocationFlags enum values
|
|
// cudaEglResourceLocationSysmem
|
|
{"CU_EGL_RESOURCE_LOCATION_SYSMEM", {"hipEglResourceLocationSysmem", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaEglResourceLocationVidmem
|
|
{"CU_EGL_RESOURCE_LOCATION_VIDMEM", {"hipEglResourceLocationVidmem", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
|
|
// no analogue
|
|
{"CUevent_flags", {"hipEventFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUevent_flags_enum", {"hipEventFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUevent_flags enum values
|
|
// cudaEventDefault
|
|
{"CU_EVENT_DEFAULT", {"hipEventDefault", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x00
|
|
// cudaEventBlockingSync
|
|
{"CU_EVENT_BLOCKING_SYNC", {"hipEventBlockingSync", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x01
|
|
// cudaEventDisableTiming
|
|
{"CU_EVENT_DISABLE_TIMING", {"hipEventDisableTiming", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
// cudaEventInterprocess
|
|
{"CU_EVENT_INTERPROCESS", {"hipEventInterprocess", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x04
|
|
|
|
// cudaExternalMemoryHandleType
|
|
{"CUexternalMemoryHandleType", {"hipExternalMemoryHandleType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUexternalMemoryHandleType_enum", {"hipExternalMemoryHandleType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUexternalMemoryHandleType enum values
|
|
// cudaExternalMemoryHandleTypeOpaqueFd
|
|
{"CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD", {"hipExternalMemoryHandleTypeOpaqueFD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaExternalMemoryHandleTypeOpaqueWin32
|
|
{"CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32", {"hipExternalMemoryHandleTypeOpaqueWin32", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// cudaExternalMemoryHandleTypeOpaqueWin32Kmt
|
|
{"CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT", {"hipExternalMemoryHandleTypeOpaqueWin32KMT", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// cudaExternalMemoryHandleTypeD3D12Heap
|
|
{"CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP", {"hipExternalMemoryHandleTypeD3D12Heap", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
// cudaExternalMemoryHandleTypeD3D12Resource
|
|
{"CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE", {"hipExternalMemoryHandleTypeD3D12Resource", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
|
|
// cudaExternalSemaphoreHandleType
|
|
{"CUexternalSemaphoreHandleType_enum", {"hipExternalSemaphoreHandleType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUexternalSemaphoreHandleType", {"hipExternalSemaphoreHandleType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUexternalSemaphoreHandleType enum values
|
|
// cudaExternalSemaphoreHandleTypeOpaqueFd
|
|
{"CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD", {"hipExternalSemaphoreHandleTypeOpaqueFD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaExternalSemaphoreHandleTypeOpaqueWin32
|
|
{"CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32", {"hipExternalSemaphoreHandleTypeOpaqueWin32", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt
|
|
{"CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT", {"hipExternalSemaphoreHandleTypeOpaqueWin32KMT", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// cudaExternalSemaphoreHandleTypeD3D12Fence
|
|
{"CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE", {"hipExternalSemaphoreHandleTypeD3D12Fence", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
|
|
// cudaTextureFilterMode
|
|
{"CUfilter_mode", {"hipTextureFilterMode", CONV_TYPE, API_DRIVER}},
|
|
{"CUfilter_mode_enum", {"hipTextureFilterMode", CONV_TYPE, API_DRIVER}},
|
|
// CUfilter_mode enum values
|
|
// cudaFilterModePoint
|
|
{"CU_TR_FILTER_MODE_POINT", {"hipFilterModePoint", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0
|
|
// cudaFilterModeLinear
|
|
{"CU_TR_FILTER_MODE_LINEAR", {"hipFilterModeLinear", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 1
|
|
|
|
// cudaFuncCache
|
|
{"CUfunc_cache", {"hipFuncCache", CONV_TYPE, API_DRIVER}},
|
|
{"CUfunc_cache_enum", {"hipFuncCache", CONV_TYPE, API_DRIVER}},
|
|
// CUfunc_cache enum values
|
|
// cudaFilterModePoint = 0
|
|
{"CU_FUNC_CACHE_PREFER_NONE", {"hipFuncCachePreferNone", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x00
|
|
// cudaFuncCachePreferShared = 1
|
|
{"CU_FUNC_CACHE_PREFER_SHARED", {"hipFuncCachePreferShared", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x01
|
|
// cudaFuncCachePreferL1 = 2
|
|
{"CU_FUNC_CACHE_PREFER_L1", {"hipFuncCachePreferL1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
// cudaFuncCachePreferEqual = 3
|
|
{"CU_FUNC_CACHE_PREFER_EQUAL", {"hipFuncCachePreferEqual", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x03
|
|
|
|
// cudaFuncAttribute
|
|
{"CUfunction_attribute", {"hipFuncAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUfunction_attribute_enum", {"hipFuncAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUfunction_attribute enum values
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK", {"hipFuncAttributeMaxThreadsPerBlocks", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES", {"hipFuncAttributeSharedSizeBytes", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES", {"hipFuncAttributeConstSizeBytes", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES", {"hipFuncAttributeLocalSizeBytes", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_NUM_REGS", {"hipFuncAttributeNumRegs", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_PTX_VERSION", {"hipFuncAttributePtxVersion", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_BINARY_VERSION", {"hipFuncAttributeBinaryVersion", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 6
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_CACHE_MODE_CA", {"hipFuncAttributeCacheModeCA", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 7
|
|
// cudaFuncAttributeMaxDynamicSharedMemorySize
|
|
{"CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES", {"hipFuncAttributeMaxDynamicSharedMemorySize", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 8
|
|
// cudaFuncAttributePreferredSharedMemoryCarveout
|
|
{"CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT", {"hipFuncAttributePreferredSharedMemoryCarveout", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 9
|
|
// no analogue
|
|
{"CU_FUNC_ATTRIBUTE_MAX", {"hipFuncAttributeMax", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 10
|
|
|
|
//cudaGraphicsMapFlags
|
|
{"CUgraphicsMapResourceFlags", {"hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUgraphicsMapResourceFlags_enum", {"hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUgraphicsMapResourceFlags enum values
|
|
// cudaGraphicsMapFlagsNone = 0
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE", {"hipGraphicsMapFlagsNone", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaGraphicsMapFlagsReadOnly = 1
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY", {"hipGraphicsMapFlagsReadOnly", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaGraphicsMapFlagsWriteDiscard = 2
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD", {"hipGraphicsMapFlagsWriteDiscard", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
|
|
// cudaGraphicsRegisterFlags
|
|
{"CUgraphicsRegisterFlags", {"hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUgraphicsRegisterFlags_enum", {"hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraphicsRegisterFlags enum values
|
|
//cudaGraphicsRegisterFlagsNone = 0
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_NONE", {"hipGraphicsRegisterFlagsNone", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaGraphicsRegisterFlagsReadOnly = 1
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY", {"hipGraphicsRegisterFlagsReadOnly", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
//cudaGraphicsRegisterFlagsWriteDiscard = 2
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD", {"hipGraphicsRegisterFlagsWriteDiscard", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaGraphicsRegisterFlagsSurfaceLoadStore = 4
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST", {"hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
// cudaGraphicsRegisterFlagsTextureGather = 8
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER", {"hipGraphicsRegisterFlagsTextureGather", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
|
|
// cudaGraphNodeType
|
|
{"CUgraphNodeType", {"hipGraphNodeType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUgraphNodeType_enum", {"hipGraphNodeType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// cudaGraphNodeType enum values
|
|
// cudaGraphNodeTypeKernel = 0x00
|
|
{"CU_GRAPH_NODE_TYPE_KERNEL", {"hipGraphNodeTypeKernel", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// cudaGraphNodeTypeMemcpy = 0x01
|
|
{"CU_GRAPH_NODE_TYPE_MEMCPY", {"hipGraphNodeTypeMemcpy", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaGraphNodeTypeMemset = 0x02
|
|
{"CU_GRAPH_NODE_TYPE_MEMSET", {"hipGraphNodeTypeMemset", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// cudaGraphNodeTypeHost = 0x03
|
|
{"CU_GRAPH_NODE_TYPE_HOST", {"hipGraphNodeTypeHost", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// cudaGraphNodeTypeGraph = 0x04
|
|
{"CU_GRAPH_NODE_TYPE_GRAPH", {"hipGraphNodeTypeGraph", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
// cudaGraphNodeTypeEmpty = 0x05
|
|
{"CU_GRAPH_NODE_TYPE_EMPTY", {"hipGraphNodeTypeEmpty", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
// cudaGraphNodeTypeCount
|
|
{"CU_GRAPH_NODE_TYPE_COUNT", {"hipGraphNodeTypeCount", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 6
|
|
|
|
// no analogue
|
|
{"CUipcMem_flags", {"hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUipcMem_flags_enum", {"hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUipcMem_flags enum values
|
|
// cudaIpcMemLazyEnablePeerAccess
|
|
{"CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS", {"hipIpcMemLazyEnablePeerAccess", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1
|
|
|
|
// no analogue
|
|
{"CUjit_cacheMode", {"hipJitCacheMode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUjit_cacheMode_enum", {"hipJitCacheMode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUjit_cacheMode enum values
|
|
// no analogue
|
|
{"CU_JIT_CACHE_OPTION_NONE", {"hipJitCacheModeOptionNone", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// no analogue
|
|
{"CU_JIT_CACHE_OPTION_CG", {"hipJitCacheModeOptionCG", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// no analogue
|
|
{"CU_JIT_CACHE_OPTION_CA", {"hipJitCacheModeOptionCA", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// no analogue
|
|
{"CUjit_fallback", {"hipJitFallback", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUjit_fallback_enum", {"hipJitFallback", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUjit_fallback enum values
|
|
// no analogue
|
|
{"CU_PREFER_PTX", {"hipJitFallbackPreferPtx", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// no analogue
|
|
{"CU_PREFER_BINARY", {"hipJitFallbackPreferBinary", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// no analogue
|
|
// NOTE: is not used by HIP, as it has no JIT, thus just a dummy enum
|
|
{"CUjit_option", {"hipJitOption", CONV_TYPE, API_DRIVER}},
|
|
{"CUjit_option_enum", {"hipJitOption", CONV_TYPE, API_DRIVER}},
|
|
// CUjit_option enum values
|
|
{"CU_JIT_MAX_REGISTERS", {"hipJitOptionMaxRegisters", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0
|
|
{"CU_JIT_THREADS_PER_BLOCK", {"hipJitOptionThreadsPerBlock", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_WALL_TIME", {"hipJitOptionWallTime", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_INFO_LOG_BUFFER", {"hipJitOptionInfoLogBuffer", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES", {"hipJitOptionInfoLogBufferSizeBytes", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_ERROR_LOG_BUFFER", {"hipJitOptionErrorLogBuffer", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES", {"hipJitOptionErrorLogBufferSizeBytes", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_OPTIMIZATION_LEVEL", {"hipJitOptionOptimizationLevel", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_TARGET_FROM_CUCONTEXT", {"hipJitOptionTargetFromContext", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_TARGET", {"hipJitOptionTarget", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_FALLBACK_STRATEGY", {"hipJitOptionFallbackStrategy", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_GENERATE_DEBUG_INFO", {"hipJitOptionGenerateDebugInfo", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_LOG_VERBOSE", {"hipJitOptionLogVerbose", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_GENERATE_LINE_INFO", {"hipJitOptionGenerateLineInfo", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_CACHE_MODE", {"hipJitOptionCacheMode", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_NEW_SM3X_OPT", {"hipJitOptionSm3xOpt", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_FAST_COMPILE", {"hipJitOptionFastCompile", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_GLOBAL_SYMBOL_NAMES", {"hipJitGlobalSymbolNames", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_GLOBAL_SYMBOL_ADDRESSES", {"hipJitGlobalSymbolAddresses", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_GLOBAL_SYMBOL_COUNT", {"hipJitGlobalSymbolCount", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
{"CU_JIT_NUM_OPTIONS", {"hipJitOptionNumOptions", CONV_NUMERIC_LITERAL, API_DRIVER}},
|
|
|
|
// no analogue
|
|
{"CUjit_target", {"hipJitTarget", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUjit_target_enum", {"hipJitTarget", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUjit_target enum values
|
|
// Deprecated
|
|
{"CU_TARGET_COMPUTE_10", {"hipJitTargetCompute10", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 10
|
|
// Deprecated
|
|
{"CU_TARGET_COMPUTE_11", {"hipJitTargetCompute11", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 11
|
|
// Deprecated
|
|
{"CU_TARGET_COMPUTE_12", {"hipJitTargetCompute12", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 12
|
|
// Deprecated
|
|
{"CU_TARGET_COMPUTE_13", {"hipJitTargetCompute13", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 13
|
|
{"CU_TARGET_COMPUTE_20", {"hipJitTargetCompute20", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 20
|
|
{"CU_TARGET_COMPUTE_21", {"hipJitTargetCompute21", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 21
|
|
{"CU_TARGET_COMPUTE_30", {"hipJitTargetCompute30", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 20
|
|
{"CU_TARGET_COMPUTE_32", {"hipJitTargetCompute32", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 32
|
|
{"CU_TARGET_COMPUTE_35", {"hipJitTargetCompute35", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 35
|
|
{"CU_TARGET_COMPUTE_37", {"hipJitTargetCompute37", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 37
|
|
{"CU_TARGET_COMPUTE_50", {"hipJitTargetCompute50", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 50
|
|
{"CU_TARGET_COMPUTE_52", {"hipJitTargetCompute52", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 52
|
|
{"CU_TARGET_COMPUTE_53", {"hipJitTargetCompute53", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 53
|
|
{"CU_TARGET_COMPUTE_60", {"hipJitTargetCompute60", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 60
|
|
{"CU_TARGET_COMPUTE_61", {"hipJitTargetCompute61", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 61
|
|
{"CU_TARGET_COMPUTE_62", {"hipJitTargetCompute62", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 62
|
|
{"CU_TARGET_COMPUTE_70", {"hipJitTargetCompute70", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 70
|
|
// Deprecated
|
|
{"CU_TARGET_COMPUTE_73", {"hipJitTargetCompute73", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 73
|
|
{"CU_TARGET_COMPUTE_75", {"hipJitTargetCompute75", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 75
|
|
|
|
// no analogue
|
|
{"CUjitInputType", {"hipJitInputType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUjitInputType_enum", {"hipJitInputType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUjitInputType enum values
|
|
{"CU_JIT_INPUT_CUBIN", {"hipJitInputTypeBin", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
{"CU_JIT_INPUT_PTX", {"hipJitInputTypePtx", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_FATBINARY", {"hipJitInputTypeFatBinary", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_OBJECT", {"hipJitInputTypeObject", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_LIBRARY", {"hipJitInputTypeLibrary", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_NUM_INPUT_TYPES", {"hipJitInputTypeNumInputTypes", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaLimit
|
|
{"CUlimit", {"hipLimit_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUlimit_enum", {"hipLimit_t", CONV_TYPE, API_DRIVER}},
|
|
// CUlimit enum values
|
|
// cudaLimitStackSize
|
|
{"CU_LIMIT_STACK_SIZE", {"hipLimitStackSize", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
//cudaLimitPrintfFifoSize
|
|
{"CU_LIMIT_PRINTF_FIFO_SIZE", {"hipLimitPrintfFifoSize", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
//cudaLimitMallocHeapSize
|
|
{"CU_LIMIT_MALLOC_HEAP_SIZE", {"hipLimitMallocHeapSize", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
// cudaLimitDevRuntimeSyncDepth
|
|
{"CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH", {"hipLimitDevRuntimeSyncDepth", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
// cudaLimitDevRuntimePendingLaunchCount
|
|
{"CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT", {"hipLimitDevRuntimePendingLaunchCount", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
// cudaLimitMaxL2FetchGranularity
|
|
{"CU_LIMIT_MAX_L2_FETCH_GRANULARITY", {"hipLimitMaxL2FetchGranularity", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x05
|
|
// no analogue
|
|
{"CU_LIMIT_MAX", {"hipLimitMax", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaMemoryAdvise
|
|
{"CUmem_advise", {"hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUmem_advise_enum", {"hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUmem_advise enum values
|
|
// cudaMemAdviseSetReadMostly
|
|
{"CU_MEM_ADVISE_SET_READ_MOSTLY", {"hipMemAdviseSetReadMostly", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaMemAdviseUnsetReadMostly
|
|
{"CU_MEM_ADVISE_UNSET_READ_MOSTLY", {"hipMemAdviseUnsetReadMostly", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// cudaMemAdviseSetPreferredLocation
|
|
{"CU_MEM_ADVISE_SET_PREFERRED_LOCATION", {"hipMemAdviseSetPreferredLocation", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// cudaMemAdviseUnsetPreferredLocation
|
|
{"CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION", {"hipMemAdviseUnsetPreferredLocation", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
// cudaMemAdviseSetAccessedBy
|
|
{"CU_MEM_ADVISE_SET_ACCESSED_BY", {"hipMemAdviseSetAccessedBy", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
// cudaMemAdviseUnsetAccessedBy
|
|
{"CU_MEM_ADVISE_UNSET_ACCESSED_BY", {"hipMemAdviseUnsetAccessedBy", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 6
|
|
|
|
// no analogue
|
|
{"CUmemAttach_flags", {"hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUmemAttach_flags_enum", {"hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUmemAttach_flags enum values
|
|
// cudaMemAttachGlobal
|
|
{"CU_MEM_ATTACH_GLOBAL", {"hipMemAttachGlobal", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
// cudaMemAttachHost
|
|
{"CU_MEM_ATTACH_HOST", {"hipMemAttachHost", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2
|
|
// cudaMemAttachSingle
|
|
{"CU_MEM_ATTACH_SINGLE", {"hipMemAttachSingle", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x4
|
|
|
|
// no analogue
|
|
// NOTE: cudaMemoryType is not an analogue
|
|
{"CUmemorytype", {"hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUmemorytype_enum", {"hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUmemorytype enum values
|
|
{"CU_MEMORYTYPE_HOST", {"hipMemTypeHost", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_MEMORYTYPE_DEVICE", {"hipMemTypeDevice", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_MEMORYTYPE_ARRAY", {"hipMemTypeArray", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
{"CU_MEMORYTYPE_UNIFIED", {"hipMemTypeUnified", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
|
|
// cudaMemRangeAttribute
|
|
{"CUmem_range_attribute", {"hipMemRangeAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUmem_range_attribute_enum", {"hipMemRangeAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUmem_range_attribute enum values
|
|
// cudaMemRangeAttributeReadMostly
|
|
{"CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY", {"hipMemRangeAttributeReadMostly", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaMemRangeAttributePreferredLocation
|
|
{"CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION", {"hipMemRangeAttributePreferredLocation", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
// cudaMemRangeAttributeAccessedBy
|
|
{"CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY", {"hipMemRangeAttributeAccessedBy", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
// cudaMemRangeAttributeLastPrefetchLocation
|
|
{"CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION", {"hipMemRangeAttributeLastPrefetchLocation", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
|
|
//no analogue
|
|
{"CUoccupancy_flags", {"hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUoccupancy_flags_enum", {"hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUoccupancy_flags enum values
|
|
// cudaOccupancyDefault
|
|
{"CU_OCCUPANCY_DEFAULT", {"hipOccupancyDefault", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaOccupancyDisableCachingOverride
|
|
{"CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE", {"hipOccupancyDisableCachingOverride", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
|
|
// TODO: Analogous enum is needed in HIP. Couldn't map enum to struct hipPointerAttribute_t.
|
|
// TODO: Do the same for Pointer Attributes as for Device Attributes.
|
|
//no analogue
|
|
{"CUpointer_attribute", {"hipPointerAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUpointer_attribute_enum", {"hipPointerAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUpointer_attribute enum values
|
|
{"CU_POINTER_ATTRIBUTE_CONTEXT", {"hipPointerAttributeContext", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
{"CU_POINTER_ATTRIBUTE_MEMORY_TYPE", {"hipPointerAttributeMemoryType", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
{"CU_POINTER_ATTRIBUTE_DEVICE_POINTER", {"hipPointerAttributeDevicePointer", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
{"CU_POINTER_ATTRIBUTE_HOST_POINTER", {"hipPointerAttributeHostPointer", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
{"CU_POINTER_ATTRIBUTE_P2P_TOKENS", {"hipPointerAttributeP2pTokens", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
{"CU_POINTER_ATTRIBUTE_SYNC_MEMOPS", {"hipPointerAttributeSyncMemops", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 6
|
|
{"CU_POINTER_ATTRIBUTE_BUFFER_ID", {"hipPointerAttributeBufferId", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 7
|
|
{"CU_POINTER_ATTRIBUTE_IS_MANAGED", {"hipPointerAttributeIsManaged", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 8
|
|
{"CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL", {"hipPointerAttributeDeviceOrdinal", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 9
|
|
|
|
// cudaResourceType
|
|
{"CUresourcetype", {"hipResourceType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUresourcetype_enum", {"hipResourceType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUresourcetype enum values
|
|
// cudaResourceTypeArray
|
|
{"CU_RESOURCE_TYPE_ARRAY", {"hipResourceTypeArray", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
//cudaResourceTypeMipmappedArray
|
|
{"CU_RESOURCE_TYPE_MIPMAPPED_ARRAY", {"hipResourceTypeMipmappedArray", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
//cudaResourceTypeLinear
|
|
{"CU_RESOURCE_TYPE_LINEAR", {"hipResourceTypeLinear", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
//cudaResourceTypePitch2D
|
|
{"CU_RESOURCE_TYPE_PITCH2D", {"hipResourceTypePitch2D", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
|
|
// cudaResourceViewFormat
|
|
{"CUresourceViewFormat", {"hipResourceViewFormat", CONV_TYPE, API_DRIVER}},
|
|
{"CUresourceViewFormat_enum", {"hipResourceViewFormat", CONV_TYPE, API_DRIVER}},
|
|
// CUresourceViewFormat enum values
|
|
// cudaResViewFormatNone
|
|
{"CU_RES_VIEW_FORMAT_NONE", {"hipResViewFormatNone", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x00
|
|
// cudaResViewFormatUnsignedChar1
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X8", {"hipResViewFormatUnsignedChar1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x01
|
|
// cudaResViewFormatUnsignedChar2
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X8", {"hipResViewFormatUnsignedChar2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
// cudaResViewFormatUnsignedChar4
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X8", {"hipResViewFormatUnsignedChar4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x03
|
|
// cudaResViewFormatSignedChar1
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X8", {"hipResViewFormatSignedChar1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x04
|
|
// cudaResViewFormatSignedChar2
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X8", {"hipResViewFormatSignedChar2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x05
|
|
// cudaResViewFormatSignedChar4
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X8", {"hipResViewFormatSignedChar4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x06
|
|
// cudaResViewFormatUnsignedShort1
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X16", {"hipResViewFormatUnsignedShort1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x07
|
|
// cudaResViewFormatUnsignedShort2
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X16", {"hipResViewFormatUnsignedShort2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x08
|
|
// cudaResViewFormatUnsignedShort4
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X16", {"hipResViewFormatUnsignedShort4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x09
|
|
// cudaResViewFormatSignedShort1
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X16", {"hipResViewFormatSignedShort1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0a
|
|
// cudaResViewFormatSignedShort2
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X16", {"hipResViewFormatSignedShort2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0b
|
|
// cudaResViewFormatSignedShort4
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X16", {"hipResViewFormatSignedShort4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0c
|
|
// cudaResViewFormatUnsignedInt1
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X32", {"hipResViewFormatUnsignedInt1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0d
|
|
// cudaResViewFormatUnsignedInt2
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X32", {"hipResViewFormatUnsignedInt2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0e
|
|
// cudaResViewFormatUnsignedInt4
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X32", {"hipResViewFormatUnsignedInt4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0f
|
|
// cudaResViewFormatSignedInt1
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X32", {"hipResViewFormatSignedInt1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x10
|
|
// cudaResViewFormatSignedInt2
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X32", {"hipResViewFormatSignedInt2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x11
|
|
// cudaResViewFormatSignedInt4
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X32", {"hipResViewFormatSignedInt4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x12
|
|
// cudaResViewFormatHalf1
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_1X16", {"hipResViewFormatHalf1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x13
|
|
// cudaResViewFormatHalf2
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_2X16", {"hipResViewFormatHalf2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x14
|
|
// cudaResViewFormatHalf4
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_4X16", {"hipResViewFormatHalf4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x15
|
|
// cudaResViewFormatFloat1
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_1X32", {"hipResViewFormatFloat1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x16
|
|
// cudaResViewFormatFloat2
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_2X32", {"hipResViewFormatFloat2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x17
|
|
// cudaResViewFormatFloat4
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_4X32", {"hipResViewFormatFloat4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x18
|
|
// cudaResViewFormatUnsignedBlockCompressed1
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC1", {"hipResViewFormatUnsignedBlockCompressed1", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x19
|
|
// cudaResViewFormatUnsignedBlockCompressed2
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC2", {"hipResViewFormatUnsignedBlockCompressed2", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1a
|
|
// cudaResViewFormatUnsignedBlockCompressed3
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC3", {"hipResViewFormatUnsignedBlockCompressed3", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1b
|
|
// cudaResViewFormatUnsignedBlockCompressed4
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC4", {"hipResViewFormatUnsignedBlockCompressed4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1c
|
|
// cudaResViewFormatSignedBlockCompressed4
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC4", {"hipResViewFormatSignedBlockCompressed4", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1d
|
|
// cudaResViewFormatUnsignedBlockCompressed5
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC5", {"hipResViewFormatUnsignedBlockCompressed5", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1e
|
|
// cudaResViewFormatSignedBlockCompressed5
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC5", {"hipResViewFormatSignedBlockCompressed5", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1f
|
|
// cudaResViewFormatUnsignedBlockCompressed6H
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC6H", {"hipResViewFormatUnsignedBlockCompressed6H", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x20
|
|
// cudaResViewFormatSignedBlockCompressed6H
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC6H", {"hipResViewFormatSignedBlockCompressed6H", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x21
|
|
// cudaResViewFormatUnsignedBlockCompressed7
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC7", {"hipResViewFormatUnsignedBlockCompressed7", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x22
|
|
|
|
// cudaError
|
|
{"CUresult", {"hipError_t", CONV_TYPE, API_DRIVER}},
|
|
{"cudaError_enum", {"hipError_t", CONV_TYPE, API_DRIVER}},
|
|
// CUresult enum values
|
|
// cudaSuccess = 0
|
|
{"CUDA_SUCCESS", {"hipSuccess", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0
|
|
// cudaErrorInvalidValue = 11
|
|
{"CUDA_ERROR_INVALID_VALUE", {"hipErrorInvalidValue", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 1
|
|
// cudaErrorMemoryAllocation = 2
|
|
{"CUDA_ERROR_OUT_OF_MEMORY", {"hipErrorMemoryAllocation", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 2
|
|
// cudaErrorInitializationError = 3; hipErrorInitializationError = 1003
|
|
// TODO: the same error code should be merged into 1
|
|
{"CUDA_ERROR_NOT_INITIALIZED", {"hipErrorNotInitialized", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 3
|
|
// cudaErrorCudartUnloading = 29
|
|
// TODO: double check, that these errors match
|
|
{"CUDA_ERROR_DEINITIALIZED", {"hipErrorDeinitialized", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 4
|
|
// cudaErrorProfilerDisabled = 55
|
|
{"CUDA_ERROR_PROFILER_DISABLED", {"hipErrorProfilerDisabled", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 5
|
|
// Deprecated as of CUDA 5.0
|
|
// cudaErrorProfilerNotInitialized = 56
|
|
{"CUDA_ERROR_PROFILER_NOT_INITIALIZED", {"hipErrorProfilerNotInitialized", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 6
|
|
// Deprecated as of CUDA 5.0
|
|
// cudaErrorProfilerAlreadyStarted = 57
|
|
{"CUDA_ERROR_PROFILER_ALREADY_STARTED", {"hipErrorProfilerAlreadyStarted", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 7
|
|
// Deprecated as of CUDA 5.0
|
|
// cudaErrorProfilerAlreadyStopped = 58
|
|
{"CUDA_ERROR_PROFILER_ALREADY_STOPPED", {"hipErrorProfilerAlreadyStopped", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 8
|
|
// cudaErrorNoDevice = 38
|
|
{"CUDA_ERROR_NO_DEVICE", {"hipErrorNoDevice", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 100
|
|
// cudaErrorInvalidDevice = 10
|
|
{"CUDA_ERROR_INVALID_DEVICE", {"hipErrorInvalidDevice", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 101
|
|
// cudaErrorInvalidKernelImage = 47
|
|
// TODO: double check the matching
|
|
{"CUDA_ERROR_INVALID_IMAGE", {"hipErrorInvalidImage", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 200
|
|
// no analogue
|
|
{"CUDA_ERROR_INVALID_CONTEXT", {"hipErrorInvalidContext", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 201
|
|
// Deprecated as of CUDA 3.2
|
|
// no analogue
|
|
{"CUDA_ERROR_CONTEXT_ALREADY_CURRENT", {"hipErrorContextAlreadyCurrent", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 202
|
|
// cudaErrorMapBufferObjectFailed = 14
|
|
// TODO: double check the matching
|
|
{"CUDA_ERROR_MAP_FAILED", {"hipErrorMapFailed", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 205
|
|
// cudaErrorUnmapBufferObjectFailed = 15
|
|
// TODO: double check the matching
|
|
{"CUDA_ERROR_UNMAP_FAILED", {"hipErrorUnmapFailed", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 206
|
|
// no analogue
|
|
{"CUDA_ERROR_ARRAY_IS_MAPPED", {"hipErrorArrayIsMapped", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 207
|
|
// no analogue
|
|
{"CUDA_ERROR_ALREADY_MAPPED", {"hipErrorAlreadyMapped", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 208
|
|
// cudaErrorNoKernelImageForDevice = 48
|
|
// TODO: double check the matching
|
|
{"CUDA_ERROR_NO_BINARY_FOR_GPU", {"hipErrorNoBinaryForGpu", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 209
|
|
// no analogue
|
|
{"CUDA_ERROR_ALREADY_ACQUIRED", {"hipErrorAlreadyAcquired", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 210
|
|
// no analogue
|
|
{"CUDA_ERROR_NOT_MAPPED", {"hipErrorNotMapped", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 211
|
|
// no analogue
|
|
{"CUDA_ERROR_NOT_MAPPED_AS_ARRAY", {"hipErrorNotMappedAsArray", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 212
|
|
// no analogue
|
|
{"CUDA_ERROR_NOT_MAPPED_AS_POINTER", {"hipErrorNotMappedAsPointer", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 213
|
|
// cudaErrorECCUncorrectable = 39
|
|
{"CUDA_ERROR_ECC_UNCORRECTABLE", {"hipErrorECCNotCorrectable", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 214
|
|
// cudaErrorUnsupportedLimit = 42
|
|
{"CUDA_ERROR_UNSUPPORTED_LIMIT", {"hipErrorUnsupportedLimit", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 215
|
|
// no analogue
|
|
{"CUDA_ERROR_CONTEXT_ALREADY_IN_USE", {"hipErrorContextAlreadyInUse", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 216
|
|
// cudaErrorPeerAccessUnsupported = 64
|
|
{"CUDA_ERROR_PEER_ACCESS_UNSUPPORTED", {"hipErrorPeerAccessUnsupported", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 217
|
|
// cudaErrorInvalidPtx = 78
|
|
{"CUDA_ERROR_INVALID_PTX", {"hipErrorInvalidKernelFile", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 218
|
|
// cudaErrorInvalidGraphicsContext = 79
|
|
{"CUDA_ERROR_INVALID_GRAPHICS_CONTEXT", {"hipErrorInvalidGraphicsContext", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 219
|
|
// cudaErrorNvlinkUncorrectable = 80
|
|
{"CUDA_ERROR_NVLINK_UNCORRECTABLE", {"hipErrorNvlinkUncorrectable", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 220
|
|
// cudaErrorJitCompilerNotFound = 81
|
|
{"CUDA_ERROR_JIT_COMPILER_NOT_FOUND", {"hipErrorJitCompilerNotFound", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 221
|
|
// no analogue
|
|
{"CUDA_ERROR_INVALID_SOURCE", {"hipErrorInvalidSource", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 300
|
|
// no analogue
|
|
{"CUDA_ERROR_FILE_NOT_FOUND", {"hipErrorFileNotFound", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 301
|
|
// cudaErrorSharedObjectSymbolNotFound = 40
|
|
{"CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND", {"hipErrorSharedObjectSymbolNotFound", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 302
|
|
// cudaErrorSharedObjectInitFailed = 41
|
|
{"CUDA_ERROR_SHARED_OBJECT_INIT_FAILED", {"hipErrorSharedObjectInitFailed", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 303
|
|
// cudaErrorOperatingSystem = 63
|
|
{"CUDA_ERROR_OPERATING_SYSTEM", {"hipErrorOperatingSystem", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 304
|
|
// cudaErrorInvalidResourceHandle = 33
|
|
{"CUDA_ERROR_INVALID_HANDLE", {"hipErrorInvalidResourceHandle", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 400
|
|
// cudaErrorIllegalState = 84
|
|
{"CUDA_ERROR_ILLEGAL_STATE", {"hipErrorIllegalState", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 401
|
|
// no analogue
|
|
{"CUDA_ERROR_NOT_FOUND", {"hipErrorNotFound", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 500
|
|
// cudaErrorNotReady = 34
|
|
{"CUDA_ERROR_NOT_READY", {"hipErrorNotReady", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 600
|
|
// cudaErrorIllegalAddress = 77
|
|
{"CUDA_ERROR_ILLEGAL_ADDRESS", {"hipErrorIllegalAddress", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 700
|
|
// cudaErrorLaunchOutOfResources = 7
|
|
{"CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES", {"hipErrorLaunchOutOfResources", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 701
|
|
// cudaErrorLaunchTimeout = 6
|
|
{"CUDA_ERROR_LAUNCH_TIMEOUT", {"hipErrorLaunchTimeOut", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 702
|
|
// no analogue
|
|
{"CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING", {"hipErrorLaunchIncompatibleTexturing", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 703
|
|
// cudaErrorPeerAccessAlreadyEnabled = 50
|
|
{"CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED", {"hipErrorPeerAccessAlreadyEnabled", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 704
|
|
// cudaErrorPeerAccessNotEnabled = 51
|
|
{"CUDA_ERROR_PEER_ACCESS_NOT_ENABLED", {"hipErrorPeerAccessNotEnabled", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 705
|
|
// no analogue
|
|
{"CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE", {"hipErrorPrimaryContextActive", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 708
|
|
// no analogue
|
|
{"CUDA_ERROR_CONTEXT_IS_DESTROYED", {"hipErrorContextIsDestroyed", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 709
|
|
// cudaErrorAssert = 59
|
|
{"CUDA_ERROR_ASSERT", {"hipErrorAssert", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 710
|
|
// cudaErrorTooManyPeers = 60
|
|
{"CUDA_ERROR_TOO_MANY_PEERS", {"hipErrorTooManyPeers", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 711
|
|
// = cudaErrorHostMemoryAlreadyRegistered = 61
|
|
{"CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED", {"hipErrorHostMemoryAlreadyRegistered", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 712
|
|
// cudaErrorHostMemoryNotRegistered = 62
|
|
{"CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED", {"hipErrorHostMemoryNotRegistered", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 713
|
|
// cudaErrorHardwareStackError= 72
|
|
{"CUDA_ERROR_HARDWARE_STACK_ERROR", {"hipErrorHardwareStackError", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 714
|
|
// cudaErrorIllegalInstruction = 73
|
|
{"CUDA_ERROR_ILLEGAL_INSTRUCTION", {"hipErrorIllegalInstruction", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 715
|
|
// cudaErrorMisalignedAddress= 74
|
|
{"CUDA_ERROR_MISALIGNED_ADDRESS", {"hipErrorMisalignedAddress", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 716
|
|
// cudaErrorInvalidAddressSpace= 75
|
|
{"CUDA_ERROR_INVALID_ADDRESS_SPACE", {"hipErrorInvalidAddressSpace", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 717
|
|
// cudaErrorInvalidPc = 76
|
|
{"CUDA_ERROR_INVALID_PC", {"hipErrorInvalidPc", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 718
|
|
// cudaErrorLaunchFailure = 4
|
|
{"CUDA_ERROR_LAUNCH_FAILED", {"hipErrorLaunchFailure", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 719
|
|
// cudaErrorNotPermitted = 70
|
|
{"CUDA_ERROR_NOT_PERMITTED", {"hipErrorNotPermitted", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 800
|
|
// cudaErrorNotSupported = 71
|
|
{"CUDA_ERROR_NOT_SUPPORTED", {"hipErrorNotSupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 801
|
|
// cudaErrorSystemNotReady = 83
|
|
{"CUDA_ERROR_SYSTEM_NOT_READY", {"hipErrorSystemNotReady", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 802
|
|
// cudaErrorStreamCaptureUnsupported = 900
|
|
{"CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED", {"hipErrorStreamCaptureUnsupported", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 900
|
|
// cudaErrorStreamCaptureInvalidated = 901
|
|
{"CUDA_ERROR_STREAM_CAPTURE_INVALIDATED", {"hipErrorStreamCaptureInvalidated", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 901
|
|
// cudaErrorStreamCaptureMerge = 902
|
|
{"CUDA_ERROR_STREAM_CAPTURE_MERGE", {"hipErrorStreamCaptureMerge", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 902
|
|
// cudaErrorStreamCaptureUnmatched = 903
|
|
{"CUDA_ERROR_STREAM_CAPTURE_UNMATCHED", {"hipErrorStreamCaptureUnmatched", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 903
|
|
// cudaErrorStreamCaptureUnjoined = 904
|
|
{"CUDA_ERROR_STREAM_CAPTURE_UNJOINED", {"hipErrorStreamCaptureUnjoined", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 904
|
|
// cudaErrorStreamCaptureIsolation = 905
|
|
{"CUDA_ERROR_STREAM_CAPTURE_ISOLATION", {"hipErrorStreamCaptureIsolation", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 905
|
|
// cudaErrorStreamCaptureImplicit = 906
|
|
{"CUDA_ERROR_STREAM_CAPTURE_IMPLICIT", {"hipErrorStreamCaptureImplicit", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 906
|
|
// cudaErrorCapturedEvent = 907
|
|
{"CUDA_ERROR_CAPTURED_EVENT", {"hipErrorCapturedEvent", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 907
|
|
// no analogue
|
|
{"CUDA_ERROR_UNKNOWN", {"hipErrorUnknown", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 999
|
|
|
|
// cudaSharedMemConfig
|
|
{"CUsharedconfig", {"hipSharedMemConfig", CONV_TYPE, API_DRIVER}},
|
|
{"CUsharedconfig_enum", {"hipSharedMemConfig", CONV_TYPE, API_DRIVER}},
|
|
// CUsharedconfig enum values
|
|
// cudaSharedMemBankSizeDefault = 0
|
|
{"CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE", {"hipSharedMemBankSizeDefault", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x00
|
|
// cudaSharedMemBankSizeFourByte = 1
|
|
{"CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE", {"hipSharedMemBankSizeFourByte", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x01
|
|
// cudaSharedMemBankSizeEightByte = 2
|
|
{"CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE", {"hipSharedMemBankSizeEightByte", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x02
|
|
|
|
// cudaSharedCarveout
|
|
{"CUshared_carveout", {"hipSharedCarveout", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUshared_carveout_enum", {"hipSharedCarveout", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUshared_carveout enum values
|
|
// cudaSharedmemCarveoutDefault
|
|
{"CU_SHAREDMEM_CARVEOUT_DEFAULT", {"hipSharedmemCarveoutDefault", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // -1
|
|
// cudaSharedmemCarveoutMaxShared
|
|
{"CU_SHAREDMEM_CARVEOUT_MAX_SHARED", {"hipSharedmemCarveoutMaxShared", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 100
|
|
// cudaSharedmemCarveoutMaxShared
|
|
{"CU_SHAREDMEM_CARVEOUT_MAX_L1", {"hipSharedmemCarveoutMaxL1", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
|
|
// no analogue
|
|
{"CUstream_flags", {"hipStreamFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstream_flags_enum", {"hipStreamFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUstream_flags enum values
|
|
// cudaStreamDefault = 0x00
|
|
{"CU_STREAM_DEFAULT", {"hipStreamDefault", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x0
|
|
// cudaStreamNonBlocking = 0x01
|
|
{"CU_STREAM_NON_BLOCKING", {"hipStreamNonBlocking", CONV_NUMERIC_LITERAL, API_DRIVER}}, // 0x1
|
|
|
|
// no analogue
|
|
{"CUstreamBatchMemOpType", {"hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstreamBatchMemOpType_enum", {"hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUstreamBatchMemOpType enum values
|
|
{"CU_STREAM_MEM_OP_WAIT_VALUE_32", {"hipStreamBatchMemOpWaitValue32", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
{"CU_STREAM_MEM_OP_WRITE_VALUE_32", {"hipStreamBatchMemOpWriteValue32", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
{"CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES", {"hipStreamBatchMemOpFlushRemoteWrites", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
{"CU_STREAM_MEM_OP_WAIT_VALUE_64", {"hipStreamBatchMemOpWaitValue64", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 4
|
|
{"CU_STREAM_MEM_OP_WRITE_VALUE_64", {"hipStreamBatchMemOpWriteValue64", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 5
|
|
|
|
// cudaStreamCaptureStatus
|
|
{"CUstreamCaptureStatus", {"hipStreamCaptureStatus", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstreamCaptureStatus_enum", {"hipStreamCaptureStatus", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUstreamCaptureStatus enum values
|
|
// cudaStreamCaptureStatusNone
|
|
{"CU_STREAM_CAPTURE_STATUS_NONE", {"hipStreamCaptureStatusNone", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
// cudaStreamCaptureStatusActive
|
|
{"CU_STREAM_CAPTURE_STATUS_ACTIVE", {"hipStreamCaptureStatusActive", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
// cudaStreamCaptureStatusInvalidated
|
|
{"CU_STREAM_CAPTURE_STATUS_INVALIDATED", {"hipStreamCaptureStatusInvalidated", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
|
|
// no analogue
|
|
{"CUstreamWaitValue_flags", {"hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstreamWaitValue_flags_enum", {"hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUstreamWaitValue_flags enum values
|
|
{"CU_STREAM_WAIT_VALUE_GEQ", {"hipStreamWaitValueGeq", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0
|
|
{"CU_STREAM_WAIT_VALUE_EQ", {"hipStreamWaitValueEq", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
{"CU_STREAM_WAIT_VALUE_AND", {"hipStreamWaitValueAnd", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2
|
|
{"CU_STREAM_WAIT_VALUE_FLUSH", {"hipStreamWaitValueFlush", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 1<<30
|
|
|
|
// no analogue
|
|
{"CUstreamWriteValue_flags", {"hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUstreamWriteValue_flags_enum", {"hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUstreamWriteValue_flags enum values
|
|
{"CU_STREAM_WRITE_VALUE_DEFAULT", {"hipStreamWriteValueDefault", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0
|
|
{"CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER", {"hipStreamWriteValueNoMemoryBarrier", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
|
|
// cudaGLDeviceList
|
|
{"CUGLDeviceList", {"hipGLDeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUGLDeviceList_enum", {"hipGLDeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUGLDeviceList enum values
|
|
// cudaGLDeviceListAll = 1
|
|
{"CU_GL_DEVICE_LIST_ALL", {"HIP_GL_DEVICE_LIST_ALL", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaGLDeviceListCurrentFrame = 2
|
|
{"CU_GL_DEVICE_LIST_CURRENT_FRAME", {"HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaGLDeviceListNextFrame = 3
|
|
{"CU_GL_DEVICE_LIST_NEXT_FRAME", {"HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
|
|
// cudaGLMapFlags
|
|
{"CUGLmap_flags", {"hipGLMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUGLmap_flags_enum", {"hipGLMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUGLmap_flags enum values
|
|
// cudaGLMapFlagsNone = 0
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_NONE", {"HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaGLMapFlagsReadOnly = 1
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY", {"HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaGLMapFlagsWriteDiscard = 2
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", {"HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
|
|
// cudaD3D9DeviceList
|
|
{"CUd3d9DeviceList", {"hipD3D9DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d9DeviceList_enum", {"hipD3D9DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d9DeviceList enum values
|
|
// cudaD3D9DeviceListAll = 1
|
|
{"CU_D3D9_DEVICE_LIST_ALL", {"HIP_D3D9_DEVICE_LIST_ALL", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaD3D9DeviceListCurrentFrame = 2
|
|
{"CU_D3D9_DEVICE_LIST_CURRENT_FRAME", {"HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaD3D9DeviceListNextFrame = 3
|
|
{"CU_D3D9_DEVICE_LIST_NEXT_FRAME", {"HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
|
|
// Deprecated
|
|
// cudaD3D9MapFlags
|
|
{"CUd3d9map_flags", {"hipD3D9MapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d9map_flags_enum", {"hipD3D9MapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d9map_flags enum values
|
|
// cudaD3D9MapFlagsNone = 0
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_NONE", {"HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaD3D9MapFlagsReadOnly = 1
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_READONLY", {"HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaD3D9MapFlagsWriteDiscard = 2
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", {"HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
|
|
// cudaD3D9RegisterFlags
|
|
{"CUd3d9register_flags", {"hipD3D9RegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d9register_flags_enum", {"hipD3D9RegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d9register_flags enum values
|
|
// cudaD3D9RegisterFlagsNone = 0
|
|
{"CU_D3D9_REGISTER_FLAGS_NONE", {"HIP_D3D9_REGISTER_FLAGS_NONE", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaD3D9RegisterFlagsArray = 1
|
|
{"CU_D3D9_REGISTER_FLAGS_ARRAY", {"HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
|
|
// cudaD3D10DeviceList
|
|
{"CUd3d10DeviceList", {"hipd3d10DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d10DeviceList_enum", {"hipD3D10DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d10DeviceList enum values
|
|
// cudaD3D10DeviceListAll = 1
|
|
{"CU_D3D10_DEVICE_LIST_ALL", {"HIP_D3D10_DEVICE_LIST_ALL", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaD3D10DeviceListCurrentFrame = 2
|
|
{"CU_D3D10_DEVICE_LIST_CURRENT_FRAME", {"HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaD3D10DeviceListNextFrame = 3
|
|
{"CU_D3D10_DEVICE_LIST_NEXT_FRAME", {"HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
|
|
// cudaD3D10MapFlags
|
|
{"CUd3d10map_flags", {"hipD3D10MapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d10map_flags_enum", {"hipD3D10MapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d10map_flags enum values
|
|
// cudaD3D10MapFlagsNone = 0
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_NONE", {"HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaD3D10MapFlagsReadOnly = 1
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_READONLY", {"HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaD3D10MapFlagsWriteDiscard = 2
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", {"HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
|
|
// cudaD3D10RegisterFlags
|
|
{"CUd3d10register_flags", {"hipD3D10RegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d10register_flags_enum", {"hipD3D10RegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d10register_flags enum values
|
|
// cudaD3D10RegisterFlagsNone = 0
|
|
{"CU_D3D10_REGISTER_FLAGS_NONE", {"HIP_D3D10_REGISTER_FLAGS_NONE", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
// cudaD3D10RegisterFlagsArray = 1
|
|
{"CU_D3D10_REGISTER_FLAGS_ARRAY", {"HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
|
|
// cudaD3D11DeviceList
|
|
{"CUd3d11DeviceList", {"hipd3d11DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUd3d11DeviceList_enum", {"hipD3D11DeviceList", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// CUd3d11DeviceList enum values
|
|
// cudaD3D11DeviceListAll = 1
|
|
{"CU_D3D11_DEVICE_LIST_ALL", {"HIP_D3D11_DEVICE_LIST_ALL", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
// cudaD3D11DeviceListCurrentFrame = 2
|
|
{"CU_D3D11_DEVICE_LIST_CURRENT_FRAME", {"HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
// cudaD3D11DeviceListNextFrame = 3
|
|
{"CU_D3D11_DEVICE_LIST_NEXT_FRAME", {"HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_NUMERIC_LITERAL, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
|
|
// 4. Typedefs
|
|
// no analogue
|
|
{"CUdevice", {"hipDevice_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUdeviceptr", {"hipDeviceptr_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// cudaHostFn_t
|
|
{"CUhostFn", {"hipHostFn", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// no analogue
|
|
{"CUoccupancyB2DSize", {"hipOccupancyB2DSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaStreamCallback_t
|
|
{"CUstreamCallback", {"hipStreamCallback_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// cudaSurfaceObject_t
|
|
{"CUsurfObject", {"hipSurfaceObject", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// cudaTextureObject_t
|
|
{"CUtexObject", {"hipTextureObject_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// 5. Defines
|
|
{"__CUDACC__", {"__HIPCC__", CONV_DEF, API_DRIVER}},
|
|
{"CUDA_CB", {"HIP_CB", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_DEVICE_CPU", {"HIP_DEVICE_CPU", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUdevice)-1)
|
|
{"CU_DEVICE_INVALID", {"HIP_DEVICE_INVALID", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUdevice)-2)
|
|
{"CU_IPC_HANDLE_SIZE", {"HIP_LAUNCH_PARAM_END", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 64
|
|
{"CU_LAUNCH_PARAM_BUFFER_POINTER", {"HIP_LAUNCH_PARAM_BUFFER_POINTER", CONV_DEF, API_DRIVER}}, // ((void*)0x01)
|
|
{"CU_LAUNCH_PARAM_BUFFER_SIZE", {"HIP_LAUNCH_PARAM_BUFFER_SIZE", CONV_DEF, API_DRIVER}}, // ((void*)0x02)
|
|
{"CU_LAUNCH_PARAM_END", {"HIP_LAUNCH_PARAM_END", CONV_DEF, API_DRIVER}}, // ((void*)0x00)
|
|
{"CU_MEMHOSTALLOC_DEVICEMAP", {"HIP_MEMHOSTALLOC_DEVICEMAP", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_MEMHOSTALLOC_PORTABLE", {"HIP_MEMHOSTALLOC_PORTABLE", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_MEMHOSTALLOC_WRITECOMBINED", {"HIP_MEMHOSTALLOC_WRITECOMBINED", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_MEMHOSTREGISTER_DEVICEMAP", {"HIP_MEMHOSTREGISTER_DEVICEMAP", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_MEMHOSTREGISTER_IOMEMORY", {"HIP_MEMHOSTREGISTER_IOMEMORY", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_MEMHOSTREGISTER_PORTABLE", {"HIP_MEMHOSTREGISTER_PORTABLE", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_PARAM_TR_DEFAULT", {"HIP_PARAM_TR_DEFAULT", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // -1
|
|
{"CU_STREAM_LEGACY", {"HIP_STREAM_LEGACY", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUstream)0x1)
|
|
{"CU_STREAM_PER_THREAD", {"HIP_STREAM_PER_THREAD", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUstream)0x2)
|
|
{"CU_TRSA_OVERRIDE_FORMAT", {"HIP_TRSA_OVERRIDE_FORMAT", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_TRSF_NORMALIZED_COORDINATES", {"HIP_TRSF_NORMALIZED_COORDINATES", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_TRSF_READ_AS_INTEGER", {"HIP_TRSF_READ_AS_INTEGER", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_TRSF_SRGB", {"HIP_TRSF_SRGB", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
// Deprecated, use CUDA_ARRAY3D_LAYERED
|
|
{"CUDA_ARRAY3D_2DARRAY", {"HIP_ARRAY3D_2DARRAY", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CUDA_ARRAY3D_COLOR_ATTACHMENT", {"HIP_ARRAY3D_COLOR_ATTACHMENT", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x20
|
|
{"CUDA_ARRAY3D_CUBEMAP", {"HIP_ARRAY3D_CUBEMAP", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CUDA_ARRAY3D_DEPTH_TEXTURE", {"HIP_ARRAY3D_DEPTH_TEXTURE", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
{"CUDA_ARRAY3D_LAYERED", {"HIP_ARRAY3D_LAYERED", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CUDA_ARRAY3D_SURFACE_LDST", {"HIP_ARRAY3D_SURFACE_LDST", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CUDA_ARRAY3D_TEXTURE_GATHER", {"HIP_ARRAY3D_TEXTURE_GATHER", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
{"CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC", {"HIP_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC", {"HIP_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CUDA_EXTERNAL_MEMORY_DEDICATED", {"HIP_EXTERNAL_MEMORY_DEDICATED", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
{"CUDA_VERSION", {"HIP_VERSION", CONV_DEF, API_DRIVER, HIP_UNSUPPORTED}}, // 10000
|
|
|
|
/////////////////////////////////////////////////////// CUDA Runtime API ///////////////////////////////////////////////////////
|
|
|
|
{"cudaError_t", {"hipError_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaError", {"hipError_t", CONV_TYPE, API_RUNTIME}},
|
|
|
|
{"libraryPropertyType_t", {"hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"libraryPropertyType", {"hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
{"cudaStreamCallback_t", {"hipStreamCallback_t", CONV_TYPE, API_RUNTIME}},
|
|
|
|
// Arrays
|
|
{"cudaArray", {"hipArray", CONV_MEM, API_RUNTIME}},
|
|
// typedef struct cudaArray *cudaArray_t;
|
|
|
|
{"cudaArray_t", {"hipArray_t", CONV_MEM, API_RUNTIME}},
|
|
// typedef const struct cudaArray *cudaArray_const_t;
|
|
|
|
{"cudaArray_const_t", {"hipArray_const_t", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMipmappedArray_t", {"hipMipmappedArray_t", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMipmappedArray_const_t", {"hipMipmappedArray_const_t", CONV_MEM, API_RUNTIME}},
|
|
|
|
// defines
|
|
{"cudaArrayDefault", {"hipArrayDefault", CONV_MEM, API_RUNTIME}},
|
|
{"cudaArrayLayered", {"hipArrayLayered", CONV_MEM, API_RUNTIME}},
|
|
{"cudaArraySurfaceLoadStore", {"hipArraySurfaceLoadStore", CONV_MEM, API_RUNTIME}},
|
|
{"cudaArrayCubemap", {"hipArrayCubemap", CONV_MEM, API_RUNTIME}},
|
|
{"cudaArrayTextureGather", {"hipArrayTextureGather", CONV_MEM, API_RUNTIME}},
|
|
|
|
{"cudaMemoryAdvise", {"hipMemAdvise", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUmem_advise)
|
|
{"cudaMemRangeAttribute", {"hipMemRangeAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUmem_range_attribute)
|
|
{"cudaMemcpyKind", {"hipMemcpyKind", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemoryType", {"hipMemoryType", CONV_MEM, API_RUNTIME}}, // API_Driver ANALOGUE (no - CUmemorytype is not an analogue)
|
|
|
|
{"cudaExtent", {"hipExtent", CONV_MEM, API_RUNTIME}},
|
|
{"cudaPitchedPtr", {"hipPitchedPtr", CONV_MEM, API_RUNTIME}},
|
|
{"cudaPos", {"hipPos", CONV_MEM, API_RUNTIME}},
|
|
|
|
{"cudaEvent_t", {"hipEvent_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaStream_t", {"hipStream_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaPointerAttributes", {"hipPointerAttribute_t", CONV_TYPE, API_RUNTIME}},
|
|
|
|
{"cudaDeviceAttr", {"hipDeviceAttribute_t", CONV_TYPE, API_RUNTIME}}, // API_DRIVER ANALOGUE (CUdevice_attribute)
|
|
{"cudaDeviceProp", {"hipDeviceProp_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceP2PAttr", {"hipDeviceP2PAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_DRIVER ANALOGUE (CUdevice_P2PAttribute)
|
|
{"cudaComputeMode", {"hipComputeMode", CONV_TYPE, API_RUNTIME}}, // API_DRIVER ANALOGUE (CUcomputemode)
|
|
{"cudaFuncCache", {"hipFuncCache_t", CONV_CACHE, API_RUNTIME}}, // API_Driver ANALOGUE (CUfunc_cache)
|
|
{"cudaFuncAttributes", {"hipFuncAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSharedMemConfig", {"hipSharedMemConfig", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaLimit", {"hipLimit_t", CONV_TYPE, API_RUNTIME}}, // API_Driver ANALOGUE (CUlimit)
|
|
|
|
{"cudaOutputMode", {"hipOutputMode", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Texture reference management
|
|
{"cudaTextureReadMode", {"hipTextureReadMode", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureFilterMode", {"hipTextureFilterMode", CONV_TEX, API_RUNTIME}}, // API_DRIVER ANALOGUE (CUfilter_mode)
|
|
|
|
{"cudaChannelFormatKind", {"hipChannelFormatKind", CONV_TEX, API_RUNTIME}},
|
|
{"cudaChannelFormatDesc", {"hipChannelFormatDesc", CONV_TEX, API_RUNTIME}},
|
|
|
|
// Texture Object Management
|
|
{"cudaResourceDesc", {"hipResourceDesc", CONV_TEX, API_RUNTIME}},
|
|
{"cudaResourceViewDesc", {"hipResourceViewDesc", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureDesc", {"hipTextureDesc", CONV_TEX, API_RUNTIME}},
|
|
{"surfaceReference", {"hipSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
// Left unchanged
|
|
// {"textureReference", {"textureReference", CONV_TEX, API_RUNTIME}},
|
|
|
|
// typedefs
|
|
{"cudaTextureObject_t", {"hipTextureObject_t", CONV_TEX, API_RUNTIME}},
|
|
{"cudaSurfaceObject_t", {"hipSurfaceObject_t", CONV_SURFACE, API_RUNTIME}},
|
|
|
|
// enums
|
|
{"cudaResourceType", {"hipResourceType", CONV_TEX, API_RUNTIME}}, // API_Driver ANALOGUE (CUresourcetype)
|
|
{"cudaResourceViewFormat", {"hipResourceViewFormat", CONV_TEX, API_RUNTIME}}, // API_Driver ANALOGUE (CUresourceViewFormat)
|
|
{"cudaTextureAddressMode", {"hipTextureAddressMode", CONV_TEX, API_RUNTIME}},
|
|
{"cudaSurfaceBoundaryMode", {"hipSurfaceBoundaryMode", CONV_SURFACE, API_RUNTIME}},
|
|
|
|
{"cudaSurfaceFormatMode", {"hipSurfaceFormatMode", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// defines
|
|
{"cudaTextureType1D", {"hipTextureType1D", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureType2D", {"hipTextureType2D", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureType3D", {"hipTextureType3D", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureTypeCubemap", {"hipTextureTypeCubemap", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureType1DLayered", {"hipTextureType1DLayered", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureType2DLayered", {"hipTextureType2DLayered", CONV_TEX, API_RUNTIME}},
|
|
{"cudaTextureTypeCubemapLayered", {"hipTextureTypeCubemapLayered", CONV_TEX, API_RUNTIME}},
|
|
|
|
// Inter-Process Communication (IPC)
|
|
{"cudaIpcEventHandle_t", {"hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaIpcEventHandle_st", {"hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaIpcMemHandle_t", {"hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaIpcMemHandle_st", {"hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME}},
|
|
|
|
// Graphics Interoperability
|
|
{"cudaGraphicsCubeFace", {"hipGraphicsCubeFace", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsMapFlags", {"hipGraphicsMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUgraphicsMapResourceFlags)
|
|
{"cudaGraphicsRegisterFlags", {"hipGraphicsRegisterFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUgraphicsRegisterFlags)
|
|
|
|
// OpenGL Interoperability
|
|
{"cudaGLDeviceList", {"hipGLDeviceList", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUGLDeviceList)
|
|
{"cudaGLMapFlags", {"hipGLMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUGLmap_flags)
|
|
|
|
// Direct3D 9 Interoperability
|
|
{"cudaD3D9DeviceList", {"hipD3D9DeviceList", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d9DeviceList)
|
|
{"cudaD3D9MapFlags", {"hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d9map_flags)
|
|
{"cudaD3D9RegisterFlags", {"hipD3D9RegisterFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d9Register_flags)
|
|
|
|
// Direct3D 10 Interoperability
|
|
{"cudaD3D10DeviceList", {"hipd3d10DeviceList", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d10DeviceList)
|
|
{"cudaD3D10MapFlags", {"hipD3D10MapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d10map_flags)
|
|
{"cudaD3D10RegisterFlags", {"hipD3D10RegisterFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d10Register_flags)
|
|
|
|
// Direct3D 11 Interoperability
|
|
{"cudaD3D11DeviceList", {"hipd3d11DeviceList", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d11DeviceList)
|
|
|
|
// EGL Interoperability
|
|
{"cudaEglStreamConnection", {"hipEglStreamConnection", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUeglStreamConnection)
|
|
|
|
{"cublasHandle_t", {"hipblasHandle_t", CONV_TYPE, API_BLAS}},
|
|
// TODO: dereferencing: typedef struct cublasContext *cublasHandle_t;
|
|
// {"cublasContext", {"hipblasHandle_t", CONV_TYPE, API_BLAS}},
|
|
|
|
///////////////////////////// cuRAND /////////////////////////////
|
|
{"curandStatus", {"hiprandStatus_t", CONV_TYPE, API_RAND}},
|
|
{"curandStatus_t", {"hiprandStatus_t", CONV_TYPE, API_RAND}},
|
|
{"curandRngType", {"hiprandRngType_t", CONV_TYPE, API_RAND}},
|
|
{"curandRngType_t", {"hiprandRngType_t", CONV_TYPE, API_RAND}},
|
|
{"curandGenerator_st", {"hiprandGenerator_st", CONV_TYPE, API_RAND}},
|
|
{"curandGenerator_t", {"hiprandGenerator_t", CONV_TYPE, API_RAND}},
|
|
{"curandDirectionVectorSet", {"hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDirectionVectorSet_t", {"hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandOrdering", {"hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandOrdering_t", {"hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistribution_st", {"hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2V_st", {"hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistribution_t", {"hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2V_t", {"hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistributionShift_st", {"hiprandDistributionShift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistributionShift_t", {"hiprandDistributionShift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistributionM2Shift_st", {"hiprandDistributionM2Shift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDistributionM2Shift_t", {"hiprandDistributionM2Shift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2_st", {"hiprandHistogramM2_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2_t", {"hiprandHistogramM2_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2K_st", {"hiprandHistogramM2K_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandHistogramM2K_t", {"hiprandHistogramM2K_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDiscreteDistribution_st", {"hiprandDiscreteDistribution_st", CONV_TYPE, API_RAND}},
|
|
{"curandDiscreteDistribution_t", {"hiprandDiscreteDistribution_t", CONV_TYPE, API_RAND}},
|
|
{"curandMethod", {"hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandMethod_t", {"hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandDirectionVectors32_t", {"hiprandDirectionVectors32_t", CONV_TYPE, API_RAND}},
|
|
{"curandDirectionVectors64_t", {"hiprandDirectionVectors64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
// cuRAND types for Device functions
|
|
{"curandStateMtgp32_t", {"hiprandStateMtgp32_t", CONV_TYPE, API_RAND}},
|
|
{"curandStateScrambledSobol64_t", {"hiprandStateScrambledSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandStateSobol64_t", {"hiprandStateSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandStateScrambledSobol32_t", {"hiprandStateScrambledSobol32_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandStateSobol32_t", {"hiprandStateSobol32_t", CONV_TYPE, API_RAND}},
|
|
{"curandStateMRG32k3a_t", {"hiprandStateMRG32k3a_t", CONV_TYPE, API_RAND}},
|
|
{"curandStatePhilox4_32_10_t", {"hiprandStatePhilox4_32_10_t", CONV_TYPE, API_RAND}},
|
|
{"curandStateXORWOW_t", {"hiprandStateXORWOW_t", CONV_TYPE, API_RAND}},
|
|
{"curandState_t", {"hiprandState_t", CONV_TYPE, API_RAND}},
|
|
{"curandState", {"hiprandState_t", CONV_TYPE, API_RAND}},
|
|
};
|
|
|
|
/// Map of all other identifiers: FUNCTION and MACRO names.
|
|
const std::map<llvm::StringRef, hipCounter> CUDA_IDENTIFIER_MAP{
|
|
//
|
|
{"cudaSuccess", {"hipSuccess", CONV_TYPE, API_RUNTIME}}, // 0
|
|
//
|
|
{"cudaErrorMissingConfiguration", {"hipErrorMissingConfiguration", CONV_TYPE, API_RUNTIME}}, // 1
|
|
{"cudaErrorPriorLaunchFailure", {"hipErrorPriorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 5
|
|
{"cudaErrorInvalidDeviceFunction", {"hipErrorInvalidDeviceFunction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 8
|
|
{"cudaErrorInvalidConfiguration", {"hipErrorInvalidConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 9
|
|
{"cudaErrorInvalidPitchValue", {"hipErrorInvalidPitchValue", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 12
|
|
{"cudaErrorInvalidSymbol", {"hipErrorInvalidSymbol", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 13
|
|
{"cudaErrorInvalidHostPointer", {"hipErrorInvalidHostPointer", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 16
|
|
{"cudaErrorInvalidDevicePointer", {"hipErrorInvalidDevicePointer", CONV_TYPE, API_RUNTIME}}, // 17
|
|
{"cudaErrorInvalidTexture", {"hipErrorInvalidTexture", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 18
|
|
{"cudaErrorInvalidTextureBinding", {"hipErrorInvalidTextureBinding", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 19
|
|
{"cudaErrorInvalidChannelDescriptor", {"hipErrorInvalidChannelDescriptor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 20
|
|
{"cudaErrorInvalidMemcpyDirection", {"hipErrorInvalidMemcpyDirection", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 21
|
|
{"cudaErrorAddressOfConstant", {"hipErrorAddressOfConstant", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 22
|
|
{"cudaErrorTextureFetchFailed", {"hipErrorTextureFetchFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 23
|
|
{"cudaErrorTextureNotBound", {"hipErrorTextureNotBound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 24
|
|
{"cudaErrorSynchronizationError", {"hipErrorSynchronizationError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 25
|
|
{"cudaErrorInvalidFilterSetting", {"hipErrorInvalidFilterSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 26
|
|
{"cudaErrorInvalidNormSetting", {"hipErrorInvalidNormSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 27
|
|
{"cudaErrorMixedDeviceExecution", {"hipErrorMixedDeviceExecution", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 28
|
|
// Deprecated as of CUDA 4.1
|
|
{"cudaErrorNotYetImplemented", {"hipErrorNotYetImplemented", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 31
|
|
// Deprecated as of CUDA 3.1
|
|
{"cudaErrorMemoryValueTooLarge", {"hipErrorMemoryValueTooLarge", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 32
|
|
{"cudaErrorInsufficientDriver", {"hipErrorInsufficientDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 35
|
|
{"cudaErrorSetOnActiveProcess", {"hipErrorSetOnActiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 36
|
|
{"cudaErrorInvalidSurface", {"hipErrorInvalidSurface", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 37
|
|
{"cudaErrorDuplicateVariableName", {"hipErrorDuplicateVariableName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 43
|
|
{"cudaErrorDuplicateTextureName", {"hipErrorDuplicateTextureName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 44
|
|
{"cudaErrorDuplicateSurfaceName", {"hipErrorDuplicateSurfaceName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 45
|
|
{"cudaErrorDevicesUnavailable", {"hipErrorDevicesUnavailable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 46
|
|
{"cudaErrorIncompatibleDriverContext", {"hipErrorIncompatibleDriverContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 49
|
|
{"cudaErrorDeviceAlreadyInUse", {"hipErrorDeviceAlreadyInUse", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 54
|
|
{"cudaErrorLaunchMaxDepthExceeded", {"hipErrorLaunchMaxDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 65
|
|
{"cudaErrorLaunchFileScopedTex", {"hipErrorLaunchFileScopedTex", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 66
|
|
{"cudaErrorLaunchFileScopedSurf", {"hipErrorLaunchFileScopedSurf", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 67
|
|
{"cudaErrorSyncDepthExceeded", {"hipErrorSyncDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 68
|
|
{"cudaErrorLaunchPendingCountExceeded", {"hipErrorLaunchPendingCountExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 69
|
|
{"cudaErrorNotPermitted", {"hipErrorNotPermitted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 70
|
|
{"cudaErrorNotSupported", {"hipErrorNotSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 71
|
|
{"cudaErrorStartupFailure", {"hipErrorStartupFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 127
|
|
// Deprecated as of CUDA 4.1
|
|
{"cudaErrorApiFailureBase", {"hipErrorApiFailureBase", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 10000
|
|
|
|
{"cudaErrorInvalidValue", {"hipErrorInvalidValue", CONV_TYPE, API_RUNTIME}}, // 11
|
|
|
|
{"cudaErrorMemoryAllocation", {"hipErrorMemoryAllocation", CONV_TYPE, API_RUNTIME}}, // 2
|
|
|
|
{"cudaErrorInitializationError", {"hipErrorInitializationError", CONV_TYPE, API_RUNTIME}}, // 3
|
|
|
|
{"cudaErrorCudartUnloading", {"hipErrorDeinitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 29
|
|
|
|
{"cudaErrorProfilerDisabled", {"hipErrorProfilerDisabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 55
|
|
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerNotInitialized", {"hipErrorProfilerNotInitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 56
|
|
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerAlreadyStarted", {"hipErrorProfilerAlreadyStarted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 57
|
|
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerAlreadyStopped", {"hipErrorProfilerAlreadyStopped", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 58
|
|
|
|
{"cudaErrorNoDevice", {"hipErrorNoDevice", CONV_TYPE, API_RUNTIME}}, // 38
|
|
|
|
{"cudaErrorInvalidDevice", {"hipErrorInvalidDevice", CONV_TYPE, API_RUNTIME}}, // 10
|
|
|
|
{"cudaErrorInvalidKernelImage", {"hipErrorInvalidImage", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 47
|
|
|
|
// TODO: double check the matching
|
|
{"cudaErrorMapBufferObjectFailed", {"hipErrorMapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 14
|
|
|
|
// TODO: double check the matching
|
|
{"cudaErrorUnmapBufferObjectFailed", {"hipErrorUnmapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 15
|
|
|
|
{"cudaErrorNoKernelImageForDevice", {"hipErrorNoBinaryForGpu", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 48
|
|
|
|
{"cudaErrorECCUncorrectable", {"hipErrorECCNotCorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 39
|
|
|
|
{"cudaErrorUnsupportedLimit", {"hipErrorUnsupportedLimit", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 42
|
|
|
|
{"cudaErrorPeerAccessUnsupported", {"hipErrorPeerAccessUnsupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 64
|
|
|
|
{"cudaErrorInvalidPtx", {"hipErrorInvalidKernelFile", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 78
|
|
|
|
{"cudaErrorInvalidGraphicsContext", {"hipErrorInvalidGraphicsContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 79
|
|
|
|
{"cudaErrorNvlinkUncorrectable", {"hipErrorNvlinkUncorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 80
|
|
|
|
{"cudaErrorJitCompilerNotFound", {"hipErrorJitCompilerNotFound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 81
|
|
|
|
{"cudaErrorSharedObjectSymbolNotFound", {"hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 40
|
|
|
|
{"cudaErrorSharedObjectInitFailed", {"hipErrorSharedObjectInitFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 41
|
|
|
|
{"cudaErrorOperatingSystem", {"hipErrorOperatingSystem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 63
|
|
|
|
{"cudaErrorInvalidResourceHandle", {"hipErrorInvalidResourceHandle", CONV_TYPE, API_RUNTIME}}, // 33
|
|
|
|
{"cudaErrorIllegalState", {"hipErrorIllegalState", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 84
|
|
|
|
{"cudaErrorNotReady", {"hipErrorNotReady", CONV_TYPE, API_RUNTIME}}, // 34
|
|
|
|
{"cudaErrorIllegalAddress", {"hipErrorIllegalAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 77
|
|
|
|
{"cudaErrorLaunchOutOfResources", {"hipErrorLaunchOutOfResources", CONV_TYPE, API_RUNTIME}}, // 7
|
|
|
|
{"cudaErrorLaunchTimeout", {"hipErrorLaunchTimeOut", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 6
|
|
|
|
{"cudaErrorPeerAccessAlreadyEnabled", {"hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_RUNTIME}}, // 50
|
|
|
|
{"cudaErrorPeerAccessNotEnabled", {"hipErrorPeerAccessNotEnabled", CONV_TYPE, API_RUNTIME}}, // 51
|
|
|
|
{"cudaErrorAssert", {"hipErrorAssert", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 59
|
|
|
|
{"cudaErrorTooManyPeers", {"hipErrorTooManyPeers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 60
|
|
|
|
{"cudaErrorHostMemoryAlreadyRegistered", {"hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_RUNTIME}}, // 61
|
|
|
|
{"cudaErrorHostMemoryNotRegistered", {"hipErrorHostMemoryNotRegistered", CONV_TYPE, API_RUNTIME}}, // 62
|
|
|
|
{"cudaErrorHardwareStackError", {"hipErrorHardwareStackError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 72
|
|
|
|
{"cudaErrorIllegalInstruction", {"hipErrorIllegalInstruction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 73
|
|
|
|
{"cudaErrorMisalignedAddress", {"hipErrorMisalignedAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 74
|
|
|
|
{"cudaErrorInvalidAddressSpace", {"hipErrorInvalidAddressSpace", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 75
|
|
|
|
{"cudaErrorInvalidPc", {"hipErrorInvalidPc", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 76
|
|
|
|
{"cudaErrorLaunchFailure", {"hipErrorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 4
|
|
|
|
{"cudaErrorUnknown", {"hipErrorUnknown", CONV_TYPE, API_RUNTIME}}, // 30
|
|
|
|
///////////////////////////// CUDA DRIVER API /////////////////////////////
|
|
|
|
|
|
// Error Handling
|
|
{"cuGetErrorName", {"hipGetErrorName___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED}}, // cudaGetErrorName (hipGetErrorName) has different signature
|
|
{"cuGetErrorString", {"hipGetErrorString___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED}}, // cudaGetErrorString (hipGetErrorString) has different signature
|
|
|
|
// Init
|
|
{"cuInit", {"hipInit", CONV_INIT, API_DRIVER}},
|
|
|
|
// Driver
|
|
{"cuDriverGetVersion", {"hipDriverGetVersion", CONV_VERSION, API_DRIVER}},
|
|
|
|
// Context Management
|
|
{"cuCtxCreate_v2", {"hipCtxCreate", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxDestroy_v2", {"hipCtxDestroy", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetApiVersion", {"hipCtxGetApiVersion", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetCacheConfig", {"hipCtxGetCacheConfig", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetCurrent", {"hipCtxGetCurrent", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetDevice", {"hipCtxGetDevice", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetFlags", {"hipCtxGetFlags", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetLimit", {"hipCtxGetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuCtxGetSharedMemConfig", {"hipCtxGetSharedMemConfig", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxGetStreamPriorityRange", {"hipCtxGetStreamPriorityRange", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuCtxPopCurrent_v2", {"hipCtxPopCurrent", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxPushCurrent_v2", {"hipCtxPushCurrent", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxSetCacheConfig", {"hipCtxSetCacheConfig", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxSetCurrent", {"hipCtxSetCurrent", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxSetLimit", {"hipCtxSetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuCtxSetSharedMemConfig", {"hipCtxSetSharedMemConfig", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuCtxSynchronize", {"hipCtxSynchronize", CONV_CONTEXT, API_DRIVER}},
|
|
// Context Management [DEPRECATED]
|
|
{"cuCtxAttach", {"hipCtxAttach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuCtxDetach", {"hipCtxDetach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Primary Context Management
|
|
{"cuDevicePrimaryCtxGetState", {"hipDevicePrimaryCtxGetState", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuDevicePrimaryCtxRelease", {"hipDevicePrimaryCtxRelease", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuDevicePrimaryCtxReset", {"hipDevicePrimaryCtxReset", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuDevicePrimaryCtxRetain", {"hipDevicePrimaryCtxRetain", CONV_CONTEXT, API_DRIVER}},
|
|
{"cuDevicePrimaryCtxSetFlags", {"hipDevicePrimaryCtxSetFlags", CONV_CONTEXT, API_DRIVER}},
|
|
|
|
// 1. Device Management
|
|
{"cuDeviceGet", {"hipGetDevice", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetName", {"hipDeviceGetName", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetCount", {"hipGetDeviceCount", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetAttribute", {"hipDeviceGetAttribute", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetPCIBusId", {"hipDeviceGetPCIBusId", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetByPCIBusId", {"hipDeviceGetByPCIBusId", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceTotalMem_v2", {"hipDeviceTotalMem", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetLuid", {"hipDeviceGetLuid", CONV_DEVICE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// 12. Peer Context Memory Access
|
|
{"cuCtxEnablePeerAccess", {"hipCtxEnablePeerAccess", CONV_PEER, API_DRIVER}},
|
|
{"cuCtxDisablePeerAccess", {"hipCtxDisablePeerAccess", CONV_PEER, API_DRIVER}},
|
|
{"cuDeviceCanAccessPeer", {"hipDeviceCanAccessPeer", CONV_PEER, API_DRIVER}},
|
|
{"cuDeviceGetP2PAttribute", {"hipDeviceGetP2PAttribute", CONV_PEER, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaDeviceGetP2PAttribute)
|
|
|
|
|
|
// Device Management [DEPRECATED]
|
|
{"cuDeviceComputeCapability", {"hipDeviceComputeCapability", CONV_DEVICE, API_DRIVER}},
|
|
{"cuDeviceGetProperties", {"hipGetDeviceProperties", CONV_DEVICE, API_DRIVER}},
|
|
|
|
// Module Management
|
|
{"cuLinkAddData", {"hipLinkAddData", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLinkAddFile", {"hipLinkAddFile", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLinkComplete", {"hipLinkComplete", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLinkCreate", {"hipLinkCreate", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLinkDestroy", {"hipLinkDestroy", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuModuleGetFunction", {"hipModuleGetFunction", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleGetGlobal_v2", {"hipModuleGetGlobal", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleGetSurfRef", {"hipModuleGetSurfRef", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuModuleGetTexRef", {"hipModuleGetTexRef", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleLoad", {"hipModuleLoad", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleLoadData", {"hipModuleLoadData", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleLoadDataEx", {"hipModuleLoadDataEx", CONV_MODULE, API_DRIVER}},
|
|
{"cuModuleLoadFatBinary", {"hipModuleLoadFatBinary", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuModuleUnload", {"hipModuleUnload", CONV_MODULE, API_DRIVER}},
|
|
|
|
// Event functions
|
|
{"cuEventCreate", {"hipEventCreate", CONV_EVENT, API_DRIVER}},
|
|
{"cuEventDestroy_v2", {"hipEventDestroy", CONV_EVENT, API_DRIVER}},
|
|
{"cuEventElapsedTime", {"hipEventElapsedTime", CONV_EVENT, API_DRIVER}},
|
|
{"cuEventQuery", {"hipEventQuery", CONV_EVENT, API_DRIVER}},
|
|
{"cuEventRecord", {"hipEventRecord", CONV_EVENT, API_DRIVER}},
|
|
{"cuEventSynchronize", {"hipEventSynchronize", CONV_EVENT, API_DRIVER}},
|
|
|
|
// External Resource Interoperability
|
|
{"cuSignalExternalSemaphoresAsync", {"hipSignalExternalSemaphoresAsync", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuWaitExternalSemaphoresAsync", {"hipWaitExternalSemaphoresAsync", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuImportExternalMemory", {"hipImportExternalMemory", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuExternalMemoryGetMappedBuffer", {"hipExternalMemoryGetMappedBuffer", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuExternalMemoryGetMappedMipmappedArray", {"hipExternalMemoryGetMappedMipmappedArray", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuDestroyExternalMemory", {"hipDestroyExternalMemory", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuImportExternalSemaphore", {"hipImportExternalSemaphore", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuDestroyExternalSemaphore", {"hipDestroyExternalSemaphore", CONV_EXTERNAL_RES, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Execution Control
|
|
{"cuFuncGetAttribute", {"hipFuncGetAttribute", CONV_EXEC, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuFuncSetCacheConfig", {"hipFuncSetCacheConfig", CONV_EXEC, API_DRIVER}},
|
|
{"cuFuncSetSharedMemConfig", {"hipFuncSetSharedMemConfig", CONV_EXEC, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLaunchKernel", {"hipModuleLaunchKernel", CONV_EXEC, API_DRIVER}},
|
|
{"cuLaunchHostFunc", {"hipLaunchHostFunc", CONV_EXEC, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Execution Control [DEPRECATED]
|
|
{"cuFuncSetBlockShape", {"hipFuncSetBlockShape", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuFuncSetSharedSize", {"hipFuncSetSharedSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLaunch", {"hipLaunch", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaLaunch)
|
|
{"cuLaunchGrid", {"hipLaunchGrid", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLaunchGridAsync", {"hipLaunchGridAsync", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuParamSetf", {"hipParamSetf", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuParamSeti", {"hipParamSeti", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuParamSetSize", {"hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuParamSetSize", {"hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuParamSetv", {"hipParamSetv", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Graph Management
|
|
{"cuGraphCreate", {"hipGraphCreate", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphLaunch", {"hipGraphLaunch", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddKernelNode", {"hipGraphAddKernelNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphKernelNodeGetParams", {"hipGraphKernelNodeGetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphKernelNodeSetParams", {"hipGraphKernelNodeSetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddMemcpyNode", {"hipGraphAddMemcpyNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphMemcpyNodeGetParams", {"hipGraphMemcpyNodeGetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphMemcpyNodeSetParams", {"hipGraphMemcpyNodeSetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddMemsetNode", {"hipGraphAddMemsetNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphMemsetNodeGetParams", {"hipGraphMemsetNodeGetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphMemsetNodeSetParams", {"hipGraphMemsetNodeSetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddHostNode", {"hipGraphAddHostNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphHostNodeGetParams", {"hipGraphHostNodeGetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphHostNodeSetParams", {"hipGraphHostNodeSetParams", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddChildGraphNode", {"hipGraphAddChildGraphNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphChildGraphNodeGetGraph", {"hipGraphChildGraphNodeGetGraph", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddEmptyNode", {"hipGraphAddEmptyNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphClone", {"hipGraphClone", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphNodeFindInClone", {"hipGraphNodeFindInClone", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphNodeGetType", {"hipGraphNodeGetType", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphGetNodes", {"hipGraphGetNodes", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphGetRootNodes", {"hipGraphGetRootNodes", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphGetEdges", {"hipGraphGetEdges", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphNodeGetDependencies", {"hipGraphNodeGetDependencies", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphNodeGetDependentNodes", {"hipGraphNodeGetDependentNodes", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphAddDependencies", {"hipGraphAddDependencies", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphRemoveDependencies", {"hipGraphRemoveDependencies", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphDestroyNode", {"hipGraphDestroyNode", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphInstantiate", {"hipGraphInstantiate", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphExecDestroy", {"hipGraphExecDestroy", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuGraphDestroy", {"hipGraphDestroy", CONV_GRAPH, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Occupancy
|
|
{"cuOccupancyMaxActiveBlocksPerMultiprocessor", {"hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_DRIVER}}, // API_Runtime ANALOGUE (cudaOccupancyMaxActiveBlocksPerMultiprocessor)
|
|
{"cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", {"hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)
|
|
{"cuOccupancyMaxPotentialBlockSize", {"hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_DRIVER}}, // API_Runtime ANALOGUE (cudaOccupancyMaxPotentialBlockSize)
|
|
{"cuOccupancyMaxPotentialBlockSizeWithFlags", {"hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaOccupancyMaxPotentialBlockSizeWithFlags)
|
|
|
|
// Streams
|
|
{"cuStreamAddCallback", {"hipStreamAddCallback", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamAttachMemAsync", {"hipStreamAttachMemAsync", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuStreamCreate", {"hipStreamCreate__", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaStreamCreate due to different signatures
|
|
{"cuStreamCreateWithPriority", {"hipStreamCreateWithPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuStreamDestroy_v2", {"hipStreamDestroy", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamGetFlags", {"hipStreamGetFlags", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamGetPriority", {"hipStreamGetPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuStreamQuery", {"hipStreamQuery", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamSynchronize", {"hipStreamSynchronize", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamWaitEvent", {"hipStreamWaitEvent", CONV_STREAM, API_DRIVER}},
|
|
{"cuStreamWaitValue32", {"hipStreamWaitValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuStreamWaitValue64", {"hipStreamWaitValue64", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuStreamWriteValue32", {"hipStreamWriteValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuStreamWriteValue64", {"hipStreamWriteValue64", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuStreamBatchMemOp", {"hipStreamBatchMemOp", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuStreamBeginCapture", {"hipStreamBeginCapture", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuStreamEndCapture", {"hipStreamEndCapture", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuStreamIsCapturing", {"hipStreamIsCapturing", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Memory management
|
|
{"cuArray3DCreate", {"hipArray3DCreate", CONV_MEM, API_DRIVER}},
|
|
{"cuArray3DGetDescriptor", {"hipArray3DGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuArrayCreate", {"hipArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuArrayDestroy", {"hipArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuArrayGetDescriptor", {"hipArrayGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuIpcCloseMemHandle", {"hipIpcCloseMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuIpcGetEventHandle", {"hipIpcGetEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuIpcGetMemHandle", {"hipIpcGetMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuIpcOpenEventHandle", {"hipIpcOpenEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuIpcOpenMemHandle", {"hipIpcOpenMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemAlloc_v2", {"hipMalloc", CONV_MEM, API_DRIVER}},
|
|
{"cuMemAllocHost", {"hipMemAllocHost", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemAllocManaged", {"hipMemAllocManaged", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemAllocPitch", {"hipMemAllocPitch__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemAllocPitch due to different signatures
|
|
{"cuMemcpy", {"hipMemcpy__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy due to different signatures
|
|
{"cuMemcpy2D", {"hipMemcpy2D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy2D due to different signatures
|
|
{"cuMemcpy2DAsync", {"hipMemcpy2DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy2DAsync due to different signatures
|
|
{"cuMemcpy2DUnaligned", {"hipMemcpy2DUnaligned", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpy3D", {"hipMemcpy3D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy3D due to different signatures
|
|
{"cuMemcpy3DAsync", {"hipMemcpy3DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy3DAsync due to different signatures
|
|
{"cuMemcpy3DPeer", {"hipMemcpy3DPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy3DPeer due to different signatures
|
|
{"cuMemcpy3DPeerAsync", {"hipMemcpy3DPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpy3DPeerAsync due to different signatures
|
|
{"cuMemcpyAsync", {"hipMemcpyAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpyAsync due to different signatures
|
|
{"cuMemcpyAtoA", {"hipMemcpyAtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyAtoD", {"hipMemcpyAtoD", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyAtoH", {"hipMemcpyAtoH", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyAtoHAsync", {"hipMemcpyAtoHAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyDtoA", {"hipMemcpyDtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyDtoD_v2", {"hipMemcpyDtoD", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyDtoDAsync_v2", {"hipMemcpyDtoDAsync", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyDtoH_v2", {"hipMemcpyDtoH", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyDtoHAsync_v2", {"hipMemcpyDtoHAsync", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyHtoA", {"hipMemcpyHtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyHtoAAsync", {"hipMemcpyHtoAAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemcpyHtoD_v2", {"hipMemcpyHtoD", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyHtoDAsync_v2", {"hipMemcpyHtoDAsync", CONV_MEM, API_DRIVER}},
|
|
{"cuMemcpyPeerAsync", {"hipMemcpyPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpyPeerAsync due to different signatures
|
|
{"cuMemcpyPeer", {"hipMemcpyPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaMemcpyPeer due to different signatures
|
|
{"cuMemFree_v2", {"hipFree", CONV_MEM, API_DRIVER}},
|
|
{"cuMemFreeHost", {"hipHostFree", CONV_MEM, API_DRIVER}},
|
|
{"cuMemGetAddressRange", {"hipMemGetAddressRange", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemGetInfo_v2", {"hipMemGetInfo", CONV_MEM, API_DRIVER}},
|
|
{"cuMemHostAlloc", {"hipHostMalloc", CONV_MEM, API_DRIVER}}, // API_Runtime ANALOGUE (cudaHostAlloc)
|
|
{"cuMemHostGetDevicePointer", {"hipMemHostGetDevicePointer", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemHostGetFlags", {"hipMemHostGetFlags", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemHostRegister_v2", {"hipHostRegister", CONV_MEM, API_DRIVER}}, // API_Runtime ANALOGUE (cudaHostAlloc)
|
|
{"cuMemHostUnregister", {"hipHostUnregister", CONV_MEM, API_DRIVER}}, // API_Runtime ANALOGUE (cudaHostUnregister)
|
|
{"cuMemsetD16_v2", {"hipMemsetD16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD16Async", {"hipMemsetD16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D16_v2", {"hipMemsetD2D16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D16Async", {"hipMemsetD2D16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D32_v2", {"hipMemsetD2D32", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D32Async", {"hipMemsetD2D32Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D8_v2", {"hipMemsetD2D8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD2D8Async", {"hipMemsetD2D8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD32_v2", {"hipMemset", CONV_MEM, API_DRIVER}}, // API_Runtime ANALOGUE (cudaMemset)
|
|
{"cuMemsetD32Async", {"hipMemsetAsync", CONV_MEM, API_DRIVER}}, // API_Runtime ANALOGUE (cudaMemsetAsync)
|
|
{"cuMemsetD8_v2", {"hipMemsetD8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMemsetD8Async", {"hipMemsetD8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMipmappedArrayCreate", {"hipMipmappedArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMipmappedArrayDestroy", {"hipMipmappedArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuMipmappedArrayGetLevel", {"hipMipmappedArrayGetLevel", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Unified Addressing
|
|
{"cuMemPrefetchAsync", {"hipMemPrefetchAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // // no API_Runtime ANALOGUE (cudaMemPrefetchAsync has different signature)
|
|
{"cuMemAdvise", {"hipMemAdvise", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // // API_Runtime ANALOGUE (cudaMemAdvise)
|
|
{"cuMemRangeGetAttribute", {"hipMemRangeGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // // API_Runtime ANALOGUE (cudaMemRangeGetAttribute)
|
|
{"cuMemRangeGetAttributes", {"hipMemRangeGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}}, // // API_Runtime ANALOGUE (cudaMemRangeGetAttributes)
|
|
{"cuPointerGetAttribute", {"hipPointerGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuPointerGetAttributes", {"hipPointerGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuPointerSetAttribute", {"hipPointerSetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Texture Reference Mngmnt
|
|
|
|
{"cuTexRefGetAddress", {"hipTexRefGetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetAddressMode", {"hipTexRefGetAddressMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetArray", {"hipTexRefGetArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetBorderColor", {"hipTexRefGetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}}, // // no API_Runtime ANALOGUE
|
|
{"cuTexRefGetFilterMode", {"hipTexRefGetFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetFlags", {"hipTexRefGetFlags", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetFormat", {"hipTexRefGetFormat", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetMaxAnisotropy", {"hipTexRefGetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetMipmapFilterMode", {"hipTexRefGetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetMipmapLevelBias", {"hipTexRefGetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetMipmapLevelClamp", {"hipTexRefGetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefGetMipmappedArray", {"hipTexRefGetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetAddress", {"hipTexRefSetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetAddress2D", {"hipTexRefSetAddress2D", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetAddressMode", {"hipTexRefSetAddressMode", CONV_TEX, API_DRIVER}},
|
|
{"cuTexRefSetArray", {"hipTexRefSetArray", CONV_TEX, API_DRIVER}},
|
|
{"cuTexRefSetBorderColor", {"hipTexRefSetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}}, // // no API_Runtime ANALOGUE
|
|
{"cuTexRefSetFilterMode", {"hipTexRefSetFilterMode", CONV_TEX, API_DRIVER}},
|
|
{"cuTexRefSetFlags", {"hipTexRefSetFlags", CONV_TEX, API_DRIVER}},
|
|
{"cuTexRefSetFormat", {"hipTexRefSetFormat", CONV_TEX, API_DRIVER}},
|
|
{"cuTexRefSetMaxAnisotropy", {"hipTexRefSetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetMipmapFilterMode", {"hipTexRefSetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetMipmapLevelBias", {"hipTexRefSetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetMipmapLevelClamp", {"hipTexRefSetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefSetMipmappedArray", {"hipTexRefSetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Texture Reference Mngmnt [DEPRECATED]
|
|
{"cuTexRefCreate", {"hipTexRefCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexRefDestroy", {"hipTexRefDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Surface Reference Mngmnt
|
|
{"cuSurfRefGetArray", {"hipSurfRefGetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuSurfRefSetArray", {"hipSurfRefSetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Texture Object Mngmnt
|
|
{"cuTexObjectCreate", {"hipTexObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexObjectDestroy", {"hipTexObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexObjectGetResourceDesc", {"hipTexObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexObjectGetResourceViewDesc", {"hipTexObjectGetResourceViewDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuTexObjectGetTextureDesc", {"hipTexObjectGetTextureDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Surface Object Mngmnt
|
|
{"cuSurfObjectCreate", {"hipSurfObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuSurfObjectDestroy", {"hipSurfObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuSurfObjectGetResourceDesc", {"hipSurfObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Graphics Interoperability
|
|
{"cuGraphicsMapResources", {"hipGraphicsMapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsMapResources)
|
|
{"cuGraphicsResourceGetMappedMipmappedArray", {"hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsResourceGetMappedMipmappedArray)
|
|
{"cuGraphicsResourceGetMappedPointer", {"hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsResourceGetMappedPointer)
|
|
{"cuGraphicsResourceSetMapFlags", {"hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsResourceSetMapFlags)
|
|
{"cuGraphicsSubResourceGetMappedArray", {"hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsSubResourceGetMappedArray)
|
|
{"cuGraphicsUnmapResources", {"hipGraphicsUnmapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsUnmapResources)
|
|
{"cuGraphicsUnregisterResource", {"hipGraphicsUnregisterResource", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsUnregisterResource)
|
|
|
|
// Profiler
|
|
{"cuProfilerInitialize", {"hipProfilerInitialize", CONV_OTHER, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaProfilerInitialize)
|
|
{"cuProfilerStart", {"hipProfilerStart", CONV_OTHER, API_DRIVER}}, // API_Runtime ANALOGUE (cudaProfilerStart)
|
|
{"cuProfilerStop", {"hipProfilerStop", CONV_OTHER, API_DRIVER}}, // API_Runtime ANALOGUE (cudaProfilerStop)
|
|
|
|
{"cuGLGetDevices", {"hipGLGetDevices", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLGetDevices)
|
|
{"cuGraphicsGLRegisterBuffer", {"hipGraphicsGLRegisterBuffer", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsGLRegisterBuffer)
|
|
{"cuGraphicsGLRegisterImage", {"hipGraphicsGLRegisterImage", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsGLRegisterImage)
|
|
{"cuWGLGetDevice", {"hipWGLGetDevice", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaWGLGetDevice)
|
|
|
|
{"cuGLCtxCreate", {"hipGLCtxCreate", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuGLInit", {"hipGLInit", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuGLMapBufferObject", {"hipGLMapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaGLMapBufferObject due to different signatures
|
|
{"cuGLMapBufferObjectAsync", {"hipGLMapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // Not equal to cudaGLMapBufferObjectAsync due to different signatures
|
|
{"cuGLRegisterBufferObject", {"hipGLRegisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLRegisterBufferObject)
|
|
{"cuGLSetBufferObjectMapFlags", {"hipGLSetBufferObjectMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLSetBufferObjectMapFlags)
|
|
{"cuGLUnmapBufferObject", {"hipGLUnmapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLUnmapBufferObject)
|
|
{"cuGLUnmapBufferObjectAsync", {"hipGLUnmapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLUnmapBufferObjectAsync)
|
|
{"cuGLUnregisterBufferObject", {"hipGLUnregisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLUnregisterBufferObject)
|
|
|
|
{"cuD3D9CtxCreate", {"hipD3D9CtxCreate", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D9CtxCreateOnDevice", {"hipD3D9CtxCreateOnDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D9GetDevice", {"hipD3D9GetDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9GetDevice)
|
|
{"cuD3D9GetDevices", {"hipD3D9GetDevices", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9GetDevices)
|
|
{"cuD3D9GetDirect3DDevice", {"hipD3D9GetDirect3DDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9GetDirect3DDevice)
|
|
{"cuGraphicsD3D9RegisterResource", {"hipGraphicsD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsD3D9RegisterResource)
|
|
|
|
{"cuD3D9MapResources", {"hipD3D9MapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9MapResources)
|
|
{"cuD3D9RegisterResource", {"hipD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9RegisterResource)
|
|
{"cuD3D9ResourceGetMappedArray", {"hipD3D9ResourceGetMappedArray", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceGetMappedArray)
|
|
{"cuD3D9ResourceGetMappedPitch", {"hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceGetMappedPitch)
|
|
{"cuD3D9ResourceGetMappedPointer", {"hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceGetMappedPointer)
|
|
{"cuD3D9ResourceGetMappedSize", {"hipD3D9ResourceGetMappedSize", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceGetMappedSize)
|
|
{"cuD3D9ResourceGetSurfaceDimensions", {"hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceGetSurfaceDimensions)
|
|
{"cuD3D9ResourceSetMapFlags", {"hipD3D9ResourceSetMapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9ResourceSetMapFlags)
|
|
{"cuD3D9UnmapResources", {"hipD3D9UnmapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9UnmapResources)
|
|
{"cuD3D9UnregisterResource", {"hipD3D9UnregisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9UnregisterResource)
|
|
|
|
// Direct3D 10 Interoperability
|
|
{"cuD3D10GetDevice", {"hipD3D10GetDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10GetDevice)
|
|
{"cuD3D10GetDevices", {"hipD3D10GetDevices", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10GetDevices)
|
|
{"cuGraphicsD3D10RegisterResource", {"hipGraphicsD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsD3D10RegisterResource)
|
|
|
|
// Direct3D 10 Interoperability [DEPRECATED]
|
|
{"cuD3D10CtxCreate", {"hipD3D10CtxCreate", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D10CtxCreateOnDevice", {"hipD3D10CtxCreateOnDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D10GetDirect3DDevice", {"hipD3D10GetDirect3DDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10GetDirect3DDevice)
|
|
{"cuD3D10MapResources", {"hipD3D10MapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10MapResources)
|
|
{"cuD3D10RegisterResource", {"hipD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10RegisterResource)
|
|
{"cuD3D10ResourceGetMappedArray", {"hipD3D10ResourceGetMappedArray", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceGetMappedArray)
|
|
{"cuD3D10ResourceGetMappedPitch", {"hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceGetMappedPitch)
|
|
{"cuD3D10ResourceGetMappedPointer", {"hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceGetMappedPointer)
|
|
{"cuD3D10ResourceGetMappedSize", {"hipD3D10ResourceGetMappedSize", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceGetMappedSize)
|
|
{"cuD3D10ResourceGetSurfaceDimensions", {"hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceGetSurfaceDimensions)
|
|
{"cuD310ResourceSetMapFlags", {"hipD3D10ResourceSetMapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10ResourceSetMapFlags)
|
|
{"cuD3D10UnmapResources", {"hipD3D10UnmapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10UnmapResources)
|
|
{"cuD3D10UnregisterResource", {"hipD3D10UnregisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10UnregisterResource)
|
|
|
|
// Direct3D 11 Interoperability
|
|
{"cuD3D11GetDevice", {"hipD3D11GetDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D11GetDevice)
|
|
{"cuD3D11GetDevices", {"hipD3D11GetDevices", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D11GetDevices)
|
|
{"cuGraphicsD3D11RegisterResource", {"hipGraphicsD3D11RegisterResource", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsD3D11RegisterResource)
|
|
|
|
// Direct3D 11 Interoperability [DEPRECATED]
|
|
{"cuD3D11CtxCreate", {"hipD3D11CtxCreate", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D11CtxCreateOnDevice", {"hipD3D11CtxCreateOnDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuD3D11GetDirect3DDevice", {"hipD3D11GetDirect3DDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D11GetDirect3DDevice)
|
|
|
|
// VDPAU Interoperability
|
|
{"cuGraphicsVDPAURegisterOutputSurface", {"hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsVDPAURegisterOutputSurface)
|
|
{"cuGraphicsVDPAURegisterVideoSurface", {"hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsVDPAURegisterVideoSurface)
|
|
{"cuVDPAUGetDevice", {"hipVDPAUGetDevice", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaVDPAUGetDevice)
|
|
{"cuVDPAUCtxCreate", {"hipVDPAUCtxCreate", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
|
|
// EGL Interoperability
|
|
{"cuEGLStreamConsumerAcquireFrame", {"hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamConsumerAcquireFrame)
|
|
{"cuEGLStreamConsumerConnect", {"hipEGLStreamConsumerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamConsumerConnect)
|
|
{"cuEGLStreamConsumerConnectWithFlags", {"hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamConsumerConnectWithFlags)
|
|
{"cuEGLStreamConsumerDisconnect", {"hipEGLStreamConsumerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // no API_Runtime ANALOGUE
|
|
{"cuEGLStreamConsumerReleaseFrame", {"hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamConsumerReleaseFrame)
|
|
{"cuEGLStreamProducerConnect", {"hipEGLStreamProducerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamProducerConnect)
|
|
{"cuEGLStreamProducerDisconnect", {"hipEGLStreamProducerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamProducerDisconnect)
|
|
{"cuEGLStreamProducerPresentFrame", {"hipEGLStreamProducerPresentFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamProducerPresentFrame)
|
|
{"cuEGLStreamProducerReturnFrame", {"hipEGLStreamProducerReturnFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEGLStreamProducerReturnFrame)
|
|
{"cuGraphicsEGLRegisterImage", {"hipGraphicsEGLRegisterImage", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsEGLRegisterImage)
|
|
{"cuGraphicsResourceGetMappedEglFrame", {"hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsResourceGetMappedEglFrame)
|
|
|
|
|
|
////////////////////////////// cuComplex API //////////////////////////////
|
|
{"cuFloatComplex", {"hipFloatComplex", CONV_TYPE, API_COMPLEX}},
|
|
{"cuDoubleComplex", {"hipDoubleComplex", CONV_TYPE, API_COMPLEX}},
|
|
{"cuComplex", {"hipComplex", CONV_TYPE, API_COMPLEX}},
|
|
|
|
{"cuCrealf", {"hipCrealf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCimagf", {"hipCimagf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"make_cuFloatComplex", {"make_hipFloatComplex", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuConjf", {"hipConjf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCaddf", {"hipCaddf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCsubf", {"hipCsubf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCmulf", {"hipCmulf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCdivf", {"hipCdivf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCabsf", {"hipCabsf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCreal", {"hipCreal", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCimag", {"hipCimag", CONV_COMPLEX, API_COMPLEX}},
|
|
{"make_cuDoubleComplex", {"make_hipDoubleComplex", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuConj", {"hipConj", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCadd", {"hipCadd", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCsub", {"hipCsub", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCmul", {"hipCmul", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCdiv", {"hipCdiv", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCabs", {"hipCabs", CONV_COMPLEX, API_COMPLEX}},
|
|
{"make_cuComplex", {"make_hipComplex", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuComplexFloatToDouble", {"hipComplexFloatToDouble", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuComplexDoubleToFloat", {"hipComplexDoubleToFloat", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCfmaf", {"hipCfmaf", CONV_COMPLEX, API_COMPLEX}},
|
|
{"cuCfma", {"hipCfma", CONV_COMPLEX, API_COMPLEX}},
|
|
|
|
/////////////////////////////// CUDA RT API ///////////////////////////////
|
|
// Data types
|
|
// TODO: rename hipblasDatatype_t to hipDataType_t and move from hipBLAS to HIP
|
|
{"cudaDataType_t", {"hipblasDatatype_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDataType", {"hipblasDatatype_t", CONV_TYPE, API_RUNTIME}},
|
|
{"CUDA_R_16F", {"HIPBLAS_R_16F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 2 // 150
|
|
{"CUDA_C_16F", {"HIPBLAS_C_16F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 6 // 153
|
|
{"CUDA_R_32F", {"HIPBLAS_R_32F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 0 // 151
|
|
{"CUDA_C_32F", {"HIPBLAS_C_32F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 4 // 154
|
|
{"CUDA_R_64F", {"HIPBLAS_R_64F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 1 // 152
|
|
{"CUDA_C_64F", {"HIPBLAS_C_64F", CONV_NUMERIC_LITERAL, API_RUNTIME}}, // 5 // 155
|
|
{"CUDA_R_8I", {"HIPBLAS_R_8I", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 //
|
|
{"CUDA_C_8I", {"HIPBLAS_C_8I", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 7 //
|
|
{"CUDA_R_8U", {"HIPBLAS_R_8U", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 8 //
|
|
{"CUDA_C_8U", {"HIPBLAS_C_8U", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 9 //
|
|
{"CUDA_R_32I", {"HIPBLAS_R_32I", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 10 //
|
|
{"CUDA_C_32I", {"HIPBLAS_C_32I", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 11 //
|
|
{"CUDA_R_32U", {"HIPBLAS_R_32U", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 12 //
|
|
{"CUDA_C_32U", {"HIPBLAS_C_32U", CONV_NUMERIC_LITERAL, API_RUNTIME, HIP_UNSUPPORTED}}, // 13 //
|
|
|
|
// Library property types
|
|
// IMPORTANT: no cuda prefix
|
|
{"MAJOR_VERSION", {"hipLibraryMajorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"MINOR_VERSION", {"hipLibraryMinorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"PATCH_LEVEL", {"hipLibraryPatchVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// defines
|
|
{"cudaMemAttachGlobal", {"hipMemAttachGlobal", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_Driver ANALOGUE (CU_MEM_ATTACH_GLOBAL = 0x1)
|
|
{"cudaMemAttachHost", {"hipMemAttachHost", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x02 // API_Driver ANALOGUE (CU_MEM_ATTACH_HOST = 0x2)
|
|
{"cudaMemAttachSingle", {"hipMemAttachSingle", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x04 // API_Driver ANALOGUE (CU_MEM_ATTACH_SINGLE = 0x4)
|
|
|
|
{"cudaOccupancyDefault", {"hipOccupancyDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x00 // API_Driver ANALOGUE (CU_OCCUPANCY_DEFAULT = 0x0)
|
|
{"cudaOccupancyDisableCachingOverride", {"hipOccupancyDisableCachingOverride", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_Driver ANALOGUE (CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = 0x1)
|
|
|
|
// Error API
|
|
{"cudaGetLastError", {"hipGetLastError", CONV_ERROR, API_RUNTIME}},
|
|
{"cudaPeekAtLastError", {"hipPeekAtLastError", CONV_ERROR, API_RUNTIME}},
|
|
{"cudaGetErrorName", {"hipGetErrorName", CONV_ERROR, API_RUNTIME}},
|
|
{"cudaGetErrorString", {"hipGetErrorString", CONV_ERROR, API_RUNTIME}},
|
|
|
|
// memcpy
|
|
// memcpy structs
|
|
{"cudaMemcpy3DParms", {"hipMemcpy3DParms", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy3DPeerParms", {"hipMemcpy3DPeerParms", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// memcpy functions
|
|
{"cudaMemcpy", {"hipMemcpy", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyToArray", {"hipMemcpyToArray", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyToSymbol", {"hipMemcpyToSymbol", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyToSymbolAsync", {"hipMemcpyToSymbolAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyAsync", {"hipMemcpyAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy2D", {"hipMemcpy2D", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy2DAsync", {"hipMemcpy2DAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy2DToArray", {"hipMemcpy2DToArray", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy2DArrayToArray", {"hipMemcpy2DArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy2DFromArray", {"hipMemcpy2DFromArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy2DFromArrayAsync", {"hipMemcpy2DFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy2DToArrayAsync", {"hipMemcpy2DToArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy3D", {"hipMemcpy3D", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpy3DAsync", {"hipMemcpy3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy3DPeer", {"hipMemcpy3DPeer", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpy3DPeerAsync", {"hipMemcpy3DPeerAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpyArrayToArray", {"hipMemcpyArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpyFromArrayAsync", {"hipMemcpyFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemcpyFromSymbol", {"hipMemcpyFromSymbol", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyFromSymbolAsync", {"hipMemcpyFromSymbolAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemAdvise", {"hipMemAdvise", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}}, //
|
|
{"cudaMemRangeGetAttribute", {"hipMemRangeGetAttribute", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}}, //
|
|
{"cudaMemRangeGetAttributes", {"hipMemRangeGetAttributes", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}}, //
|
|
|
|
// Memory advise values
|
|
{"cudaMemAdviseSetReadMostly", {"hipMemAdviseSetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_MEM_ADVISE_SET_READ_MOSTLY = 1)
|
|
{"cudaMemAdviseUnsetReadMostly", {"hipMemAdviseUnsetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_MEM_ADVISE_UNSET_READ_MOSTLY = 2)
|
|
{"cudaMemAdviseSetPreferredLocation", {"hipMemAdviseSetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_Driver ANALOGUE (CU_MEM_ADVISE_SET_PREFERRED_LOCATION = 3)
|
|
{"cudaMemAdviseUnsetPreferredLocation", {"hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 4 // API_Driver ANALOGUE (CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = 4)
|
|
{"cudaMemAdviseSetAccessedBy", {"hipMemAdviseSetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 5 // API_Driver ANALOGUE (CU_MEM_ADVISE_SET_ACCESSED_BY = 5)
|
|
{"cudaMemAdviseUnsetAccessedBy", {"hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 6 // API_Driver ANALOGUE (CU_MEM_ADVISE_UNSET_ACCESSED_BY = 6)
|
|
|
|
// CUmem_range_attribute
|
|
{"cudaMemRangeAttributeReadMostly", {"hipMemRangeAttributeReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = 1)
|
|
{"cudaMemRangeAttributePreferredLocation", {"hipMemRangeAttributePreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = 2)
|
|
{"cudaMemRangeAttributeAccessedBy", {"hipMemRangeAttributeAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_Driver ANALOGUE (CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = 3)
|
|
{"cudaMemRangeAttributeLastPrefetchLocation", {"hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 4 // API_Driver ANALOGUE (CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = 4)
|
|
|
|
// memcpy kind
|
|
{"cudaMemcpyHostToHost", {"hipMemcpyHostToHost", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyHostToDevice", {"hipMemcpyHostToDevice", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyDeviceToHost", {"hipMemcpyDeviceToHost", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyDeviceToDevice", {"hipMemcpyDeviceToDevice", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyDefault", {"hipMemcpyDefault", CONV_MEM, API_RUNTIME}},
|
|
|
|
// memset
|
|
{"cudaMemset", {"hipMemset", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemsetAsync", {"hipMemsetAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemset2D", {"hipMemset2D", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemset2DAsync", {"hipMemset2DAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemset3D", {"hipMemset3D", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemset3DAsync", {"hipMemset3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Memory management
|
|
{"cudaMemGetInfo", {"hipMemGetInfo", CONV_MEM, API_RUNTIME}},
|
|
{"cudaArrayGetInfo", {"hipArrayGetInfo", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaFreeMipmappedArray", {"hipFreeMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGetMipmappedArrayLevel", {"hipGetMipmappedArrayLevel", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGetSymbolAddress", {"hipGetSymbolAddress", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGetSymbolSize", {"hipGetSymbolSize", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMemPrefetchAsync", {"hipMemPrefetchAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}}, // // API_Driver ANALOGUE (cuMemPrefetchAsync)
|
|
|
|
// malloc
|
|
{"cudaMalloc", {"hipMalloc", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMallocHost", {"hipHostMalloc", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMallocArray", {"hipMallocArray", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMalloc3D", {"hipMalloc3D", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMalloc3DArray", {"hipMalloc3DArray", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMallocManaged", {"hipMallocManaged", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMallocMipmappedArray", {"hipMallocMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaMallocPitch", {"hipMallocPitch", CONV_MEM, API_RUNTIME}},
|
|
|
|
{"cudaFree", {"hipFree", CONV_MEM, API_RUNTIME}},
|
|
{"cudaFreeHost", {"hipHostFree", CONV_MEM, API_RUNTIME}},
|
|
{"cudaFreeArray", {"hipFreeArray", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostRegister", {"hipHostRegister", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostUnregister", {"hipHostUnregister", CONV_MEM, API_RUNTIME}},
|
|
// hipHostAlloc deprecated - use hipHostMalloc instead
|
|
{"cudaHostAlloc", {"hipHostMalloc", CONV_MEM, API_RUNTIME}},
|
|
|
|
// enum cudaMemoryType
|
|
{"cudaMemoryTypeHost", {"hipMemoryTypeHost", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemoryTypeDevice", {"hipMemoryTypeDevice", CONV_MEM, API_RUNTIME}},
|
|
|
|
// make memory functions
|
|
{"make_cudaExtent", {"make_hipExtent", CONV_MEM, API_RUNTIME}},
|
|
{"make_cudaPitchedPtr", {"make_hipPitchedPtr", CONV_MEM, API_RUNTIME}},
|
|
{"make_cudaPos", {"make_hipPos", CONV_MEM, API_RUNTIME}},
|
|
|
|
// Host Malloc Flags (#defines)
|
|
{"cudaHostAllocDefault", {"hipHostMallocDefault", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostAllocPortable", {"hipHostMallocPortable", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostAllocMapped", {"hipHostMallocMapped", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostAllocWriteCombined", {"hipHostMallocWriteCombined", CONV_MEM, API_RUNTIME}},
|
|
|
|
// Host Register Flags
|
|
{"cudaHostGetFlags", {"hipHostGetFlags", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostRegisterDefault", {"hipHostRegisterDefault", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostRegisterPortable", {"hipHostRegisterPortable", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostRegisterMapped", {"hipHostRegisterMapped", CONV_MEM, API_RUNTIME}},
|
|
{"cudaHostRegisterIoMemory", {"hipHostRegisterIoMemory", CONV_MEM, API_RUNTIME}},
|
|
|
|
{"warpSize", {"hipWarpSize", CONV_SPECIAL_FUNC, API_RUNTIME}},
|
|
|
|
// Events
|
|
{"cudaEventCreate", {"hipEventCreate", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventCreateWithFlags", {"hipEventCreateWithFlags", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventDestroy", {"hipEventDestroy", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventRecord", {"hipEventRecord", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventElapsedTime", {"hipEventElapsedTime", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventSynchronize", {"hipEventSynchronize", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventQuery", {"hipEventQuery", CONV_EVENT, API_RUNTIME}},
|
|
// Event Flags
|
|
{"cudaEventDefault", {"hipEventDefault", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventBlockingSync", {"hipEventBlockingSync", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventDisableTiming", {"hipEventDisableTiming", CONV_EVENT, API_RUNTIME}},
|
|
{"cudaEventInterprocess", {"hipEventInterprocess", CONV_EVENT, API_RUNTIME}},
|
|
|
|
// Streams
|
|
{"cudaStreamCreate", {"hipStreamCreate", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamCreateWithFlags", {"hipStreamCreateWithFlags", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamCreateWithPriority", {"hipStreamCreateWithPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaStreamDestroy", {"hipStreamDestroy", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamWaitEvent", {"hipStreamWaitEvent", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamSynchronize", {"hipStreamSynchronize", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamGetFlags", {"hipStreamGetFlags", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamQuery", {"hipStreamQuery", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamAddCallback", {"hipStreamAddCallback", CONV_STREAM, API_RUNTIME}},
|
|
{"cudaStreamAttachMemAsync", {"hipStreamAttachMemAsync", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaStreamGetPriority", {"hipStreamGetPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Stream Flags (defines)
|
|
{"cudaStreamDefault", {"hipStreamDefault", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaStreamNonBlocking", {"hipStreamNonBlocking", CONV_TYPE, API_RUNTIME}},
|
|
|
|
// Other synchronization
|
|
{"cudaDeviceSynchronize", {"hipDeviceSynchronize", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaDeviceReset", {"hipDeviceReset", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaSetDevice", {"hipSetDevice", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaGetDevice", {"hipGetDevice", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaGetDeviceCount", {"hipGetDeviceCount", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaChooseDevice", {"hipChooseDevice", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// Thread Management
|
|
{"cudaThreadExit", {"hipDeviceReset", CONV_THREAD, API_RUNTIME}},
|
|
{"cudaThreadGetCacheConfig", {"hipDeviceGetCacheConfig", CONV_THREAD, API_RUNTIME}},
|
|
{"cudaThreadGetLimit", {"hipThreadGetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaThreadSetCacheConfig", {"hipDeviceSetCacheConfig", CONV_THREAD, API_RUNTIME}},
|
|
{"cudaThreadSetLimit", {"hipThreadSetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaThreadSynchronize", {"hipDeviceSynchronize", CONV_THREAD, API_RUNTIME}},
|
|
|
|
// Attributes
|
|
{"cudaDeviceGetAttribute", {"hipDeviceGetAttribute", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// enum cudaDeviceAttr
|
|
{"cudaDevAttrMaxThreadsPerBlock", {"hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_RUNTIME}}, // 1 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1)
|
|
{"cudaDevAttrMaxBlockDimX", {"hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_RUNTIME}}, // 2 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = 2)
|
|
{"cudaDevAttrMaxBlockDimY", {"hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_RUNTIME}}, // 3 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = 3)
|
|
{"cudaDevAttrMaxBlockDimZ", {"hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_RUNTIME}}, // 4 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = 4)
|
|
{"cudaDevAttrMaxGridDimX", {"hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_RUNTIME}}, // 5 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 5)
|
|
{"cudaDevAttrMaxGridDimY", {"hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_RUNTIME}}, // 6 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 6)
|
|
{"cudaDevAttrMaxGridDimZ", {"hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_RUNTIME}}, // 7 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = 7)
|
|
{"cudaDevAttrMaxSharedMemoryPerBlock", {"hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_RUNTIME}}, // 8 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = 8)
|
|
{"cudaDevAttrTotalConstantMemory", {"hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_RUNTIME}}, // 9 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY =9)
|
|
{"cudaDevAttrWarpSize", {"hipDeviceAttributeWarpSize", CONV_TYPE, API_RUNTIME}}, // 10 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10)
|
|
{"cudaDevAttrMaxPitch", {"hipDeviceAttributeMaxPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 11 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_PITCH = 11)
|
|
{"cudaDevAttrMaxRegistersPerBlock", {"hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_RUNTIME}}, // 12 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12)
|
|
{"cudaDevAttrClockRate", {"hipDeviceAttributeClockRate", CONV_TYPE, API_RUNTIME}}, // 13 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13)
|
|
{"cudaDevAttrTextureAlignment", {"hipDeviceAttributeTextureAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 14 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = 14)
|
|
// Is not deprecated as CUDA Driver's API analogue CU_DEVICE_ATTRIBUTE_GPU_OVERLAP
|
|
{"cudaDevAttrGpuOverlap", {"hipDeviceAttributeGpuOverlap", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 15 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15)
|
|
{"cudaDevAttrMultiProcessorCount", {"hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_RUNTIME}}, // 16 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16)
|
|
{"cudaDevAttrKernelExecTimeout", {"hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 17 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = 17)
|
|
{"cudaDevAttrIntegrated", {"hipDeviceAttributeIntegrated", CONV_TYPE, API_RUNTIME}}, // 18 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_INTEGRATED = 18)
|
|
{"cudaDevAttrCanMapHostMemory", {"hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 19 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19)
|
|
{"cudaDevAttrComputeMode", {"hipDeviceAttributeComputeMode", CONV_TYPE, API_RUNTIME}}, // 20 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20)
|
|
{"cudaDevAttrMaxTexture1DWidth", {"hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 21 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = 21)
|
|
{"cudaDevAttrMaxTexture2DWidth", {"hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 22 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = 22)
|
|
{"cudaDevAttrMaxTexture2DHeight", {"hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 23 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = 23)
|
|
{"cudaDevAttrMaxTexture3DWidth", {"hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 24 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = 24)
|
|
{"cudaDevAttrMaxTexture3DHeight", {"hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 25 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25)
|
|
{"cudaDevAttrMaxTexture3DDepth", {"hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 26 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26)
|
|
{"cudaDevAttrMaxTexture2DLayeredWidth", {"hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 27 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27)
|
|
{"cudaDevAttrMaxTexture2DLayeredHeight", {"hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 28 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28)
|
|
{"cudaDevAttrMaxTexture2DLayeredLayers", {"hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 29 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29)
|
|
{"cudaDevAttrSurfaceAlignment", {"hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 30 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30)
|
|
{"cudaDevAttrConcurrentKernels", {"hipDeviceAttributeConcurrentKernels", CONV_TYPE, API_RUNTIME}}, // 31 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31)
|
|
{"cudaDevAttrEccEnabled", {"hipDeviceAttributeEccEnabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 32 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_ECC_ENABLED = 32)
|
|
{"cudaDevAttrPciBusId", {"hipDeviceAttributePciBusId", CONV_TYPE, API_RUNTIME}}, // 33 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = 33)
|
|
{"cudaDevAttrPciDeviceId", {"hipDeviceAttributePciDeviceId", CONV_TYPE, API_RUNTIME}}, // 34 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = 34)
|
|
{"cudaDevAttrTccDriver", {"hipDeviceAttributeTccDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 35 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_TCC_DRIVER = 35)
|
|
{"cudaDevAttrMemoryClockRate", {"hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_RUNTIME}}, // 36 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = 36)
|
|
{"cudaDevAttrGlobalMemoryBusWidth", {"hipDeviceAttributeMemoryBusWidth", CONV_TYPE, API_RUNTIME}}, // 37 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = 37)
|
|
{"cudaDevAttrL2CacheSize", {"hipDeviceAttributeL2CacheSize", CONV_TYPE, API_RUNTIME}}, // 38 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = 38)
|
|
{"cudaDevAttrMaxThreadsPerMultiProcessor", {"hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE, API_RUNTIME}}, // 39 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39)
|
|
{"cudaDevAttrAsyncEngineCount", {"hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 40 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40)
|
|
{"cudaDevAttrUnifiedAddressing", {"hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 41 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = 41)
|
|
{"cudaDevAttrMaxTexture1DLayeredWidth", {"hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 42 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = 42)
|
|
{"cudaDevAttrMaxTexture1DLayeredLayers", {"hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 43 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = 43)
|
|
// 44 - no
|
|
{"cudaDevAttrMaxTexture2DGatherWidth", {"hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 45 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = 45)
|
|
{"cudaDevAttrMaxTexture2DGatherHeight", {"hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 46 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = 46)
|
|
{"cudaDevAttrMaxTexture3DWidthAlt", {"hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 47 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = 47)
|
|
{"cudaDevAttrMaxTexture3DHeightAlt", {"hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 48 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = 48)
|
|
{"cudaDevAttrMaxTexture3DDepthAlt", {"hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 49 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = 49)
|
|
{"cudaDevAttrPciDomainId", {"hipDeviceAttributePciDomainId", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 50 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = 50)
|
|
{"cudaDevAttrTexturePitchAlignment", {"hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 51 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = 51)
|
|
{"cudaDevAttrMaxTextureCubemapWidth", {"hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 52 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = 52)
|
|
{"cudaDevAttrMaxTextureCubemapLayeredWidth", {"hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 53 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = 53)
|
|
{"cudaDevAttrMaxTextureCubemapLayeredLayers", {"hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 54 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = 54)
|
|
{"cudaDevAttrMaxSurface1DWidth", {"hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 55 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = 55)
|
|
{"cudaDevAttrMaxSurface2DWidth", {"hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 56 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = 56)
|
|
{"cudaDevAttrMaxSurface2DHeight", {"hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 57 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = 57)
|
|
{"cudaDevAttrMaxSurface3DWidth", {"hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 58 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = 58)
|
|
{"cudaDevAttrMaxSurface3DHeight", {"hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 59 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = 59)
|
|
{"cudaDevAttrMaxSurface3DDepth", {"hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 60 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = 60)
|
|
{"cudaDevAttrMaxSurface1DLayeredWidth", {"hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 61 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = 61)
|
|
{"cudaDevAttrMaxSurface1DLayeredLayers", {"hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 62 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = 62)
|
|
{"cudaDevAttrMaxSurface2DLayeredWidth", {"hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 63 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = 63)
|
|
{"cudaDevAttrMaxSurface2DLayeredHeight", {"hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 64 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = 64)
|
|
{"cudaDevAttrMaxSurface2DLayeredLayers", {"hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 65 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = 65)
|
|
{"cudaDevAttrMaxSurfaceCubemapWidth", {"hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 66 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = 66)
|
|
{"cudaDevAttrMaxSurfaceCubemapLayeredWidth", {"hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 67 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = 67)
|
|
{"cudaDevAttrMaxSurfaceCubemapLayeredLayers", {"hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 68 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = 68)
|
|
{"cudaDevAttrMaxTexture1DLinearWidth", {"hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 69 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = 69)
|
|
{"cudaDevAttrMaxTexture2DLinearWidth", {"hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 70 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = 70)
|
|
{"cudaDevAttrMaxTexture2DLinearHeight", {"hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 71 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = 71)
|
|
{"cudaDevAttrMaxTexture2DLinearPitch", {"hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 72 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = 72)
|
|
{"cudaDevAttrMaxTexture2DMipmappedWidth", {"hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 73 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = 73)
|
|
{"cudaDevAttrMaxTexture2DMipmappedHeight", {"hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 74 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = 74)
|
|
{"cudaDevAttrComputeCapabilityMajor", {"hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE, API_RUNTIME}}, // 75 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75)
|
|
{"cudaDevAttrComputeCapabilityMinor", {"hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE, API_RUNTIME}}, // 76 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76)
|
|
{"cudaDevAttrMaxTexture1DMipmappedWidth", {"hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 77 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = 77)
|
|
{"cudaDevAttrStreamPrioritiesSupported", {"hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 78 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = 78)
|
|
{"cudaDevAttrGlobalL1CacheSupported", {"hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 79 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = 79)
|
|
{"cudaDevAttrLocalL1CacheSupported", {"hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 80 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = 80)
|
|
{"cudaDevAttrMaxSharedMemoryPerMultiprocessor", {"hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE, API_RUNTIME}}, // 81 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = 81)
|
|
{"cudaDevAttrMaxRegistersPerMultiprocessor", {"hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 82 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82)
|
|
{"cudaDevAttrManagedMemory", {"hipDeviceAttributeManagedMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 83 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = 83)
|
|
{"cudaDevAttrIsMultiGpuBoard", {"hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE, API_RUNTIME}}, // 84 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = 84)
|
|
{"cudaDevAttrMultiGpuBoardGroupID", {"hipDeviceAttributeMultiGpuBoardGroupID", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 85 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = 85)
|
|
{"cudaDevAttrHostNativeAtomicSupported", {"hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 86 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = 86)
|
|
{"cudaDevAttrSingleToDoublePrecisionPerfRatio", {"hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 87 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = 87)
|
|
{"cudaDevAttrPageableMemoryAccess", {"hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 88 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = 88)
|
|
{"cudaDevAttrConcurrentManagedAccess", {"hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 89 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = 89)
|
|
{"cudaDevAttrComputePreemptionSupported", {"hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 90 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = 90)
|
|
{"cudaDevAttrCanUseHostPointerForRegisteredMem", {"hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 91 // API_DRIVER ANALOGUE (CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = 91)
|
|
|
|
// Pointer Attributes
|
|
// struct cudaPointerAttributes
|
|
{"cudaPointerGetAttributes", {"hipPointerGetAttributes", CONV_MEM, API_RUNTIME}},
|
|
|
|
{"cudaHostGetDevicePointer", {"hipHostGetDevicePointer", CONV_MEM, API_RUNTIME}},
|
|
|
|
// Device
|
|
{"cudaGetDeviceProperties", {"hipGetDeviceProperties", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaDeviceGetPCIBusId", {"hipDeviceGetPCIBusId", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaDeviceGetByPCIBusId", {"hipDeviceGetByPCIBusId", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaDeviceGetStreamPriorityRange", {"hipDeviceGetStreamPriorityRange", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSetValidDevices", {"hipSetValidDevices", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// P2P Attributes (enum cudaDeviceP2PAttr)
|
|
{"cudaDevP2PAttrPerformanceRank", {"hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_DRIVER ANALOGUE (CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = 0x01)
|
|
{"cudaDevP2PAttrAccessSupported", {"hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x02 // API_DRIVER ANALOGUE (CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = 0x02)
|
|
{"cudaDevP2PAttrNativeAtomicSupported", {"hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x03 // API_DRIVER ANALOGUE (CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = 0x03)
|
|
//
|
|
{"cudaDeviceGetP2PAttribute", {"hipDeviceGetP2PAttribute", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}}, // API_DRIVER ANALOGUE (cuDeviceGetP2PAttribute)
|
|
|
|
// enum cudaComputeMode
|
|
{"cudaComputeModeDefault", {"hipComputeModeDefault", CONV_TYPE, API_RUNTIME}}, // 0 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_DEFAULT = 0)
|
|
{"cudaComputeModeExclusive", {"hipComputeModeExclusive", CONV_TYPE, API_RUNTIME}}, // 1 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE = 1)
|
|
{"cudaComputeModeProhibited", {"hipComputeModeProhibited", CONV_TYPE, API_RUNTIME}}, // 2 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_PROHIBITED = 2)
|
|
{"cudaComputeModeExclusiveProcess", {"hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME}}, // 3 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE_PROCESS = 3)
|
|
|
|
// Device Flags
|
|
{"cudaGetDeviceFlags", {"hipGetDeviceFlags", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSetDeviceFlags", {"hipSetDeviceFlags", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// Device stuff (#defines)
|
|
{"cudaDeviceScheduleAuto", {"hipDeviceScheduleAuto", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceScheduleSpin", {"hipDeviceScheduleSpin", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceScheduleYield", {"hipDeviceScheduleYield", CONV_TYPE, API_RUNTIME}},
|
|
// deprecated as of CUDA 4.0 and replaced with cudaDeviceScheduleBlockingSync
|
|
{"cudaDeviceBlockingSync", {"hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceScheduleBlockingSync", {"hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceScheduleMask", {"hipDeviceScheduleMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaDeviceMapHost", {"hipDeviceMapHost", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaDeviceLmemResizeToMax", {"hipDeviceLmemResizeToMax", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaDeviceMask", {"hipDeviceMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Cache config
|
|
{"cudaDeviceSetCacheConfig", {"hipDeviceSetCacheConfig", CONV_CACHE, API_RUNTIME}},
|
|
{"cudaDeviceGetCacheConfig", {"hipDeviceGetCacheConfig", CONV_CACHE, API_RUNTIME}},
|
|
{"cudaFuncSetCacheConfig", {"hipFuncSetCacheConfig", CONV_CACHE, API_RUNTIME}},
|
|
|
|
// Execution control
|
|
// CUDA function cache configurations (enum cudaFuncCache)
|
|
{"cudaFuncCachePreferNone", {"hipFuncCachePreferNone", CONV_CACHE, API_RUNTIME}}, // 0 // API_Driver ANALOGUE (CU_FUNC_CACHE_PREFER_NONE = 0x00)
|
|
{"cudaFuncCachePreferShared", {"hipFuncCachePreferShared", CONV_CACHE, API_RUNTIME}}, // 1 // API_Driver ANALOGUE (CU_FUNC_CACHE_PREFER_SHARED = 0x01)
|
|
{"cudaFuncCachePreferL1", {"hipFuncCachePreferL1", CONV_CACHE, API_RUNTIME}}, // 2 // API_Driver ANALOGUE (CU_FUNC_CACHE_PREFER_L1 = 0x02)
|
|
{"cudaFuncCachePreferEqual", {"hipFuncCachePreferEqual", CONV_CACHE, API_RUNTIME}}, // 3 // API_Driver ANALOGUE (CU_FUNC_CACHE_PREFER_EQUAL = 0x03)
|
|
|
|
// Execution control functions
|
|
{"cudaFuncGetAttributes", {"hipFuncGetAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaFuncSetSharedMemConfig", {"hipFuncSetSharedMemConfig", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGetParameterBuffer", {"hipGetParameterBuffer", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSetDoubleForDevice", {"hipSetDoubleForDevice", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSetDoubleForHost", {"hipSetDoubleForHost", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Execution Control [deprecated since 7.0]
|
|
{"cudaConfigureCall", {"hipConfigureCall", CONV_EXEC, API_RUNTIME}},
|
|
{"cudaLaunch", {"hipLaunchByPtr", CONV_EXEC, API_RUNTIME}},
|
|
{"cudaSetupArgument", {"hipSetupArgument", CONV_EXEC, API_RUNTIME}},
|
|
|
|
// Version Management
|
|
{"cudaDriverGetVersion", {"hipDriverGetVersion", CONV_VERSION, API_RUNTIME}},
|
|
{"cudaRuntimeGetVersion", {"hipRuntimeGetVersion", CONV_VERSION, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Occupancy
|
|
{"cudaOccupancyMaxPotentialBlockSize", {"hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_RUNTIME}},
|
|
{"cudaOccupancyMaxPotentialBlockSizeWithFlags", {"hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaOccupancyMaxActiveBlocksPerMultiprocessor", {"hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_RUNTIME}},
|
|
{"cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", {"hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaOccupancyMaxPotentialBlockSizeVariableSMem", {"hipOccupancyMaxPotentialBlockSizeVariableSMem", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags", {"hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Peer2Peer
|
|
{"cudaDeviceCanAccessPeer", {"hipDeviceCanAccessPeer", CONV_PEER, API_RUNTIME}},
|
|
{"cudaDeviceDisablePeerAccess", {"hipDeviceDisablePeerAccess", CONV_PEER, API_RUNTIME}},
|
|
{"cudaDeviceEnablePeerAccess", {"hipDeviceEnablePeerAccess", CONV_PEER, API_RUNTIME}},
|
|
|
|
{"cudaMemcpyPeerAsync", {"hipMemcpyPeerAsync", CONV_MEM, API_RUNTIME}},
|
|
{"cudaMemcpyPeer", {"hipMemcpyPeer", CONV_MEM, API_RUNTIME}},
|
|
|
|
// #define cudaIpcMemLazyEnablePeerAccess 0x01
|
|
{"cudaIpcMemLazyEnablePeerAccess", {"hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_RUNTIME}}, // 0x01 // API_Driver ANALOGUE (CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = 0x1)
|
|
|
|
// Shared memory
|
|
{"cudaDeviceSetSharedMemConfig", {"hipDeviceSetSharedMemConfig", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaDeviceGetSharedMemConfig", {"hipDeviceGetSharedMemConfig", CONV_DEVICE, API_RUNTIME}},
|
|
// translate deprecated
|
|
// {"cudaThreadGetSharedMemConfig", {"hipDeviceGetSharedMemConfig", CONV_DEVICE, API_RUNTIME}},
|
|
// {"cudaThreadSetSharedMemConfig", {"hipDeviceSetSharedMemConfig", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// enum cudaSharedMemConfig
|
|
{"cudaSharedMemBankSizeDefault", {"hipSharedMemBankSizeDefault", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaSharedMemBankSizeFourByte", {"hipSharedMemBankSizeFourByte", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaSharedMemBankSizeEightByte", {"hipSharedMemBankSizeEightByte", CONV_TYPE, API_RUNTIME}},
|
|
|
|
// enum cudaLimit
|
|
{"cudaLimitStackSize", {"hipLimitStackSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x00 // API_Driver ANALOGUE (CU_LIMIT_STACK_SIZE = 0x00)
|
|
{"cudaLimitPrintfFifoSize", {"hipLimitPrintfFifoSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_Driver ANALOGUE (CU_LIMIT_PRINTF_FIFO_SIZE = 0x01)
|
|
{"cudaLimitMallocHeapSize", {"hipLimitMallocHeapSize", CONV_TYPE, API_RUNTIME}}, // 0x02 // API_Driver ANALOGUE (CU_LIMIT_MALLOC_HEAP_SIZE = 0x02)
|
|
{"cudaLimitDevRuntimeSyncDepth", {"hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x03 // API_Driver ANALOGUE (CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = 0x03)
|
|
{"cudaLimitDevRuntimePendingLaunchCount", {"hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x04 // API_Driver ANALOGUE (CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = 0x04)
|
|
|
|
{"cudaDeviceGetLimit", {"hipDeviceGetLimit", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// Profiler
|
|
{"cudaProfilerInitialize", {"hipProfilerInitialize", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuProfilerInitialize)
|
|
{"cudaProfilerStart", {"hipProfilerStart", CONV_OTHER, API_RUNTIME}}, // API_Driver ANALOGUE (cuProfilerStart)
|
|
{"cudaProfilerStop", {"hipProfilerStop", CONV_OTHER, API_RUNTIME}}, // API_Driver ANALOGUE (cuProfilerStop)
|
|
|
|
// enum cudaOutputMode
|
|
{"cudaKeyValuePair", {"hipKeyValuePair", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaCSV", {"hipCSV", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Texture Reference Management
|
|
// enum cudaTextureReadMode
|
|
{"cudaReadModeElementType", {"hipReadModeElementType", CONV_TEX, API_RUNTIME}},
|
|
{"cudaReadModeNormalizedFloat", {"hipReadModeNormalizedFloat", CONV_TEX, API_RUNTIME}},
|
|
|
|
// enum cudaTextureFilterMode
|
|
{"cudaFilterModePoint", {"hipFilterModePoint", CONV_TEX, API_RUNTIME}}, // 0 // API_DRIVER ANALOGUE (CU_TR_FILTER_MODE_POINT = 0)
|
|
{"cudaFilterModeLinear", {"hipFilterModeLinear", CONV_TEX, API_RUNTIME}}, // 1 // API_DRIVER ANALOGUE (CU_TR_FILTER_MODE_POINT = 1)
|
|
|
|
{"cudaBindTexture", {"hipBindTexture", CONV_TEX, API_RUNTIME}},
|
|
{"cudaUnbindTexture", {"hipUnbindTexture", CONV_TEX, API_RUNTIME}},
|
|
{"cudaBindTexture2D", {"hipBindTexture2D", CONV_TEX, API_RUNTIME}},
|
|
{"cudaBindTextureToArray", {"hipBindTextureToArray", CONV_TEX, API_RUNTIME}},
|
|
{"cudaBindTextureToMipmappedArray", {"hipBindTextureToMipmappedArray", CONV_TEX, API_RUNTIME}}, // Unsupported yet on NVCC path
|
|
{"cudaGetTextureAlignmentOffset", {"hipGetTextureAlignmentOffset", CONV_TEX, API_RUNTIME}}, // Unsupported yet on NVCC path
|
|
{"cudaGetTextureReference", {"hipGetTextureReference", CONV_TEX, API_RUNTIME}}, // Unsupported yet on NVCC path
|
|
|
|
// Channel (enum cudaChannelFormatKind)
|
|
{"cudaChannelFormatKindSigned", {"hipChannelFormatKindSigned", CONV_TEX, API_RUNTIME}},
|
|
{"cudaChannelFormatKindUnsigned", {"hipChannelFormatKindUnsigned", CONV_TEX, API_RUNTIME}},
|
|
{"cudaChannelFormatKindFloat", {"hipChannelFormatKindFloat", CONV_TEX, API_RUNTIME}},
|
|
{"cudaChannelFormatKindNone", {"hipChannelFormatKindNone", CONV_TEX, API_RUNTIME}},
|
|
|
|
{"cudaCreateChannelDesc", {"hipCreateChannelDesc", CONV_TEX, API_RUNTIME}},
|
|
{"cudaGetChannelDesc", {"hipGetChannelDesc", CONV_TEX, API_RUNTIME}},
|
|
|
|
// Texture Object Management
|
|
// enum cudaResourceType
|
|
{"cudaResourceTypeArray", {"hipResourceTypeArray", CONV_TEX, API_RUNTIME}}, // 0x00 // API_Driver ANALOGUE (CU_RESOURCE_TYPE_ARRAY = 0x00)
|
|
{"cudaResourceTypeMipmappedArray", {"hipResourceTypeMipmappedArray", CONV_TEX, API_RUNTIME}}, // 0x01 // API_Driver ANALOGUE (CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01)
|
|
{"cudaResourceTypeLinear", {"hipResourceTypeLinear", CONV_TEX, API_RUNTIME}}, // 0x02 // API_Driver ANALOGUE (CU_RESOURCE_TYPE_LINEAR = 0x02)
|
|
{"cudaResourceTypePitch2D", {"hipResourceTypePitch2D", CONV_TEX, API_RUNTIME}}, // 0x03 // API_Driver ANALOGUE (CU_RESOURCE_TYPE_PITCH2D = 0x03)
|
|
|
|
// enum cudaResourceViewFormat
|
|
{"cudaResViewFormatNone", {"hipResViewFormatNone", CONV_TEX, API_RUNTIME}}, // 0x00 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_NONE = 0x00)
|
|
{"cudaResViewFormatUnsignedChar1", {"hipResViewFormatUnsignedChar1", CONV_TEX, API_RUNTIME}}, // 0x01 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_1X8 = 0x01)
|
|
{"cudaResViewFormatUnsignedChar2", {"hipResViewFormatUnsignedChar2", CONV_TEX, API_RUNTIME}}, // 0x02 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_2X8 = 0x02)
|
|
{"cudaResViewFormatUnsignedChar4", {"hipResViewFormatUnsignedChar4", CONV_TEX, API_RUNTIME}}, // 0x03 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_4X8 = 0x03)
|
|
{"cudaResViewFormatSignedChar1", {"hipResViewFormatSignedChar1", CONV_TEX, API_RUNTIME}}, // 0x04 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_1X8 = 0x04)
|
|
{"cudaResViewFormatSignedChar2", {"hipResViewFormatSignedChar2", CONV_TEX, API_RUNTIME}}, // 0x05 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_2X8 = 0x05)
|
|
{"cudaResViewFormatSignedChar4", {"hipResViewFormatSignedChar4", CONV_TEX, API_RUNTIME}}, // 0x06 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_4X8 = 0x06)
|
|
{"cudaResViewFormatUnsignedShort1", {"hipResViewFormatUnsignedShort1", CONV_TEX, API_RUNTIME}}, // 0x07 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_1X16 = 0x07)
|
|
{"cudaResViewFormatUnsignedShort2", {"hipResViewFormatUnsignedShort2", CONV_TEX, API_RUNTIME}}, // 0x08 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_2X16 = 0x08)
|
|
{"cudaResViewFormatUnsignedShort4", {"hipResViewFormatUnsignedShort4", CONV_TEX, API_RUNTIME}}, // 0x09 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_4X16 = 0x09)
|
|
{"cudaResViewFormatSignedShort1", {"hipResViewFormatSignedShort1", CONV_TEX, API_RUNTIME}}, // 0x0a // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_1X16 = 0x0a)
|
|
{"cudaResViewFormatSignedShort2", {"hipResViewFormatSignedShort2", CONV_TEX, API_RUNTIME}}, // 0x0b // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_2X16 = 0x0b)
|
|
{"cudaResViewFormatSignedShort4", {"hipResViewFormatSignedShort4", CONV_TEX, API_RUNTIME}}, // 0x0c // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_4X16 = 0x0c)
|
|
{"cudaResViewFormatUnsignedInt1", {"hipResViewFormatUnsignedInt1", CONV_TEX, API_RUNTIME}}, // 0x0d // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_1X32 = 0x0d)
|
|
{"cudaResViewFormatUnsignedInt2", {"hipResViewFormatUnsignedInt2", CONV_TEX, API_RUNTIME}}, // 0x0e // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_2X32 = 0x0e)
|
|
{"cudaResViewFormatUnsignedInt4", {"hipResViewFormatUnsignedInt4", CONV_TEX, API_RUNTIME}}, // 0x0f // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UINT_4X32 = 0x0f)
|
|
{"cudaResViewFormatSignedInt1", {"hipResViewFormatSignedInt1", CONV_TEX, API_RUNTIME}}, // 0x10 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_1X32 = 0x10)
|
|
{"cudaResViewFormatSignedInt2", {"hipResViewFormatSignedInt2", CONV_TEX, API_RUNTIME}}, // 0x11 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_2X32 = 0x11)
|
|
{"cudaResViewFormatSignedInt4", {"hipResViewFormatSignedInt4", CONV_TEX, API_RUNTIME}}, // 0x12 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SINT_4X32 = 0x12)
|
|
{"cudaResViewFormatHalf1", {"hipResViewFormatHalf1", CONV_TEX, API_RUNTIME}}, // 0x13 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_1X16 = 0x13)
|
|
{"cudaResViewFormatHalf2", {"hipResViewFormatHalf2", CONV_TEX, API_RUNTIME}}, // 0x14 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_2X16 = 0x14)
|
|
{"cudaResViewFormatHalf4", {"hipResViewFormatHalf4", CONV_TEX, API_RUNTIME}}, // 0x15 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_4X16 = 0x15)
|
|
{"cudaResViewFormatFloat1", {"hipResViewFormatFloat1", CONV_TEX, API_RUNTIME}}, // 0x16 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_1X32 = 0x16)
|
|
{"cudaResViewFormatFloat2", {"hipResViewFormatFloat2", CONV_TEX, API_RUNTIME}}, // 0x17 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_2X32 = 0x17)
|
|
{"cudaResViewFormatFloat4", {"hipResViewFormatFloat4", CONV_TEX, API_RUNTIME}}, // 0x18 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_FLOAT_4X32 = 0x18)
|
|
{"cudaResViewFormatUnsignedBlockCompressed1", {"hipResViewFormatUnsignedBlockCompressed1", CONV_TEX, API_RUNTIME}}, // 0x19 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = 0x19)
|
|
{"cudaResViewFormatUnsignedBlockCompressed2", {"hipResViewFormatUnsignedBlockCompressed2", CONV_TEX, API_RUNTIME}}, // 0x1a // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = 0x1a)
|
|
{"cudaResViewFormatUnsignedBlockCompressed3", {"hipResViewFormatUnsignedBlockCompressed3", CONV_TEX, API_RUNTIME}}, // 0x1b // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = 0x1b)
|
|
{"cudaResViewFormatUnsignedBlockCompressed4", {"hipResViewFormatUnsignedBlockCompressed4", CONV_TEX, API_RUNTIME}}, // 0x1c // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = 0x1c)
|
|
{"cudaResViewFormatSignedBlockCompressed4", {"hipResViewFormatSignedBlockCompressed4", CONV_TEX, API_RUNTIME}}, // 0x1d // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SIGNED_BC4 = 0x1d)
|
|
{"cudaResViewFormatUnsignedBlockCompressed5", {"hipResViewFormatUnsignedBlockCompressed5", CONV_TEX, API_RUNTIME}}, // 0x1e // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = 0x1e)
|
|
{"cudaResViewFormatSignedBlockCompressed5", {"hipResViewFormatSignedBlockCompressed5", CONV_TEX, API_RUNTIME}}, // 0x1f // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SIGNED_BC5 = 0x1f)
|
|
{"cudaResViewFormatUnsignedBlockCompressed6H", {"hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX, API_RUNTIME}}, // 0x20 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = 0x20)
|
|
{"cudaResViewFormatSignedBlockCompressed6H", {"hipResViewFormatSignedBlockCompressed6H", CONV_TEX, API_RUNTIME}}, // 0x21 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_SIGNED_BC6H = 0x21)
|
|
{"cudaResViewFormatUnsignedBlockCompressed7", {"hipResViewFormatUnsignedBlockCompressed7", CONV_TEX, API_RUNTIME}}, // 0x22 // API_Driver ANALOGUE (CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = 0x22)
|
|
|
|
{"cudaAddressModeWrap", {"hipAddressModeWrap", CONV_TEX, API_RUNTIME}},
|
|
{"cudaAddressModeClamp", {"hipAddressModeClamp", CONV_TEX, API_RUNTIME}},
|
|
{"cudaAddressModeMirror", {"hipAddressModeMirror", CONV_TEX, API_RUNTIME}},
|
|
{"cudaAddressModeBorder", {"hipAddressModeBorder", CONV_TEX, API_RUNTIME}},
|
|
|
|
// functions
|
|
{"cudaCreateTextureObject", {"hipCreateTextureObject", CONV_TEX, API_RUNTIME}},
|
|
{"cudaDestroyTextureObject", {"hipDestroyTextureObject", CONV_TEX, API_RUNTIME}},
|
|
{"cudaGetTextureObjectResourceDesc", {"hipGetTextureObjectResourceDesc", CONV_TEX, API_RUNTIME}},
|
|
{"cudaGetTextureObjectResourceViewDesc", {"hipGetTextureObjectResourceViewDesc", CONV_TEX, API_RUNTIME}},
|
|
{"cudaGetTextureObjectTextureDesc", {"hipGetTextureObjectTextureDesc", CONV_TEX, API_RUNTIME}},
|
|
|
|
// Surface Reference Management
|
|
{"cudaBindSurfaceToArray", {"hipBindSurfaceToArray", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGetSurfaceReference", {"hipGetSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// enum cudaSurfaceBoundaryMode
|
|
{"cudaBoundaryModeZero", {"hipBoundaryModeZero", CONV_SURFACE, API_RUNTIME}},
|
|
{"cudaBoundaryModeClamp", {"hipBoundaryModeClamp", CONV_SURFACE, API_RUNTIME}},
|
|
{"cudaBoundaryModeTrap", {"hipBoundaryModeTrap", CONV_SURFACE, API_RUNTIME}},
|
|
|
|
// enum cudaSurfaceFormatMode
|
|
{"cudaFormatModeForced", {"hipFormatModeForced", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaFormatModeAuto", {"hipFormatModeAuto", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Surface Object Management
|
|
{"cudaCreateSurfaceObject", {"hipCreateSurfaceObject", CONV_SURFACE, API_RUNTIME}},
|
|
{"cudaDestroySurfaceObject", {"hipDestroySurfaceObject", CONV_SURFACE, API_RUNTIME}},
|
|
{"cudaGetSurfaceObjectResourceDesc", {"hipGetSurfaceObjectResourceDesc", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Inter-Process Communications (IPC)
|
|
{"cudaIpcCloseMemHandle", {"hipIpcCloseMemHandle", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaIpcGetEventHandle", {"hipIpcGetEventHandle", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaIpcGetMemHandle", {"hipIpcGetMemHandle", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaIpcOpenEventHandle", {"hipIpcOpenEventHandle", CONV_DEVICE, API_RUNTIME}},
|
|
{"cudaIpcOpenMemHandle", {"hipIpcOpenMemHandle", CONV_DEVICE, API_RUNTIME}},
|
|
|
|
// OpenGL Interoperability
|
|
{"cudaGLGetDevices", {"hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsGLRegisterBuffer", {"hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsGLRegisterImage", {"hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaWGLGetDevice", {"hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// Graphics Interoperability
|
|
{"cudaGraphicsMapResources", {"hipGraphicsMapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsMapResources)
|
|
{"cudaGraphicsResourceGetMappedMipmappedArray", {"hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsResourceGetMappedMipmappedArray)
|
|
{"cudaGraphicsResourceGetMappedPointer", {"hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsResourceGetMappedPointer)
|
|
{"cudaGraphicsResourceSetMapFlags", {"hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsResourceSetMapFlags)
|
|
{"cudaGraphicsSubResourceGetMappedArray", {"hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsSubResourceGetMappedArray)
|
|
{"cudaGraphicsUnmapResources", {"hipGraphicsUnmapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsUnmapResources)
|
|
{"cudaGraphicsUnregisterResource", {"hipGraphicsUnregisterResource", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsUnregisterResource)
|
|
|
|
// enum cudaGraphicsCubeFace
|
|
{"cudaGraphicsCubeFacePositiveX", {"hipGraphicsCubeFacePositiveX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsCubeFaceNegativeX", {"hipGraphicsCubeFaceNegativeX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsCubeFacePositiveY", {"hipGraphicsCubeFacePositiveY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsCubeFaceNegativeY", {"hipGraphicsCubeFaceNegativeY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsCubeFacePositiveZ", {"hipGraphicsCubeFacePositiveZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaGraphicsCubeFaceNegativeZ", {"hipGraphicsCubeFaceNegativeZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// enum cudaGraphicsMapFlags
|
|
{"cudaGraphicsMapFlagsNone", {"hipGraphicsMapFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0x00)
|
|
{"cudaGraphicsMapFlagsReadOnly", {"hipGraphicsMapFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01)
|
|
{"cudaGraphicsMapFlagsWriteDiscard", {"hipGraphicsMapFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02)
|
|
|
|
// enum cudaGraphicsRegisterFlags
|
|
{"cudaGraphicsRegisterFlagsNone", {"hipGraphicsRegisterFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0x00)
|
|
{"cudaGraphicsRegisterFlagsReadOnly", {"hipGraphicsRegisterFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01)
|
|
{"cudaGraphicsRegisterFlagsWriteDiscard", {"hipGraphicsRegisterFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 0x02)
|
|
{"cudaGraphicsRegisterFlagsSurfaceLoadStore", {"hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 4 // API_Driver ANALOGUE (CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 0x04)
|
|
{"cudaGraphicsRegisterFlagsTextureGather", {"hipGraphicsRegisterFlagsTextureGather", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED}}, // 8 // API_Driver ANALOGUE (CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 0x08)
|
|
|
|
// OpenGL Interoperability
|
|
// enum cudaGLDeviceList
|
|
{"cudaGLDeviceListAll", {"HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_Driver ANALOGUE (CU_GL_DEVICE_LIST_ALL)
|
|
{"cudaGLDeviceListCurrentFrame", {"HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x02 // API_Driver ANALOGUE (CU_GL_DEVICE_LIST_CURRENT_FRAME)
|
|
{"cudaGLDeviceListNextFrame", {"HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x03 // API_Driver ANALOGUE (CU_GL_DEVICE_LIST_NEXT_FRAME)
|
|
|
|
{"cudaGLGetDevices", {"hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLGetDevices)
|
|
{"cudaGraphicsGLRegisterBuffer", {"hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsGLRegisterBuffer)
|
|
{"cudaGraphicsGLRegisterImage", {"hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsGLRegisterImage)
|
|
{"cudaWGLGetDevice", {"hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuWGLGetDevice)
|
|
|
|
// OpenGL Interoperability [DEPRECATED]
|
|
// enum cudaGLMapFlags
|
|
{"cudaGLMapFlagsNone", {"HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x00 // API_Driver ANALOGUE (CU_GL_MAP_RESOURCE_FLAGS_NONE)
|
|
{"cudaGLMapFlagsReadOnly", {"HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x01 // API_Driver ANALOGUE (CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY)
|
|
{"cudaGLMapFlagsWriteDiscard", {"HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // 0x02 // API_Driver ANALOGUE (CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD)
|
|
|
|
{"cudaGLMapBufferObject", {"hipGLMapBufferObject__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // Not equal to cuGLMapBufferObject due to different signatures
|
|
{"cudaGLMapBufferObjectAsync", {"hipGLMapBufferObjectAsync__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // Not equal to cuGLMapBufferObjectAsync due to different signatures
|
|
{"cudaGLRegisterBufferObject", {"hipGLRegisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLRegisterBufferObject)
|
|
{"cudaGLSetBufferObjectMapFlags", {"hipGLSetBufferObjectMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLSetBufferObjectMapFlags)
|
|
{"cudaGLSetGLDevice", {"hipGLSetGLDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // no API_Driver ANALOGUE
|
|
{"cudaGLUnmapBufferObject", {"hipGLUnmapBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLUnmapBufferObject)
|
|
{"cudaGLUnmapBufferObjectAsync", {"hipGLUnmapBufferObjectAsync", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLUnmapBufferObjectAsync)
|
|
{"cudaGLUnregisterBufferObject", {"hipGLUnregisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGLUnregisterBufferObject)
|
|
|
|
// Direct3D 9 Interoperability
|
|
// enum CUd3d9DeviceList
|
|
{"cudaD3D9DeviceListAll", {"HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D9_DEVICE_LIST_ALL)
|
|
{"cudaD3D9DeviceListCurrentFrame", {"HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_D3D9_DEVICE_LIST_CURRENT_FRAME)
|
|
{"cudaD3D9DeviceListNextFrame", {"HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_Driver ANALOGUE (CU_D3D9_DEVICE_LIST_NEXT_FRAME)
|
|
|
|
// cudaD3D9MapFlags enum values
|
|
{"cudaD3D9MapFlags", {"hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (CUd3d9map_flags)
|
|
{"cudaD3D9MapFlagsNone", {"HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_D3D9_MAPRESOURCE_FLAGS_NONE)
|
|
{"cudaD3D9MapFlagsReadOnly", {"HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D9_MAPRESOURCE_FLAGS_READONLY)
|
|
{"cudaD3D9MapFlagsWriteDiscard", {"HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD)
|
|
|
|
{"cudaD3D9GetDevice", {"hipD3D9GetDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9GetDevice)
|
|
{"cudaD3D9GetDevices", {"hipD3D9GetDevices", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9GetDevices)
|
|
{"cudaD3D9GetDirect3DDevice", {"hipD3D9GetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9GetDirect3DDevice)
|
|
{"cudaD3D9SetDirect3DDevice", {"hipD3D9SetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // no API_Driver ANALOGUE
|
|
{"cudaGraphicsD3D9RegisterResource", {"hipGraphicsD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsD3D9RegisterResource)
|
|
|
|
// enum cudaD3D9RegisterFlags
|
|
{"cudaD3D9RegisterFlagsNone", {"HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_D3D9_REGISTER_FLAGS_NONE)
|
|
{"cudaD3D9RegisterFlagsArray", {"HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D9_REGISTER_FLAGS_ARRAY)
|
|
|
|
{"cudaD3D9MapResources", {"hipD3D9MapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9MapResources)
|
|
{"cudaD3D9RegisterResource", {"hipD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9RegisterResource)
|
|
{"cudaD3D9ResourceGetMappedArray", {"hipD3D9ResourceGetMappedArray", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9ResourceGetMappedArray)
|
|
{"cudaD3D9ResourceGetMappedPitch", {"hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cudaD3D9ResourceGetMappedPitch)
|
|
{"cudaD3D9ResourceGetMappedPointer", {"hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9ResourceGetMappedPointer)
|
|
{"cudaD3D9ResourceGetMappedSize", {"hipD3D9ResourceGetMappedSize", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9ResourceGetMappedSize)
|
|
{"cudaD3D9ResourceGetSurfaceDimensions", {"hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9ResourceGetSurfaceDimensions)
|
|
{"cudaD3D9ResourceSetMapFlags", {"hipD3D9ResourceSetMapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9ResourceSetMapFlags)
|
|
{"cudaD3D9UnmapResources", {"hipD3D9UnmapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9UnmapResources)
|
|
{"cudaD3D9UnregisterResource", {"hipD3D9UnregisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D9UnregisterResource)
|
|
|
|
// Direct3D 10 Interoperability
|
|
// enum cudaD3D10DeviceList
|
|
{"cudaD3D10DeviceListAll", {"HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D10_DEVICE_LIST_ALL)
|
|
{"cudaD3D10DeviceListCurrentFrame", {"HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_D3D10_DEVICE_LIST_CURRENT_FRAME)
|
|
{"cudaD3D10DeviceListNextFrame", {"HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_Driver ANALOGUE (CU_D3D10_DEVICE_LIST_NEXT_FRAME)
|
|
{"cudaD3D10GetDevice", {"hipD3D10GetDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10GetDevice)
|
|
{"cudaD3D10GetDevices", {"hipD3D10GetDevices", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10GetDevices)
|
|
{"cudaGraphicsD3D10RegisterResource", {"hipGraphicsD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsD3D10RegisterResource)
|
|
|
|
// Direct3D 10 Interoperability [DEPRECATED]
|
|
// enum cudaD3D10MapFlags
|
|
{"cudaD3D10MapFlagsNone", {"HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_D3D10_MAPRESOURCE_FLAGS_NONE)
|
|
{"cudaD3D10MapFlagsReadOnly", {"HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D10_MAPRESOURCE_FLAGS_READONLY)
|
|
{"cudaD3D10MapFlagsWriteDiscard", {"HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD)
|
|
|
|
// enum cudaD3D10RegisterFlags
|
|
{"cudaD3D10RegisterFlagsNone", {"HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 0 // API_Driver ANALOGUE (CU_D3D10_REGISTER_FLAGS_NONE)
|
|
{"cudaD3D10RegisterFlagsArray", {"HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D10_REGISTER_FLAGS_ARRAY)
|
|
|
|
{"cudaD3D10GetDirect3DDevice", {"hipD3D10GetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cudaD3D10GetDirect3DDevice)
|
|
{"cudaD3D10MapResources", {"hipD3D10MapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10MapResources)
|
|
{"cudaD3D10RegisterResource", {"hipD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10RegisterResource)
|
|
{"cudaD3D10ResourceGetMappedArray", {"hipD3D10ResourceGetMappedArray", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10ResourceGetMappedArray)
|
|
{"cudaD3D10ResourceGetMappedPitch", {"hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cudaD3D10ResourceGetMappedPitch)
|
|
{"cudaD3D10ResourceGetMappedPointer", {"hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10ResourceGetMappedPointer)
|
|
{"cudaD3D10ResourceGetMappedSize", {"hipD3D10ResourceGetMappedSize", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10ResourceGetMappedSize)
|
|
{"cudaD3D10ResourceGetSurfaceDimensions", {"hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10ResourceGetSurfaceDimensions)
|
|
{"cudaD3D10ResourceSetMapFlags", {"hipD3D10ResourceSetMapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10ResourceSetMapFlags)
|
|
{"cudaD3D10SetDirect3DDevice", {"hipD3D10SetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // no API_Driver ANALOGUE
|
|
{"cudaD3D10UnmapResources", {"hipD3D10UnmapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10UnmapResources)
|
|
{"cudaD3D10UnregisterResource", {"hipD3D10UnregisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D10UnregisterResource)
|
|
|
|
// Direct3D 11 Interoperability
|
|
// enum cudaD3D11DeviceList
|
|
{"cudaD3D11DeviceListAll", {"HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // 1 // API_Driver ANALOGUE (CU_D3D11_DEVICE_LIST_ALL)
|
|
{"cudaD3D11DeviceListCurrentFrame", {"HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // 2 // API_Driver ANALOGUE (CU_D3D11_DEVICE_LIST_CURRENT_FRAME)
|
|
{"cudaD3D11DeviceListNextFrame", {"HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // 3 // API_Driver ANALOGUE (CU_D3D11_DEVICE_LIST_NEXT_FRAME)
|
|
|
|
{"cudaD3D11GetDevice", {"hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D11GetDevice)
|
|
{"cudaD3D11GetDevices", {"hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D11GetDevices)
|
|
{"cudaGraphicsD3D11RegisterResource", {"hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsD3D11RegisterResource)
|
|
|
|
// Direct3D 11 Interoperability [DEPRECATED]
|
|
{"cudaD3D11GetDevice", {"hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D11GetDevice)
|
|
{"cudaD3D11GetDevices", {"hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuD3D11GetDevices)
|
|
{"cudaGraphicsD3D11RegisterResource", {"hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsD3D11RegisterResource)
|
|
|
|
// VDPAU Interoperability
|
|
{"cudaGraphicsVDPAURegisterOutputSurface", {"hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsVDPAURegisterOutputSurface)
|
|
{"cudaGraphicsVDPAURegisterVideoSurface", {"hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsVDPAURegisterVideoSurface)
|
|
{"cudaVDPAUGetDevice", {"hipVDPAUGetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuVDPAUGetDevice)
|
|
{"cudaVDPAUSetVDPAUDevice", {"hipVDPAUSetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED}}, // no API_Driver ANALOGUE
|
|
|
|
// EGL Interoperability
|
|
{"cudaEGLStreamConsumerAcquireFrame", {"hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamConsumerAcquireFrame)
|
|
{"cudaEGLStreamConsumerConnect", {"hipEGLStreamConsumerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamConsumerConnect)
|
|
{"cudaEGLStreamConsumerConnectWithFlags", {"hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamConsumerConnectWithFlags)
|
|
{"cudaEGLStreamConsumerReleaseFrame", {"hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamConsumerReleaseFrame)
|
|
{"cudaEGLStreamProducerConnect", {"hipEGLStreamProducerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamProducerConnect)
|
|
{"cudaEGLStreamProducerDisconnect", {"hipEGLStreamProducerDisconnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamProducerDisconnect)
|
|
{"cudaEGLStreamProducerPresentFrame", {"hipEGLStreamProducerPresentFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamProducerPresentFrame)
|
|
{"cudaEGLStreamProducerReturnFrame", {"hipEGLStreamProducerReturnFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuEGLStreamProducerReturnFrame)
|
|
{"cudaGraphicsEGLRegisterImage", {"hipGraphicsEGLRegisterImage", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsEGLRegisterImage)
|
|
{"cudaGraphicsResourceGetMappedEglFrame", {"hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED}}, // API_Driver ANALOGUE (cuGraphicsResourceGetMappedEglFrame)
|
|
|
|
///////////////////////////// cuBLAS /////////////////////////////
|
|
// Blas Data Types
|
|
|
|
// Blas operations
|
|
{"cublasOperation_t", {"hipblasOperation_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_OP_N", {"HIPBLAS_OP_N", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_OP_T", {"HIPBLAS_OP_T", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_OP_C", {"HIPBLAS_OP_C", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas statuses
|
|
{"cublasStatus", {"hipblasStatus_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasStatus_t", {"hipblasStatus_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_STATUS_SUCCESS", {"HIPBLAS_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_NOT_INITIALIZED", {"HIPBLAS_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_ALLOC_FAILED", {"HIPBLAS_STATUS_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_INVALID_VALUE", {"HIPBLAS_STATUS_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_MAPPING_ERROR", {"HIPBLAS_STATUS_MAPPING_ERROR", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_EXECUTION_FAILED", {"HIPBLAS_STATUS_EXECUTION_FAILED", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_INTERNAL_ERROR", {"HIPBLAS_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_NOT_SUPPORTED", {"HIPBLAS_STATUS_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_ARCH_MISMATCH", {"HIPBLAS_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_STATUS_LICENSE_ERROR", {"HIPBLAS_STATUS_LICENSE_ERROR", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas Fill Modes
|
|
{"cublasFillMode_t", {"hipblasFillMode_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_FILL_MODE_LOWER", {"HIPBLAS_FILL_MODE_LOWER", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_FILL_MODE_UPPER", {"HIPBLAS_FILL_MODE_UPPER", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas Diag Types
|
|
{"cublasDiagType_t", {"hipblasDiagType_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_DIAG_NON_UNIT", {"HIPBLAS_DIAG_NON_UNIT", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_DIAG_UNIT", {"HIPBLAS_DIAG_UNIT", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas Side Modes
|
|
{"cublasSideMode_t", {"hipblasSideMode_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_SIDE_LEFT", {"HIPBLAS_SIDE_LEFT", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_SIDE_RIGHT", {"HIPBLAS_SIDE_RIGHT", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas Pointer Modes
|
|
{"cublasPointerMode_t", {"hipblasPointerMode_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_POINTER_MODE_HOST", {"HIPBLAS_POINTER_MODE_HOST", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
{"CUBLAS_POINTER_MODE_DEVICE", {"HIPBLAS_POINTER_MODE_DEVICE", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas Atomics Modes
|
|
{"cublasAtomicsMode_t", {"hipblasAtomicsMode_t", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_ATOMICS_NOT_ALLOWED", {"HIPBLAS_ATOMICS_NOT_ALLOWED", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_ATOMICS_ALLOWED", {"HIPBLAS_ATOMICS_ALLOWED", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas Data Type
|
|
{"cublasDataType_t", {"hipblasDatatype_t", CONV_TYPE, API_BLAS}},
|
|
|
|
// Blas Math mode/tensor operation
|
|
{"cublasMath_t", {"hipblasMath_t", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_DEFAULT_MATH", {"HIPBLAS_DEFAULT_MATH", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_TENSOR_OP_MATH", {"HIPBLAS_TENSOR_OP_MATH", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blass different GEMM algorithms
|
|
{"cublasGemmAlgo_t", {"hipblasGemmAlgo_t", CONV_TYPE, API_BLAS}},
|
|
{"CUBLAS_GEMM_DFALT", {"HIPBLAS_GEMM_DEFAULT", CONV_NUMERIC_LITERAL, API_BLAS}}, // -1 // 160
|
|
{"CUBLAS_GEMM_DEFAULT", {"HIPBLAS_GEMM_DEFAULT", CONV_NUMERIC_LITERAL, API_BLAS}}, // -1 // 160
|
|
{"CUBLAS_GEMM_ALGO0", {"HIPBLAS_GEMM_ALGO0", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 0
|
|
{"CUBLAS_GEMM_ALGO1", {"HIPBLAS_GEMM_ALGO1", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 1
|
|
{"CUBLAS_GEMM_ALGO2", {"HIPBLAS_GEMM_ALGO2", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 2
|
|
{"CUBLAS_GEMM_ALGO3", {"HIPBLAS_GEMM_ALGO3", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 3
|
|
{"CUBLAS_GEMM_ALGO4", {"HIPBLAS_GEMM_ALGO4", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 4
|
|
{"CUBLAS_GEMM_ALGO5", {"HIPBLAS_GEMM_ALGO5", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 5
|
|
{"CUBLAS_GEMM_ALGO6", {"HIPBLAS_GEMM_ALGO6", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 6
|
|
{"CUBLAS_GEMM_ALGO7", {"HIPBLAS_GEMM_ALGO7", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 7
|
|
{"CUBLAS_GEMM_ALGO8", {"HIPBLAS_GEMM_ALGO8", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 8
|
|
{"CUBLAS_GEMM_ALGO9", {"HIPBLAS_GEMM_ALGO9", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 9
|
|
{"CUBLAS_GEMM_ALGO10", {"HIPBLAS_GEMM_ALGO10", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 10
|
|
{"CUBLAS_GEMM_ALGO11", {"HIPBLAS_GEMM_ALGO11", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 11
|
|
{"CUBLAS_GEMM_ALGO12", {"HIPBLAS_GEMM_ALGO12", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 12
|
|
{"CUBLAS_GEMM_ALGO13", {"HIPBLAS_GEMM_ALGO13", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 13
|
|
{"CUBLAS_GEMM_ALGO14", {"HIPBLAS_GEMM_ALGO14", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 14
|
|
{"CUBLAS_GEMM_ALGO15", {"HIPBLAS_GEMM_ALGO15", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 15
|
|
{"CUBLAS_GEMM_ALGO16", {"HIPBLAS_GEMM_ALGO16", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 16
|
|
{"CUBLAS_GEMM_ALGO17", {"HIPBLAS_GEMM_ALGO17", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 17
|
|
{"CUBLAS_GEMM_ALGO18", {"HIPBLAS_GEMM_ALGO18", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 18
|
|
{"CUBLAS_GEMM_ALGO19", {"HIPBLAS_GEMM_ALGO19", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 19
|
|
{"CUBLAS_GEMM_ALGO20", {"HIPBLAS_GEMM_ALGO20", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 20
|
|
{"CUBLAS_GEMM_ALGO21", {"HIPBLAS_GEMM_ALGO21", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 21
|
|
{"CUBLAS_GEMM_ALGO22", {"HIPBLAS_GEMM_ALGO22", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 22
|
|
{"CUBLAS_GEMM_ALGO23", {"HIPBLAS_GEMM_ALGO23", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 23
|
|
{"CUBLAS_GEMM_DEFAULT_TENSOR_OP", {"HIPBLAS_GEMM_DEFAULT_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 99
|
|
{"CUBLAS_GEMM_DFALT_TENSOR_OP", {"HIPBLAS_GEMM_DFALT_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 99
|
|
{"CUBLAS_GEMM_ALGO0_TENSOR_OP", {"HIPBLAS_GEMM_ALGO0_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 100
|
|
{"CUBLAS_GEMM_ALGO1_TENSOR_OP", {"HIPBLAS_GEMM_ALGO1_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 101
|
|
{"CUBLAS_GEMM_ALGO2_TENSOR_OP", {"HIPBLAS_GEMM_ALGO2_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 102
|
|
{"CUBLAS_GEMM_ALGO3_TENSOR_OP", {"HIPBLAS_GEMM_ALGO3_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 103
|
|
{"CUBLAS_GEMM_ALGO4_TENSOR_OP", {"HIPBLAS_GEMM_ALGO4_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 104
|
|
{"CUBLAS_GEMM_ALGO5_TENSOR_OP", {"HIPBLAS_GEMM_ALGO5_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 105
|
|
{"CUBLAS_GEMM_ALGO6_TENSOR_OP", {"HIPBLAS_GEMM_ALGO6_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 106
|
|
{"CUBLAS_GEMM_ALGO7_TENSOR_OP", {"HIPBLAS_GEMM_ALGO7_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 107
|
|
{"CUBLAS_GEMM_ALGO8_TENSOR_OP", {"HIPBLAS_GEMM_ALGO8_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 108
|
|
{"CUBLAS_GEMM_ALGO9_TENSOR_OP", {"HIPBLAS_GEMM_ALGO9_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 109
|
|
{"CUBLAS_GEMM_ALGO10_TENSOR_OP", {"HIPBLAS_GEMM_ALGO10_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 110
|
|
{"CUBLAS_GEMM_ALGO11_TENSOR_OP", {"HIPBLAS_GEMM_ALGO11_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 111
|
|
{"CUBLAS_GEMM_ALGO12_TENSOR_OP", {"HIPBLAS_GEMM_ALGO12_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 112
|
|
{"CUBLAS_GEMM_ALGO13_TENSOR_OP", {"HIPBLAS_GEMM_ALGO13_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 113
|
|
{"CUBLAS_GEMM_ALGO14_TENSOR_OP", {"HIPBLAS_GEMM_ALGO14_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 114
|
|
{"CUBLAS_GEMM_ALGO15_TENSOR_OP", {"HIPBLAS_GEMM_ALGO15_TENSOR_OP", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}}, // 115
|
|
|
|
///////////////////////////// cuBLAS functions /////////////////////////////
|
|
// Blas management functions
|
|
{"cublasInit", {"hipblasInit", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasShutdown", {"hipblasShutdown", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetVersion", {"hipblasGetVersion", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetError", {"hipblasGetError", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasAlloc", {"hipblasAlloc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasFree", {"hipblasFree", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetKernelStream", {"hipblasSetKernelStream", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetAtomicsMode", {"hipblasGetAtomicsMode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetAtomicsMode", {"hipblasSetAtomicsMode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetMathMode", {"hipblasGetMathMode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetMathMode", {"hipblasSetMathMode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas logging
|
|
{"cublasLogCallback", {"hipblasLogCallback", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasLoggerConfigure", {"hipblasLoggerConfigure", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetLoggerCallback", {"hipblasSetLoggerCallback", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetLoggerCallback", {"hipblasGetLoggerCallback", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas1 (v1) Routines
|
|
{"cublasCreate", {"hipblasCreate", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDestroy", {"hipblasDestroy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSetStream", {"hipblasSetStream", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetStream", {"hipblasGetStream", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetPointerMode", {"hipblasGetPointerMode", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSetPointerMode", {"hipblasSetPointerMode", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSetVector", {"hipblasSetVector", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetVector", {"hipblasGetVector", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSetVectorAsync", {"hipblasSetVectorAsync", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetVectorAsync", {"hipblasGetVectorAsync", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetMatrix", {"hipblasSetMatrix", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetMatrix", {"hipblasGetMatrix", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetMatrixAsync", {"hipblasGetMatrixAsync", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetMatrixAsync", {"hipblasSetMatrixAsync", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasXerbla", {"hipblasXerbla", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// NRM2
|
|
{"cublasSnrm2", {"hipblasSnrm2", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDnrm2", {"hipblasDnrm2", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasScnrm2", {"hipblasScnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDznrm2", {"hipblasDznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasNrm2Ex", {"hipblasNrm2Ex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// DOT
|
|
{"cublasSdot", {"hipblasSdot", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasSdotBatched", {"hipblasSdotBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDdot", {"hipblasDdot", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasDdotBatched", {"hipblasDdotBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCdotu", {"hipblasCdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCdotc", {"hipblasCdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdotu", {"hipblasZdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdotc", {"hipblasZdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SCAL
|
|
{"cublasSscal", {"hipblasSscal", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasSscalBatched", {"hipblasSscalBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDscal", {"hipblasDscal", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasDscalBatched", {"hipblasDscalBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCscal", {"hipblasCscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsscal", {"hipblasCsscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZscal", {"hipblasZscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdscal", {"hipblasZdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AXPY
|
|
{"cublasSaxpy", {"hipblasSaxpy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSaxpyBatched", {"hipblasSaxpyBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDaxpy", {"hipblasDaxpy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCaxpy", {"hipblasCaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZaxpy", {"hipblasZaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// COPY
|
|
{"cublasScopy", {"hipblasScopy", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasScopyBatched", {"hipblasScopyBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDcopy", {"hipblasDcopy", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasDcopyBatched", {"hipblasDcopyBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCcopy", {"hipblasCcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZcopy", {"hipblasZcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SWAP
|
|
{"cublasSswap", {"hipblasSswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDswap", {"hipblasDswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCswap", {"hipblasCswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZswap", {"hipblasZswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AMAX
|
|
{"cublasIsamax", {"hipblasIsamax", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasIdamax", {"hipblasIdamax", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasIcamax", {"hipblasIcamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIzamax", {"hipblasIzamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AMIN
|
|
{"cublasIsamin", {"hipblasIsamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIdamin", {"hipblasIdamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIcamin", {"hipblasIcamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIzamin", {"hipblasIzamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ASUM
|
|
{"cublasSasum", {"hipblasSasum", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasSasumBatched", {"hipblasSasumBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDasum", {"hipblasDasum", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasDasumBatched", {"hipblasDasumBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasScasum", {"hipblasScasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDzasum", {"hipblasDzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROT
|
|
{"cublasSrot", {"hipblasSrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrot", {"hipblasDrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCrot", {"hipblasCrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsrot", {"hipblasCsrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZrot", {"hipblasZrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdrot", {"hipblasZdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTG
|
|
{"cublasSrotg", {"hipblasSrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotg", {"hipblasDrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCrotg", {"hipblasCrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZrotg", {"hipblasZrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTM
|
|
{"cublasSrotm", {"hipblasSrotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotm", {"hipblasDrotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTMG
|
|
{"cublasSrotmg", {"hipblasSrotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotmg", {"hipblasDrotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GEMV
|
|
{"cublasSgemv", {"hipblasSgemv", CONV_MATH_FUNC, API_BLAS}},
|
|
// there is no such a function in CUDA
|
|
{"cublasSgemvBatched", {"hipblasSgemvBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgemv", {"hipblasDgemv", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgemv", {"hipblasCgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemv", {"hipblasZgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GBMV
|
|
{"cublasSgbmv", {"hipblasSgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgbmv", {"hipblasDgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgbmv", {"hipblasCgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgbmv", {"hipblasZgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRMV
|
|
{"cublasStrmv", {"hipblasStrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrmv", {"hipblasDtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrmv", {"hipblasCtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrmv", {"hipblasZtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TBMV
|
|
{"cublasStbmv", {"hipblasStbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtbmv", {"hipblasDtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtbmv", {"hipblasCtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtbmv", {"hipblasZtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TPMV
|
|
{"cublasStpmv", {"hipblasStpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtpmv", {"hipblasDtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtpmv", {"hipblasCtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtpmv", {"hipblasZtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSV
|
|
{"cublasStrsv", {"hipblasStrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsv", {"hipblasDtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrsv", {"hipblasCtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsv", {"hipblasZtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TPSV
|
|
{"cublasStpsv", {"hipblasStpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtpsv", {"hipblasDtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtpsv", {"hipblasCtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtpsv", {"hipblasZtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TBSV
|
|
{"cublasStbsv", {"hipblasStbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtbsv", {"hipblasDtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtbsv", {"hipblasCtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtbsv", {"hipblasZtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYMV/HEMV
|
|
{"cublasSsymv", {"hipblasSsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsymv", {"hipblasDsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsymv", {"hipblasCsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsymv", {"hipblasZsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChemv", {"hipblasChemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhemv", {"hipblasZhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SBMV/HBMV
|
|
{"cublasSsbmv", {"hipblasSsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsbmv", {"hpiblasDsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChbmv", {"hipblasChbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhbmv", {"hipblasZhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPMV/HPMV
|
|
{"cublasSspmv", {"hipblasSspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspmv", {"hipblasDspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpmv", {"hipblasChpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpmv", {"hipblasZhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GER
|
|
{"cublasSger", {"hipblasSger", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDger", {"hipblasDger", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgeru", {"hipblasCgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgerc", {"hipblasCgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgeru", {"hipblasZgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgerc", {"hipblasZgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR/HER
|
|
{"cublasSsyr", {"hipblasSsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr", {"hipblasDsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr", {"hipblasCsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr", {"hipblasZsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCher", {"hipblasCher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher", {"hipblasZher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPR/HPR
|
|
{"cublasSspr", {"hipblasSspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspr", {"hipblasDspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpr", {"hipblasChpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpr", {"hipblasZhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR2/HER2
|
|
{"cublasSsyr2", {"hipblasSsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr2", {"hipblasDsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr2", {"hipblasCsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr2", {"hipblasZsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCher2", {"hipblasCher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher2", {"hipblasZher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPR2/HPR2
|
|
{"cublasSspr2", {"hipblasSspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspr2", {"hipblasDspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpr2", {"hipblasChpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpr2", {"hipblasZhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas3 (v1) Routines
|
|
// GEMM
|
|
{"cublasSgemm", {"hipblasSgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDgemm", {"hipblasDgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgemm", {"hipblasCgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasZgemm", {"hipblasZgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasHgemm", {"hipblasHgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
|
|
// BATCH GEMM
|
|
{"cublasSgemmBatched", {"hipblasSgemmBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDgemmBatched", {"hipblasDgemmBatched", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasHgemmBatched", {"hipblasHgemmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSgemmStridedBatched", {"hipblasSgemmStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgemmStridedBatched", {"hipblasDgemmStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgemmBatched", {"hipblasCgemmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgemm3mBatched", {"hipblasCgemm3mBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemmBatched", {"hipblasZgemmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgemmStridedBatched", {"hipblasCgemmStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgemm3mStridedBatched", {"hipblasCgemm3mStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemmStridedBatched", {"hipblasZgemmStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasHgemmStridedBatched", {"hipblasHgemmStridedBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYRK
|
|
{"cublasSsyrk", {"hipblasSsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyrk", {"hipblasDsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyrk", {"hipblasCsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyrk", {"hipblasZsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HERK
|
|
{"cublasCherk", {"hipblasCherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZherk", {"hipblasZherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR2K
|
|
{"cublasSsyr2k", {"hipblasSsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr2k", {"hipblasDsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr2k", {"hipblasCsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr2k", {"hipblasZsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYRKX - eXtended SYRK
|
|
{"cublasSsyrkx", {"hipblasSsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyrkx", {"hipblasDsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyrkx", {"hipblasCsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyrkx", {"hipblasZsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HER2K
|
|
{"cublasCher2k", {"hipblasCher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher2k", {"hipblasZher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HERKX - eXtended HERK
|
|
{"cublasCherkx", {"hipblasCherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZherkx", {"hipblasZherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYMM
|
|
{"cublasSsymm", {"hipblasSsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsymm", {"hipblasDsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsymm", {"hipblasCsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsymm", {"hipblasZsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HEMM
|
|
{"cublasChemm", {"hipblasChemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhemm", {"hipblasZhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSM
|
|
{"cublasStrsm", {"hipblasStrsm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDtrsm", {"hipblasDtrsm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCtrsm", {"hipblasCtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsm", {"hipblasZtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSM - Batched Triangular Solver
|
|
{"cublasStrsmBatched", {"hipblasStrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsmBatched", {"hipblasDtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrsmBatched", {"hipblasCtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsmBatched", {"hipblasZtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRMM
|
|
{"cublasStrmm", {"hipblasStrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrmm", {"hipblasDtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrmm", {"hipblasCtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrmm", {"hipblasZtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ------------------------ CUBLAS BLAS - like extension (cublas_api.h)
|
|
// GEAM
|
|
{"cublasSgeam", {"hipblasSgeam", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDgeam", {"hipblasDgeam", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgeam", {"hipblasCgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgeam", {"hipblasZgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GETRF - Batched LU
|
|
{"cublasSgetrfBatched", {"hipblasSgetrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgetrfBatched", {"hipblasDgetrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgetrfBatched", {"hipblasCgetrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgetrfBatched", {"hipblasZgetrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Batched inversion based on LU factorization from getrf
|
|
{"cublasSgetriBatched", {"hipblasSgetriBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgetriBatched", {"hipblasDgetriBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgetriBatched", {"hipblasCgetriBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgetriBatched", {"hipblasZgetriBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Batched solver based on LU factorization from getrf
|
|
{"cublasSgetrsBatched", {"hipblasSgetrsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgetrsBatched", {"hipblasDgetrsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgetrsBatched", {"hipblasCgetrsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgetrsBatched", {"hipblasZgetrsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSM - Batched Triangular Solver
|
|
{"cublasStrsmBatched", {"hipblasStrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsmBatched", {"hipblasDtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrsmBatched", {"hipblasCtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsmBatched", {"hipblasZtrsmBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// MATINV - Batched
|
|
{"cublasSmatinvBatched", {"hipblasSmatinvBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDmatinvBatched", {"hipblasDmatinvBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCmatinvBatched", {"hipblasCmatinvBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZmatinvBatched", {"hipblasZmatinvBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Batch QR Factorization
|
|
{"cublasSgeqrfBatched", {"hipblasSgeqrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgeqrfBatched", {"hipblasDgeqrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgeqrfBatched", {"hipblasCgeqrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgeqrfBatched", {"hipblasZgeqrfBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Least Square Min only m >= n and Non-transpose supported
|
|
{"cublasSgelsBatched", {"hipblasSgelsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgelsBatched", {"hipblasDgelsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgelsBatched", {"hipblasCgelsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgelsBatched", {"hipblasZgelsBatched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// DGMM
|
|
{"cublasSdgmm", {"hipblasSdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDdgmm", {"hipblasDdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCdgmm", {"hipblasCdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdgmm", {"hipblasZdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TPTTR - Triangular Pack format to Triangular format
|
|
{"cublasStpttr", {"hipblasStpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtpttr", {"hipblasDtpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtpttr", {"hipblasCtpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtpttr", {"hipblasZtpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRTTP - Triangular format to Triangular Pack format
|
|
{"cublasStrttp", {"hipblasStrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrttp", {"hipblasDtrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrttp", {"hipblasCtrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrttp", {"hipblasZtrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas2 (v2) Routines
|
|
{"cublasCreate_v2", {"hipblasCreate", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDestroy_v2", {"hipblasDestroy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetVersion_v2", {"hipblasGetVersion", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGetProperty", {"hipblasGetProperty", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSetStream_v2", {"hipblasSetStream", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetStream_v2", {"hipblasGetStream", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGetPointerMode_v2", {"hipblasGetPointerMode", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasSetPointerMode_v2", {"hipblasSetPointerMode", CONV_MATH_FUNC, API_BLAS}},
|
|
|
|
// GEMV
|
|
{"cublasSgemv_v2", {"hipblasSgemv", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDgemv_v2", {"hipblasDgemv", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgemv_v2", {"hipblasCgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemv_v2", {"hipblasZgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GBMV
|
|
{"cublasSgbmv_v2", {"hipblasSgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDgbmv_v2", {"hipblasDgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgbmv_v2", {"hipblasCgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgbmv_v2", {"hipblasZgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRMV
|
|
{"cublasStrmv_v2", {"hipblasStrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrmv_v2", {"hipblasDtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrmv_v2", {"hipblasCtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrmv_v2", {"hipblasZtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TBMV
|
|
{"cublasStbmv_v2", {"hipblasStbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtbmv_v2", {"hipblasDtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtbmv_v2", {"hipblasCtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtbmv_v2", {"hipblasZtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TPMV
|
|
{"cublasStpmv_v2", {"hipblasStpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtpmv_v2", {"hipblasDtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtpmv_v2", {"hipblasCtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtpmv_v2", {"hipblasZtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSV
|
|
{"cublasStrsv_v2", {"hipblasStrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsv_v2", {"hipblasDtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrsv_v2", {"hipblasCtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsv_v2", {"hipblasZtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TPSV
|
|
{"cublasStpsv_v2", {"hipblasStpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtpsv_v2", {"hipblasDtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtpsv_v2", {"hipblasCtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtpsv_v2", {"hipblasZtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TBSV
|
|
{"cublasStbsv_v2", {"hipblasStbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtbsv_v2", {"hipblasDtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtbsv_v2", {"hipblasCtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtbsv_v2", {"hipblasZtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYMV/HEMV
|
|
{"cublasSsymv_v2", {"hipblasSsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsymv_v2", {"hipblasDsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsymv_v2", {"hipblasCsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsymv_v2", {"hipblasZsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChemv_v2", {"hipblasChemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhemv_v2", {"hipblasZhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SBMV/HBMV
|
|
{"cublasSsbmv_v2", {"hipblasSsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsbmv_v2", {"hpiblasDsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChbmv_v2", {"hipblasChbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhbmv_v2", {"hipblasZhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPMV/HPMV
|
|
{"cublasSspmv_v2", {"hipblasSspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspmv_v2", {"hipblasDspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpmv_v2", {"hipblasChpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpmv_v2", {"hipblasZhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// GER
|
|
{"cublasSger_v2", {"hipblasSger", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDger_v2", {"hipblasDger", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgeru_v2", {"hipblasCgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgerc_v2", {"hipblasCgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgeru_v2", {"hipblasZgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgerc_v2", {"hipblasZgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR/HER
|
|
{"cublasSsyr_v2", {"hipblasSsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr_v2", {"hipblasDsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr_v2", {"hipblasCsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr_v2", {"hipblasZsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCher_v2", {"hipblasCher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher_v2", {"hipblasZher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPR/HPR
|
|
{"cublasSspr_v2", {"hipblasSspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspr_v2", {"hipblasDspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpr_v2", {"hipblasChpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpr_v2", {"hipblasZhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR2/HER2
|
|
{"cublasSsyr2_v2", {"hipblasSsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr2_v2", {"hipblasDsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr2_v2", {"hipblasCsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr2_v2", {"hipblasZsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCher2_v2", {"hipblasCher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher2_v2", {"hipblasZher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SPR2/HPR2
|
|
{"cublasSspr2_v2", {"hipblasSspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDspr2_v2", {"hipblasDspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasChpr2_v2", {"hipblasChpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhpr2_v2", {"hipblasZhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas3 (v2) Routines
|
|
// GEMM
|
|
{"cublasSgemm_v2", {"hipblasSgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDgemm_v2", {"hipblasDgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgemm_v2", {"hipblasCgemm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCgemm3m", {"hipblasCgemm3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCgemm3mEx", {"hipblasCgemm3mEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemm_v2", {"hipblasZgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZgemm3m", {"hipblasZgemm3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
//IO in FP16 / FP32, computation in float
|
|
{"cublasSgemmEx", {"hipblasSgemmEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGemmEx", {"hipblasGemmEx", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasGemmBatchedEx", {"hipblasGemmBatchedEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasGemmStridedBatchedEx", {"hipblasGemmStridedBatchedEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
// IO in Int8 complex/cuComplex, computation in cuComplex
|
|
{"cublasCgemmEx", {"hipblasCgemmEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasUint8gemmBias", {"hipblasUint8gemmBias", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYRK
|
|
{"cublasSsyrk_v2", {"hipblasSsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyrk_v2", {"hipblasDsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyrk_v2", {"hipblasCsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyrk_v2", {"hipblasZsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// IO in Int8 complex/cuComplex, computation in cuComplex
|
|
{"cublasCsyrkEx", {"hipblasCsyrkEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
// IO in Int8 complex/cuComplex, computation in cuComplex, Gaussian math
|
|
{"cublasCsyrk3mEx", {"hipblasCsyrk3mEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HERK
|
|
{"cublasCherk_v2", {"hipblasCherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
// IO in Int8 complex/cuComplex, computation in cuComplex
|
|
{"cublasCherkEx", {"hipblasCherkEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
// IO in Int8 complex/cuComplex, computation in cuComplex, Gaussian math
|
|
{"cublasCherk3mEx", {"hipblasCherk3mEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZherk_v2", {"hipblasZherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYR2K
|
|
{"cublasSsyr2k_v2", {"hipblasSsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsyr2k_v2", {"hipblasDsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsyr2k_v2", {"hipblasCsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsyr2k_v2", {"hipblasZsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HER2K
|
|
{"cublasCher2k_v2", {"hipblasCher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZher2k_v2", {"hipblasZher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SYMM
|
|
{"cublasSsymm_v2", {"hipblasSsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDsymm_v2", {"hipblasDsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsymm_v2", {"hipblasCsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZsymm_v2", {"hipblasZsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// HEMM
|
|
{"cublasChemm_v2", {"hipblasChemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZhemm_v2", {"hipblasZhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRSM
|
|
{"cublasStrsm_v2", {"hipblasStrsm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDtrsm_v2", {"hipblasDtrsm", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCtrsm_v2", {"hipblasCtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrsm_v2", {"hipblasZtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// TRMM
|
|
{"cublasStrmm_v2", {"hipblasStrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDtrmm_v2", {"hipblasDtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCtrmm_v2", {"hipblasCtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZtrmm_v2", {"hipblasZtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// NRM2
|
|
{"cublasSnrm2_v2", {"hipblasSnrm2", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDnrm2_v2", {"hipblasDnrm2", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasScnrm2_v2", {"hipblasScnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDznrm2_v2", {"hipblasDznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// DOT
|
|
{"cublasDotEx", {"hipblasDotEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDotcEx", {"hipblasDotcEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
{"cublasSdot_v2", {"hipblasSdot", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDdot_v2", {"hipblasDdot", CONV_MATH_FUNC, API_BLAS}},
|
|
|
|
{"cublasCdotu_v2", {"hipblasCdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCdotc_v2", {"hipblasCdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdotu_v2", {"hipblasZdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdotc_v2", {"hipblasZdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SCAL
|
|
{"cublasScalEx", {"hipblasScalEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSscal_v2", {"hipblasSscal", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDscal_v2", {"hipblasDscal", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCscal_v2", {"hipblasCscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsscal_v2", {"hipblasCsscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZscal_v2", {"hipblasZscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdscal_v2", {"hipblasZdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AXPY
|
|
{"cublasAxpyEx", {"hipblasAxpyEx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasSaxpy_v2", {"hipblasSaxpy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDaxpy_v2", {"hipblasDaxpy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCaxpy_v2", {"hipblasCaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZaxpy_v2", {"hipblasZaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// COPY
|
|
{"cublasScopy_v2", {"hipblasScopy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDcopy_v2", {"hipblasDcopy", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasCcopy_v2", {"hipblasCcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZcopy_v2", {"hipblasZcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// SWAP
|
|
{"cublasSswap_v2", {"hipblasSswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDswap_v2", {"hipblasDswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCswap_v2", {"hipblasCswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZswap_v2", {"hipblasZswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AMAX
|
|
{"cublasIsamax_v2", {"hipblasIsamax", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasIdamax_v2", {"hipblasIdamax", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasIcamax_v2", {"hipblasIcamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIzamax_v2", {"hipblasIzamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// AMIN
|
|
{"cublasIsamin_v2", {"hipblasIsamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIdamin_v2", {"hipblasIdamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIcamin_v2", {"hipblasIcamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasIzamin_v2", {"hipblasIzamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ASUM
|
|
{"cublasSasum_v2", {"hipblasSasum", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDasum_v2", {"hipblasDasum", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasScasum_v2", {"hipblasScasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDzasum_v2", {"hipblasDzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROT
|
|
{"cublasSrot_v2", {"hipblasSrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrot_v2", {"hipblasDrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCrot_v2", {"hipblasCrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCsrot_v2", {"hipblasCsrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZrot_v2", {"hipblasZrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZdrot_v2", {"hipblasZdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTG
|
|
{"cublasSrotg_v2", {"hipblasSrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotg_v2", {"hipblasDrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasCrotg_v2", {"hipblasCrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasZrotg_v2", {"hipblasZrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTM
|
|
{"cublasSrotm_v2", {"hipblasSrotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotm_v2", {"hipblasDrotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// ROTMG
|
|
{"cublasSrotmg_v2", {"hipblasSrotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDrotmg_v2", {"hipblasDrotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
///////////////////////////// cuRAND /////////////////////////////
|
|
// RAND function call status types (enum curandStatus)
|
|
{"CURAND_STATUS_SUCCESS", {"HIPRAND_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_VERSION_MISMATCH", {"HIPRAND_STATUS_VERSION_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_NOT_INITIALIZED", {"HIPRAND_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_ALLOCATION_FAILED", {"HIPRAND_STATUS_ALLOCATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_TYPE_ERROR", {"HIPRAND_STATUS_TYPE_ERROR", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_OUT_OF_RANGE", {"HIPRAND_STATUS_OUT_OF_RANGE", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_LENGTH_NOT_MULTIPLE", {"HIPRAND_STATUS_LENGTH_NOT_MULTIPLE", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_DOUBLE_PRECISION_REQUIRED", {"HIPRAND_STATUS_DOUBLE_PRECISION_REQUIRED", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_LAUNCH_FAILURE", {"HIPRAND_STATUS_LAUNCH_FAILURE", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_PREEXISTING_FAILURE", {"HIPRAND_STATUS_PREEXISTING_FAILURE", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_INITIALIZATION_FAILED", {"HIPRAND_STATUS_INITIALIZATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_ARCH_MISMATCH", {"HIPRAND_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_STATUS_INTERNAL_ERROR", {"HIPRAND_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
|
|
// RAND generator types (enum curandRngType)
|
|
{"CURAND_RNG_TEST", {"HIPRAND_RNG_TEST", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_DEFAULT", {"HIPRAND_RNG_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_XORWOW", {"HIPRAND_RNG_PSEUDO_XORWOW", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_MRG32K3A", {"HIPRAND_RNG_PSEUDO_MRG32K3A", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_MTGP32", {"HIPRAND_RNG_PSEUDO_MTGP32", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_MT19937", {"HIPRAND_RNG_PSEUDO_MT19937", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_PSEUDO_PHILOX4_32_10", {"HIPRAND_RNG_PSEUDO_PHILOX4_32_10", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_QUASI_DEFAULT", {"HIPRAND_RNG_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_QUASI_SOBOL32", {"HIPRAND_RNG_QUASI_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_QUASI_SCRAMBLED_SOBOL32", {"HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_QUASI_SOBOL64", {"HIPRAND_RNG_QUASI_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
{"CURAND_RNG_QUASI_SCRAMBLED_SOBOL64", {"HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND}},
|
|
|
|
// RAND ordering of results in memory (enum curandOrdering)
|
|
{"CURAND_ORDERING_PSEUDO_BEST", {"HIPRAND_ORDERING_PSEUDO_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_ORDERING_PSEUDO_DEFAULT", {"HIPRAND_ORDERING_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_ORDERING_PSEUDO_SEEDED", {"HIPRAND_ORDERING_PSEUDO_SEEDED", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_ORDERING_QUASI_DEFAULT", {"HIPRAND_ORDERING_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
|
|
// RAND choice of direction vector set (enum curandDirectionVectorSet)
|
|
{"CURAND_DIRECTION_VECTORS_32_JOEKUO6", {"HIPRAND_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6", {"HIPRAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_DIRECTION_VECTORS_64_JOEKUO6", {"HIPRAND_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6", {"HIPRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
|
|
// RAND method (enum curandMethod)
|
|
{"CURAND_CHOOSE_BEST", {"HIPRAND_CHOOSE_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_ITR", {"HIPRAND_ITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_KNUTH", {"HIPRAND_KNUTH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_HITR", {"HIPRAND_HITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_M1", {"HIPRAND_M1", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_M2", {"HIPRAND_M2", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_BINARY_SEARCH", {"HIPRAND_BINARY_SEARCH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_DISCRETE_GAUSS", {"HIPRAND_DISCRETE_GAUSS", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_REJECTION", {"HIPRAND_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_DEVICE_API", {"HIPRAND_DEVICE_API", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_FAST_REJECTION", {"HIPRAND_FAST_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_3RD", {"HIPRAND_3RD", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_DEFINITION", {"HIPRAND_DEFINITION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
{"CURAND_POISSON", {"HIPRAND_POISSON", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED}},
|
|
|
|
// RAND Host functions
|
|
{"curandCreateGenerator", {"hiprandCreateGenerator", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandCreateGeneratorHost", {"hiprandCreateGeneratorHost", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandCreatePoissonDistribution", {"hiprandCreatePoissonDistribution", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandDestroyDistribution", {"hiprandDestroyDistribution", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandDestroyGenerator", {"hiprandDestroyGenerator", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerate", {"hiprandGenerate", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateLogNormal", {"hiprandGenerateLogNormal", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateLogNormalDouble", {"hiprandGenerateLogNormalDouble", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateLongLong", {"hiprandGenerateLongLong", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGenerateNormal", {"hiprandGenerateNormal", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateNormalDouble", {"hiprandGenerateNormalDouble", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGeneratePoisson", {"hiprandGeneratePoisson", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateSeeds", {"hiprandGenerateSeeds", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateUniform", {"hiprandGenerateUniform", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGenerateUniformDouble", {"hiprandGenerateUniformDouble", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandGetDirectionVectors32", {"hiprandGetDirectionVectors32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGetDirectionVectors64", {"hiprandGetDirectionVectors64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGetProperty", {"hiprandGetProperty", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGetScrambleConstants32", {"hiprandGetScrambleConstants32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGetScrambleConstants64", {"hiprandGetScrambleConstants64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandGetVersion", {"hiprandGetVersion", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandSetGeneratorOffset", {"hiprandSetGeneratorOffset", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandSetGeneratorOrdering", {"hiprandSetGeneratorOrdering", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curandSetPseudoRandomGeneratorSeed", {"hiprandSetPseudoRandomGeneratorSeed", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandSetQuasiRandomGeneratorDimensions", {"hiprandSetQuasiRandomGeneratorDimensions", CONV_MATH_FUNC, API_RAND}},
|
|
{"curandSetStream", {"hiprandSetStream", CONV_MATH_FUNC, API_RAND}},
|
|
|
|
// RAND Device functions
|
|
{"curand", {"hiprand", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_init", {"hiprand_init", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal", {"hiprand_log_normal", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal_double", {"hiprand_log_normal_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal2", {"hiprand_log_normal2", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal2_double", {"hiprand_log_normal2_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal4", {"hiprand_log_normal4", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_log_normal4_double", {"hiprand_log_normal4_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_mtgp32_single", {"hiprand_mtgp32_single", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curand_mtgp32_single_specific", {"hiprand_mtgp32_single_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curand_mtgp32_specific", {"hiprand_mtgp32_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
{"curand_normal", {"hiprand_normal", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_normal_double", {"hiprand_normal_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_normal2", {"hiprand_normal2", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_normal2_double", {"hiprand_normal2_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_normal4", {"hiprand_normal4", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_normal4_double", {"hiprand_normal4_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_uniform", {"hiprand_uniform", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_uniform_double", {"hiprand_uniform_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_uniform2_double", {"hiprand_uniform2_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_uniform4", {"hiprand_uniform4", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_uniform4_double", {"hiprand_uniform4_double", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_discrete", {"hiprand_discrete", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_discrete4", {"hiprand_discrete4", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_poisson", {"hiprand_poisson", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_poisson4", {"hiprand_poisson4", CONV_DEVICE_FUNC, API_RAND}},
|
|
{"curand_Philox4x32_10", {"hiprand_Philox4x32_10", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED}},
|
|
// unchanged function names: skipahead, skipahead_sequence, skipahead_subsequence
|
|
|
|
///////////////////////////// cuDNN /////////////////////////////
|
|
// cuDNN defines
|
|
{"CUDNN_VERSION", {"HIPDNN_VERSION", CONV_NUMERIC_LITERAL, API_DNN}}, // 7000
|
|
{"CUDNN_DIM_MAX", {"HIPDNN_DIM_MAX", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 8
|
|
{"CUDNN_LRN_MIN_N", {"HIPDNN_LRN_MIN_N", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1
|
|
{"CUDNN_LRN_MAX_N", {"HIPDNN_LRN_MAX_N", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 16
|
|
{"CUDNN_LRN_MIN_K", {"HIPDNN_LRN_MIN_K", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1e-5
|
|
{"CUDNN_LRN_MIN_BETA", {"HIPDNN_LRN_MIN_BETA", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0.01
|
|
{"CUDNN_BN_MIN_EPSILON", {"HIPDNN_BN_MIN_EPSILON", CONV_NUMERIC_LITERAL, API_DNN}}, // 1e-5
|
|
{"CUDNN_SEV_ERROR_EN", {"HIPDNN_SEV_ERROR_EN", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_SEV_WARNING_EN", {"HIPDNN_SEV_WARNING_EN", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_SEV_INFO_EN", {"HIPDNN_SEV_INFO_EN", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN enums
|
|
{"cudnnStatus_t", {"hipdnnStatus_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_STATUS_SUCCESS", {"HIPDNN_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_STATUS_NOT_INITIALIZED", {"HIPDNN_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_STATUS_ALLOC_FAILED", {"HIPDNN_STATUS_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_STATUS_BAD_PARAM", {"HIPDNN_STATUS_BAD_PARAM", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_STATUS_INTERNAL_ERROR", {"HIPDNN_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_STATUS_INVALID_VALUE", {"HIPDNN_STATUS_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_STATUS_ARCH_MISMATCH", {"HIPDNN_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_DNN}}, // 6
|
|
{"CUDNN_STATUS_MAPPING_ERROR", {"HIPDNN_STATUS_MAPPING_ERROR", CONV_NUMERIC_LITERAL, API_DNN}}, // 7
|
|
{"CUDNN_STATUS_EXECUTION_FAILED", {"HIPDNN_STATUS_EXECUTION_FAILED", CONV_NUMERIC_LITERAL, API_DNN}}, // 8
|
|
{"CUDNN_STATUS_NOT_SUPPORTED", {"HIPDNN_STATUS_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_DNN}}, // 9
|
|
{"CUDNN_STATUS_LICENSE_ERROR", {"HIPDNN_STATUS_LICENSE_ERROR", CONV_NUMERIC_LITERAL, API_DNN}}, // 10
|
|
{"CUDNN_STATUS_RUNTIME_PREREQUISITE_MISSING", {"HIPDNN_STATUS_RUNTIME_PREREQUISITE_MISSING", CONV_NUMERIC_LITERAL, API_DNN}}, // 11
|
|
{"CUDNN_STATUS_RUNTIME_IN_PROGRESS", {"HIPDNN_STATUS_RUNTIME_IN_PROGRESS", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 12
|
|
{"CUDNN_STATUS_RUNTIME_FP_OVERFLOW", {"HIPDNN_STATUS_RUNTIME_FP_OVERFLOW", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 13
|
|
{"cudnnRuntimeTag_t", {"hipdnnRuntimeTag_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnConvolutionMode_t", {"hipdnnConvolutionMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION", {"HIPDNN_CONVOLUTION", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CROSS_CORRELATION", {"HIPDNN_CROSS_CORRELATION", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnTensorFormat_t", {"hipdnnTensorFormat_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_TENSOR_NCHW", {"HIPDNN_TENSOR_NCHW", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_TENSOR_NHWC", {"HIPDNN_TENSOR_NHWC", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_TENSOR_NCHW_VECT_C", {"HIPDNN_TENSOR_NCHW_VECT_C", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnDataType_t", {"hipdnnDataType_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_DATA_FLOAT", {"HIPDNN_DATA_FLOAT", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_DATA_DOUBLE", {"HIPDNN_DATA_DOUBLE", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_DATA_HALF", {"HIPDNN_DATA_HALF", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_DATA_INT8", {"HIPDNN_DATA_INT8", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_DATA_INT32", {"HIPDNN_DATA_INT32", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_DATA_INT8x4", {"HIPDNN_DATA_INT8x4", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_DATA_UINT8", {"HIPDNN_DATA_UINT8", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 6
|
|
{"CUDNN_DATA_UINT8x4", {"HIPDNN_DATA_UINT8x4", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 7
|
|
{"cudnnErrQueryMode_t", {"hipdnnErrQueryMode_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_ERRQUERY_RAWCODE", {"HIPDNN_ERRQUERY_RAWCODE", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
{"CUDNN_ERRQUERY_NONBLOCKING", {"HIPDNN_ERRQUERY_NONBLOCKING", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1
|
|
{"CUDNN_ERRQUERY_BLOCKING", {"HIPDNN_ERRQUERY_BLOCKING", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 2
|
|
{"cudnnSeverity_t", {"hipdnnSeverity_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_SEV_FATAL", {"HIPDNN_SEV_FATAL", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
{"CUDNN_SEV_ERROR", {"HIPDNN_SEV_ERROR", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1
|
|
{"CUDNN_SEV_WARNING", {"HIPDNN_SEV_WARNING", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 2
|
|
{"CUDNN_SEV_INFO", {"HIPDNN_SEV_INFO", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 3
|
|
{"cudnnConvolutionFwdAlgo_t", {"hipdnnConvolutionFwdAlgo_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM", {"HIPDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM", {"HIPDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_GEMM", {"HIPDNN_CONVOLUTION_FWD_ALGO_GEMM", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_DIRECT", {"HIPDNN_CONVOLUTION_FWD_ALGO_DIRECT", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_FFT", {"HIPDNN_CONVOLUTION_FWD_ALGO_FFT", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_FFT_TILING", {"HIPDNN_CONVOLUTION_FWD_ALGO_FFT_TILING", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD", {"HIPDNN_CONVOLUTION_FWD_ALGO_WINOGRAD", CONV_NUMERIC_LITERAL, API_DNN}}, // 6
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED", {"HIPDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED", CONV_NUMERIC_LITERAL, API_DNN}}, // 7
|
|
{"CUDNN_CONVOLUTION_FWD_ALGO_COUNT", {"HIPDNN_CONVOLUTION_FWD_ALGO_COUNT", CONV_NUMERIC_LITERAL, API_DNN}}, // 8
|
|
{"cudnnConvolutionFwdPreference_t", {"hipdnnConvolutionFwdPreference_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_FWD_NO_WORKSPACE", {"HIPDNN_CONVOLUTION_FWD_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_FWD_PREFER_FASTEST", {"HIPDNN_CONVOLUTION_FWD_PREFER_FASTEST", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT", {"HIPDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnDeterminism_t", {"hipdnnDeterminism_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_NON_DETERMINISTIC", {"HIPDNN_NON_DETERMINISTIC", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
{"CUDNN_DETERMINISTIC", {"HIPDNN_DETERMINISTIC", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1
|
|
{"cudnnDivNormMode_t", {"hipdnnDivNormMode_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_DIVNORM_PRECOMPUTED_MEANS", {"HIPDNN_DIVNORM_PRECOMPUTED_MEANS", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
{"cudnnCTCLossAlgo_t", {"hipdnnCTCLossAlgo_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_CTC_LOSS_ALGO_DETERMINISTIC", {"HIPDNN_CTC_LOSS_ALGO_DETERMINISTIC", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
{"CUDNN_CTC_LOSS_ALGO_NON_DETERMINISTIC", {"HIPDNN_CTC_LOSS_ALGO_NON_DETERMINISTIC", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 1
|
|
{"cudnnLRNMode_t", {"hipdnnLRNMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_LRN_CROSS_CHANNEL_DIM1", {"HIPDNN_LRN_CROSS_CHANNEL", CONV_NUMERIC_LITERAL, API_DNN}}, // 0 vs 1
|
|
{"cudnnRNNInputMode_t", {"hipdnnRNNInputMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_LINEAR_INPUT", {"HIPDNN_LINEAR_INPUT", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_SKIP_INPUT", {"HIPDNN_SKIP_INPUT", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnDirectionMode_t", {"hipdnnDirectionMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_UNIDIRECTIONAL", {"HIPDNN_UNIDIRECTIONAL", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_BIDIRECTIONAL", {"HIPDNN_BIDIRECTIONAL", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnMathType_t", {"hipdnnMathType_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_DEFAULT_MATH", {"HIPDNN_DEFAULT_MATH", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_TENSOR_OP_MATH", {"HIPDNN_TENSOR_OP_MATH", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnNanPropagation_t", {"hipdnnNanPropagation_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_NOT_PROPAGATE_NAN", {"HIPDNN_NOT_PROPAGATE_NAN", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_PROPAGATE_NAN", {"HIPDNN_PROPAGATE_NAN", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnConvolutionBwdDataAlgo_t", {"hipdnnConvolutionBwdDataAlgo_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_0", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_0", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_1", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_1", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_FFT", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT_TILING", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_FFT_TILING", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_ALGO_COUNT", {"HIPDNN_CONVOLUTION_BWD_DATA_ALGO_TRANSPOSE_GEMM", CONV_NUMERIC_LITERAL, API_DNN}}, // 6
|
|
{"cudnnConvolutionBwdFilterAlgo_t", {"hipdnnConvolutionBwdFilterAlgo_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_0", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_1", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_3", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_3", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD_NONFUSED", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD_NONFUSED", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT_TILING", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT_TILING", CONV_NUMERIC_LITERAL, API_DNN}}, // 6
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_ALGO_COUNT", {"HIPDNN_CONVOLUTION_BWD_FILTER_ALGO_COUNT", CONV_NUMERIC_LITERAL, API_DNN}}, // 7
|
|
{"cudnnConvolutionBwdFilterPreference_t", {"hipdnnConvolutionBwdFilterPreference_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_NO_WORKSPACE", {"HIPDNN_CONVOLUTION_BWD_FILTER_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_PREFER_FASTEST", {"HIPDNN_CONVOLUTION_BWD_FILTER_PREFER_FASTEST", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT",{"HIPDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT",CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnRNNAlgo_t", {"hipdnnRNNAlgo_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_RNN_ALGO_STANDARD", {"HIPDNN_RNN_ALGO_STANDARD", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_RNN_ALGO_PERSIST_STATIC", {"HIPDNN_RNN_ALGO_PERSIST_STATIC", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_RNN_ALGO_PERSIST_DYNAMIC", {"HIPDNN_RNN_ALGO_PERSIST_DYNAMIC", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_RNN_ALGO_COUNT", {"HIPDNN_RNN_ALGO_COUNT", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 3
|
|
{"cudnnRNNMode_t", {"hipdnnRNNMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_RNN_RELU", {"HIPDNN_RNN_RELU", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_RNN_TANH", {"HIPDNN_RNN_TANH", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_LSTM", {"HIPDNN_LSTM", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_GRU", {"HIPDNN_GRU", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"cudnnOpTensorOp_t", {"hipdnnOpTensorOp_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_OP_TENSOR_ADD", {"HIPDNN_OP_TENSOR_ADD", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_OP_TENSOR_MUL", {"HIPDNN_OP_TENSOR_MUL", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_OP_TENSOR_MIN", {"HIPDNN_OP_TENSOR_MIN", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_OP_TENSOR_MAX", {"HIPDNN_OP_TENSOR_MAX", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_OP_TENSOR_SQRT", {"HIPDNN_OP_TENSOR_SQRT", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_OP_TENSOR_NOT", {"HIPDNN_OP_TENSOR_NOT", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 5
|
|
{"cudnnReduceTensorOp_t", {"hipdnnReduceTensorOp_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_REDUCE_TENSOR_ADD", {"HIPDNN_REDUCE_TENSOR_ADD", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_REDUCE_TENSOR_MUL", {"HIPDNN_REDUCE_TENSOR_MUL", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_REDUCE_TENSOR_MIN", {"HIPDNN_REDUCE_TENSOR_MIN", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_REDUCE_TENSOR_MAX", {"HIPDNN_REDUCE_TENSOR_MAX", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_REDUCE_TENSOR_AMAX", {"HIPDNN_REDUCE_TENSOR_AMAX", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_REDUCE_TENSOR_AVG", {"HIPDNN_REDUCE_TENSOR_AVG", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"CUDNN_REDUCE_TENSOR_NORM1", {"HIPDNN_REDUCE_TENSOR_NORM1", CONV_NUMERIC_LITERAL, API_DNN}}, // 6
|
|
{"CUDNN_REDUCE_TENSOR_NORM2", {"HIPDNN_REDUCE_TENSOR_NORM2", CONV_NUMERIC_LITERAL, API_DNN}}, // 7
|
|
{"CUDNN_REDUCE_TENSOR_MUL_NO_ZEROS", {"HIPDNN_REDUCE_TENSOR_MUL_NO_ZEROS", CONV_NUMERIC_LITERAL, API_DNN}}, // 8
|
|
{"cudnnReduceTensorIndices_t", {"hipdnnReduceTensorIndices_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_REDUCE_TENSOR_NO_INDICES", {"HIPDNN_REDUCE_TENSOR_NO_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_REDUCE_TENSOR_FLATTENED_INDICES", {"HIPDNN_REDUCE_TENSOR_FLATTENED_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnConvolutionBwdDataPreference_t", {"hipdnnConvolutionBwdDataPreference_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_NO_WORKSPACE", {"HIPDNN_CONVOLUTION_BWD_DATA_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_PREFER_FASTEST", {"HIPDNN_CONVOLUTION_BWD_DATA_PREFER_FASTEST", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT", {"HIPDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnIndicesType_t", {"hipdnnIndicesType_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_32BIT_INDICES", {"HIPDNN_32BIT_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_64BIT_INDICES", {"HIPDNN_64BIT_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_16BIT_INDICES", {"HIPDNN_16BIT_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_8BIT_INDICES", {"HIPDNN_8BIT_INDICES", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"cudnnSoftmaxAlgorithm_t", {"hipdnnSoftmaxAlgorithm_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_SOFTMAX_FAST", {"HIPDNN_SOFTMAX_FAST", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_SOFTMAX_ACCURATE", {"HIPDNN_SOFTMAX_ACCURATE", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_SOFTMAX_LOG", {"HIPDNN_SOFTMAX_LOG", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnSoftmaxMode_t", {"hipdnnSoftmaxMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_SOFTMAX_MODE_INSTANCE", {"HIPDNN_SOFTMAX_MODE_INSTANCE", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_SOFTMAX_MODE_CHANNEL", {"HIPDNN_SOFTMAX_MODE_CHANNEL", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"cudnnPoolingMode_t", {"hipdnnPoolingMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_POOLING_MAX", {"HIPDNN_POOLING_MAX", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_POOLING_AVERAGE_COUNT_INCLUDE_PADDING", {"HIPDNN_POOLING_AVERAGE_COUNT_INCLUDE_PADDING", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING", {"HIPDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_POOLING_MAX_DETERMINISTIC", {"HIPDNN_POOLING_MAX_DETERMINISTIC", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"cudnnActivationMode_t", {"hipdnnActivationMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_ACTIVATION_SIGMOID", {"HIPDNN_ACTIVATION_SIGMOID", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_ACTIVATION_RELU", {"HIPDNN_ACTIVATION_RELU", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_ACTIVATION_TANH", {"HIPDNN_ACTIVATION_TANH", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"CUDNN_ACTIVATION_CLIPPED_RELU", {"HIPDNN_ACTIVATION_CLIPPED_RELU", CONV_NUMERIC_LITERAL, API_DNN}}, // 3
|
|
{"CUDNN_ACTIVATION_ELU", {"HIPDNN_ACTIVATION_ELU", CONV_NUMERIC_LITERAL, API_DNN}}, // 4
|
|
{"CUDNN_ACTIVATION_IDENTITY", {"HIPDNN_ACTIVATION_PATHTRU", CONV_NUMERIC_LITERAL, API_DNN}}, // 5
|
|
{"cudnnBatchNormMode_t", {"hipdnnBatchNormMode_t", CONV_TYPE, API_DNN}},
|
|
{"CUDNN_BATCHNORM_PER_ACTIVATION", {"HIPDNN_BATCHNORM_PER_ACTIVATION", CONV_NUMERIC_LITERAL, API_DNN}}, // 0
|
|
{"CUDNN_BATCHNORM_SPATIAL", {"HIPDNN_BATCHNORM_SPATIAL", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUDNN_BATCHNORM_SPATIAL_PERSISTENT", {"HIPDNN_BATCHNORM_SPATIAL_PERSISTENT", CONV_NUMERIC_LITERAL, API_DNN}}, // 2
|
|
{"cudnnSamplerType_t", {"hipdnnSamplerType_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"CUDNN_SAMPLER_BILINEAR", {"HIPDNN_SAMPLER_BILINEAR", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // 0
|
|
|
|
// cuDNN types
|
|
{"cudnnContext", {"hipdnnContext", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnHandle_t", {"hipdnnHandle_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnTensorStruct", {"hipdnnTensorStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnTensorDescriptor_t", {"hipdnnTensorDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnConvolutionStruct", {"hipdnnConvolutionStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnConvolutionDescriptor_t", {"hipdnnConvolutionDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnPoolingStruct", {"hipdnnPoolingStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnPoolingDescriptor_t", {"hipdnnPoolingDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnFilterStruct", {"hipdnnFilterStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFilterDescriptor_t", {"hipdnnFilterDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnLRNStruct", {"hipdnnLRNStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnLRNDescriptor_t", {"hipdnnLRNDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnActivationStruct", {"hipdnnActivationStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnActivationDescriptor_t", {"hipdnnActivationDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnSpatialTransformerStruct", {"hipdnnSpatialTransformerStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSpatialTransformerDescriptor_t", {"hipdnnSpatialTransformerDescriptor_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnOpTensorStruct", {"hipdnnOpTensorStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnOpTensorDescriptor_t", {"hipdnnOpTensorDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnReduceTensorStruct", {"hipdnnReduceTensorStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnReduceTensorDescriptor_t", {"hipdnnReduceTensorDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnCTCLossStruct", {"hipdnnCTCLossStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCTCLossDescriptor_t", {"hipdnnCTCLossDescriptor_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnConvolutionFwdAlgoPerf_t", {"hipdnnConvolutionFwdAlgoPerf_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnConvolutionBwdFilterAlgoPerf_t", {"hipdnnConvolutionBwdFilterAlgoPerf_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnConvolutionBwdDataAlgoPerf_t", {"hipdnnConvolutionBwdDataAlgoPerf_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnDropoutStruct", {"hipdnnDropoutStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDropoutDescriptor_t", {"hipdnnDropoutDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnAlgorithmStruct", {"hipdnnAlgorithmStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnAlgorithmDescriptor_t", {"hipdnnAlgorithmDescriptor_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnAlgorithmPerformanceStruct", {"hipdnnAlgorithmPerformanceStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnAlgorithmPerformance_t", {"hipdnnAlgorithmPerformance_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnRNNStruct", {"hipdnnRNNStruct", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnRNNDescriptor_t", {"hipdnnRNNDescriptor_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnPersistentRNNPlan", {"hipdnnPersistentRNNPlan", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnPersistentRNNPlan_t", {"hipdnnPersistentRNNPlan_t", CONV_TYPE, API_DNN}},
|
|
{"cudnnAlgorithm_t", {"hipdnnAlgorithm_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDebug_t", {"hipdnnDebug_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCallback_t", {"hipdnnCallback_t", CONV_TYPE, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
///////////////////////////// cuDNN functions /////////////////////////////
|
|
{"cudnnGetVersion", {"hipdnnGetVersion", CONV_VERSION, API_DNN}},
|
|
{"cudnnGetCudartVersion", {"hipdnnGetCudartVersion", CONV_VERSION, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnQueryRuntimeError", {"hipdnnQueryRuntimeError", CONV_VERSION, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetProperty", {"hipdnnGetProperty", CONV_VERSION, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetErrorString", {"hipdnnGetErrorString", CONV_ERROR, API_DNN}},
|
|
{"cudnnIm2Col", {"hipdnnIm2Col", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCreate", {"hipdnnCreate", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroy", {"hipdnnDestroy", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetStream", {"hipdnnSetStream", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetStream", {"hipdnnGetStream", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetCallback", {"hipdnnSetCallback", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetCallback", {"hipdnnGetCallback", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN Tensor functions
|
|
{"cudnnCreateTensorDescriptor", {"hipdnnCreateTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetTensor4dDescriptor", {"hipdnnSetTensor4dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetTensor4dDescriptorEx", {"hipdnnSetTensor4dDescriptorEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetTensor4dDescriptor", {"hipdnnGetTensor4dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetTensorNdDescriptor", {"hipdnnSetTensorNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetTensorNdDescriptorEx", {"hipdnnSetTensorNdDescriptorEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetTensorNdDescriptor", {"hipdnnGetTensorNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetTensorSizeInBytes", {"hipdnnGetTensorSizeInBytes", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroyTensorDescriptor", {"hipdnnDestroyTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnTransformTensor", {"hipdnnTransformTensor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnAddTensor", {"hipdnnAddTensor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnCreateOpTensorDescriptor", {"hipdnnCreateOpTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetOpTensorDescriptor", {"hipdnnSetOpTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetOpTensorDescriptor", {"hipdnnGetOpTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyOpTensorDescriptor", {"hipdnnDestroyOpTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnOpTensor", {"hipdnnOpTensor", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Reduce Tensor functions
|
|
{"cudnnCreateReduceTensorDescriptor", {"hipdnnCreateReduceTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetReduceTensorDescriptor", {"hipdnnSetReduceTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetReduceTensorDescriptor", {"hipdnnGetReduceTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyReduceTensorDescriptor", {"hipdnnDestroyReduceTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetReductionIndicesSize", {"hipdnnGetReductionIndicesSize", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetReductionWorkspaceSize", {"hipdnnGetReductionWorkspaceSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnReduceTensor", {"hipdnnReduceTensor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetTensor", {"hipdnnSetTensor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnScaleTensor", {"hipdnnScaleTensor", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Filter functions
|
|
{"cudnnCreateFilterDescriptor", {"hipdnnCreateFilterDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetFilter4dDescriptor", {"hipdnnSetFilter4dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetFilter4dDescriptor", {"hipdnnGetFilter4dDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetFilterNdDescriptor", {"hipdnnSetFilterNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetFilterNdDescriptor", {"hipdnnGetFilterNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyFilterDescriptor", {"hipdnnDestroyFilterDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Convolution functions
|
|
{"cudnnCreateConvolutionDescriptor", {"hipdnnCreateConvolutionDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetConvolutionMathType", {"hipdnnSetConvolutionMathType", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionMathType", {"hipdnnGetConvolutionMathType", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetConvolutionGroupCount", {"hipdnnSetConvolutionGroupCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetConvolutionGroupCount", {"hipdnnGetConvolutionGroupCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetConvolution2dDescriptor", {"hipdnnSetConvolution2dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolution2dDescriptor", {"hipdnnGetConvolution2dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolution2dForwardOutputDim", {"hipdnnGetConvolution2dForwardOutputDim", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetConvolutionNdDescriptor", {"hipdnnSetConvolutionNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionNdDescriptor", {"hipdnnGetConvolutionNdDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetConvolutionNdForwardOutputDim", {"hipdnnGetConvolutionNdForwardOutputDim", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroyConvolutionDescriptor", {"hipdnnDestroyConvolutionDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionForwardAlgorithmMaxCount", {"hipdnnGetConvolutionForwardAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindConvolutionForwardAlgorithm", {"hipdnnFindConvolutionForwardAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnFindConvolutionForwardAlgorithmEx", {"hipdnnFindConvolutionForwardAlgorithmEx", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionForwardAlgorithm", {"hipdnnGetConvolutionForwardAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionForwardAlgorithm_v7", {"hipdnnGetConvolutionForwardAlgorithm_v7", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetConvolutionForwardWorkspaceSize", {"hipdnnGetConvolutionForwardWorkspaceSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnConvolutionForward", {"hipdnnConvolutionForward", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnConvolutionBiasActivationForward", {"hipdnnConvolutionBiasActivationForward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnConvolutionBackwardBias", {"hipdnnConvolutionBackwardBias", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardFilterAlgorithmMaxCount", {"hipdnnGetConvolutionBackwardFilterAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindConvolutionBackwardFilterAlgorithm", {"hipdnnFindConvolutionBackwardFilterAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnFindConvolutionBackwardFilterAlgorithmEx", {"hipdnnFindConvolutionBackwardFilterAlgorithmEx", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardFilterAlgorithm", {"hipdnnGetConvolutionBackwardFilterAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardFilterAlgorithm_v7", {"hipdnnGetConvolutionBackwardFilterAlgorithm_v7", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetConvolutionBackwardFilterWorkspaceSize", {"hipdnnGetConvolutionBackwardFilterWorkspaceSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnConvolutionBackwardFilter", {"hipdnnConvolutionBackwardFilter", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardDataAlgorithmMaxCount", {"hipdnnGetConvolutionBackwardDataAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindConvolutionBackwardDataAlgorithm", {"hipdnnFindConvolutionBackwardDataAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnFindConvolutionBackwardDataAlgorithmEx", {"hipdnnFindConvolutionBackwardDataAlgorithmEx", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardDataAlgorithm", {"hipdnnGetConvolutionBackwardDataAlgorithm", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetConvolutionBackwardDataAlgorithm_v7", {"hipdnnGetConvolutionBackwardDataAlgorithm_v7", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetConvolutionBackwardDataWorkspaceSize", {"hipdnnGetConvolutionBackwardDataWorkspaceSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnConvolutionBackwardData", {"hipdnnConvolutionBackwardData", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Sortmax functions
|
|
{"cudnnSoftmaxForward", {"hipdnnSoftmaxForward", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSoftmaxBackward", {"hipdnnSoftmaxBackward", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Pooling functions
|
|
{"cudnnCreatePoolingDescriptor", {"hipdnnCreatePoolingDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetPooling2dDescriptor", {"hipdnnSetPooling2dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetPooling2dDescriptor", {"hipdnnGetPooling2dDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetPoolingNdDescriptor", {"hipdnnSetPoolingNdDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetPoolingNdDescriptor", {"hipdnnGetPoolingNdDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetPoolingNdForwardOutputDim", {"hipdnnGetPoolingNdForwardOutputDim", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetPooling2dForwardOutputDim", {"hipdnnGetPooling2dForwardOutputDim", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyPoolingDescriptor", {"hipdnnDestroyPoolingDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnPoolingForward", {"hipdnnPoolingForward", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnPoolingBackward", {"hipdnnPoolingBackward", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Activation functions
|
|
{"cudnnCreateActivationDescriptor", {"hipdnnCreateActivationDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetActivationDescriptor", {"hipdnnSetActivationDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetActivationDescriptor", {"hipdnnGetActivationDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyActivationDescriptor", {"hipdnnDestroyActivationDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnActivationForward", {"hipdnnActivationForward", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnActivationBackward", {"hipdnnActivationBackward", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN LRN functions
|
|
{"cudnnCreateLRNDescriptor", {"hipdnnCreateLRNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetLRNDescriptor", {"hipdnnSetLRNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetLRNDescriptor", {"hipdnnGetLRNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyLRNDescriptor", {"hipdnnDestroyLRNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnLRNCrossChannelForward", {"hipdnnLRNCrossChannelForward", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnLRNCrossChannelBackward", {"hipdnnLRNCrossChannelBackward", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Divisive Normalization functions
|
|
{"cudnnDivisiveNormalizationForward", {"hipdnnDivisiveNormalizationForward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDivisiveNormalizationBackward", {"hipdnnDivisiveNormalizationBackward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN Batch Normalization functions
|
|
{"cudnnDeriveBNTensorDescriptor", {"hipdnnDeriveBNTensorDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnBatchNormalizationForwardTraining", {"hipdnnBatchNormalizationForwardTraining", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnBatchNormalizationForwardInference", {"hipdnnBatchNormalizationForwardInference", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnBatchNormalizationBackward", {"hipdnnBatchNormalizationBackward", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Spatial Transformer functions
|
|
{"cudnnCreateSpatialTransformerDescriptor", {"hipdnnCreateSpatialTransformerDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetSpatialTransformerNdDescriptor", {"hipdnnSetSpatialTransformerNdDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroySpatialTransformerDescriptor", {"hipdnnDestroySpatialTransformerDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSpatialTfGridGeneratorForward", {"hipdnnSpatialTfGridGeneratorForward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSpatialTfGridGeneratorBackward", {"hipdnnSpatialTfGridGeneratorBackward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSpatialTfSamplerForward", {"hipdnnSpatialTfSamplerForward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSpatialTfSamplerBackward", {"hipdnnSpatialTfSamplerBackward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN Dropout functions
|
|
{"cudnnCreateDropoutDescriptor", {"hipdnnCreateDropoutDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyDropoutDescriptor", {"hipdnnDestroyDropoutDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDropoutGetStatesSize", {"hipdnnDropoutGetStatesSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDropoutGetReserveSpaceSize", {"hipdnnDropoutGetReserveSpaceSize", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetDropoutDescriptor", {"hipdnnSetDropoutDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetDropoutDescriptor", {"hipdnnGetDropoutDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnRestoreDropoutDescriptor", {"hipdnnRestoreDropoutDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDropoutForward", {"hipdnnDropoutForward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDropoutBackward", {"hipdnnDropoutBackward", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN RNN functions
|
|
{"cudnnCreateRNNDescriptor", {"hipdnnCreateRNNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyRNNDescriptor", {"hipdnnDestroyRNNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNForwardInferenceAlgorithmMaxCount", {"hipdnnGetRNNForwardInferenceAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindRNNForwardInferenceAlgorithmEx", {"hipdnnFindRNNForwardInferenceAlgorithmEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNForwardTrainingAlgorithmMaxCount", {"hipdnnGetRNNForwardTrainingAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindRNNForwardTrainingAlgorithmEx", {"hipdnnFindRNNForwardTrainingAlgorithmEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNBackwardDataAlgorithmMaxCount", {"hipdnnGetRNNBackwardDataAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindRNNBackwardDataAlgorithmEx", {"hipdnnFindRNNBackwardDataAlgorithmEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNBackwardWeightsAlgorithmMaxCount", {"hipdnnGetRNNBackwardWeightsAlgorithmMaxCount", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnFindRNNBackwardWeightsAlgorithmEx", {"hipdnnFindRNNBackwardWeightsAlgorithmEx", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCreatePersistentRNNPlan", {"hipdnnCreatePersistentRNNPlan", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetPersistentRNNPlan", {"hipdnnSetPersistentRNNPlan", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnDestroyPersistentRNNPlan", {"hipdnnDestroyPersistentRNNPlan", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetRNNDescriptor", {"hipdnnSetRNNDescriptor", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNDescriptor", {"hipdnnGetRNNDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetRNNProjectionLayers", {"hipdnnSetRNNProjectionLayers", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNProjectionLayers", {"hipdnnGetRNNProjectionLayers", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetRNNAlgorithmDescriptor", {"hipdnnSetRNNAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetRNNMatrixMathType", {"hipdnnSetRNNMatrixMathType", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNMatrixMathType", {"hipdnnGetRNNMatrixMathType", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetRNNWorkspaceSize", {"hipdnnGetRNNWorkspaceSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNTrainingReserveSize", {"hipdnnGetRNNTrainingReserveSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNParamsSize", {"hipdnnGetRNNParamsSize", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNLinLayerMatrixParams", {"hipdnnGetRNNLinLayerMatrixParams", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnGetRNNLinLayerBiasParams", {"hipdnnGetRNNLinLayerBiasParams", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnRNNForwardInference", {"hipdnnRNNForwardInference", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnRNNForwardTraining", {"hipdnnRNNForwardTraining", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnRNNBackwardData", {"hipdnnRNNBackwardData", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnRNNBackwardWeights", {"hipdnnRNNBackwardWeights", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetRNNDescriptor_v5", {"hipdnnSetRNNDescriptor_v5", CONV_MATH_FUNC, API_DNN}},
|
|
{"cudnnSetRNNDescriptor_v6", {"hipdnnSetRNNDescriptor_v6", CONV_MATH_FUNC, API_DNN}},
|
|
|
|
// cuDNN Connectionist Temporal Classification loss functions
|
|
{"cudnnCreateCTCLossDescriptor", {"hipdnnCreateCTCLossDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetCTCLossDescriptor", {"hipdnnSetCTCLossDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetCTCLossDescriptor", {"hipdnnGetCTCLossDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroyCTCLossDescriptor", {"hipdnnDestroyCTCLossDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCTCLoss", {"hipdnnCTCLoss", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetCTCLossWorkspaceSize", {"hipdnnGetCTCLossWorkspaceSize", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
// cuDNN Algorithm functions
|
|
{"cudnnCreateAlgorithmDescriptor", {"hipdnnCreateAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetAlgorithmDescriptor", {"hipdnnSetAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetAlgorithmDescriptor", {"hipdnnGetAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCopyAlgorithmDescriptor", {"hipdnnCopyAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroyAlgorithmDescriptor", {"hipdnnDestroyAlgorithmDescriptor", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnCreateAlgorithmPerformance", {"hipdnnCreateAlgorithmPerformance", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSetAlgorithmPerformance", {"hipdnnSetAlgorithmPerformance", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetAlgorithmPerformance", {"hipdnnGetAlgorithmPerformance", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnDestroyAlgorithmPerformance", {"hipdnnDestroyAlgorithmPerformance", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnGetAlgorithmSpaceSize", {"hipdnnGetAlgorithmSpaceSize", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnSaveAlgorithm", {"hipdnnSaveAlgorithm", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
{"cudnnRestoreAlgorithm", {"hipdnnRestoreAlgorithm", CONV_MATH_FUNC, API_DNN, HIP_UNSUPPORTED}},
|
|
|
|
///////////////////////////// cuFFT /////////////////////////////
|
|
// cuFFT defines
|
|
{"CUFFT_FORWARD", {"HIPFFT_FORWARD", CONV_NUMERIC_LITERAL, API_DNN}}, // -1
|
|
{"CUFFT_INVERSE", {"HIPFFT_BACKWARD", CONV_NUMERIC_LITERAL, API_DNN}}, // 1
|
|
{"CUFFT_COMPATIBILITY_DEFAULT", {"HIPFFT_COMPATIBILITY_DEFAULT", CONV_NUMERIC_LITERAL, API_DNN, HIP_UNSUPPORTED}}, // CUFFT_COMPATIBILITY_FFTW_PADDING
|
|
|
|
// cuFFT enums
|
|
{"cufftResult_t", {"hipfftResult_t", CONV_TYPE, API_FFT}},
|
|
{"cufftResult", {"hipfftResult", CONV_TYPE, API_FFT}},
|
|
{"CUFFT_SUCCESS", {"HIPFFT_SUCCESS", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x0 0
|
|
{"CUFFT_INVALID_PLAN", {"HIPFFT_INVALID_PLAN", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x1 1
|
|
{"CUFFT_ALLOC_FAILED", {"HIPFFT_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x2 2
|
|
{"CUFFT_INVALID_TYPE", {"HIPFFT_INVALID_TYPE", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x3 3
|
|
{"CUFFT_INVALID_VALUE", {"HIPFFT_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x4 4
|
|
{"CUFFT_INTERNAL_ERROR", {"HIPFFT_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x5 5
|
|
{"CUFFT_EXEC_FAILED", {"HIPFFT_EXEC_FAILED", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x6 6
|
|
{"CUFFT_SETUP_FAILED", {"HIPFFT_SETUP_FAILED", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x7 7
|
|
{"CUFFT_INVALID_SIZE", {"HIPFFT_INVALID_SIZE", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x8 8
|
|
{"CUFFT_UNALIGNED_DATA", {"HIPFFT_UNALIGNED_DATA", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x9 9
|
|
{"CUFFT_INCOMPLETE_PARAMETER_LIST", {"HIPFFT_INCOMPLETE_PARAMETER_LIST", CONV_NUMERIC_LITERAL, API_FFT}}, // 0xA 10
|
|
{"CUFFT_INVALID_DEVICE", {"HIPFFT_INVALID_DEVICE", CONV_NUMERIC_LITERAL, API_FFT}}, // 0xB 11
|
|
{"CUFFT_PARSE_ERROR", {"HIPFFT_PARSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT}}, // 0xC 12
|
|
{"CUFFT_NO_WORKSPACE", {"HIPFFT_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_FFT}}, // 0xD 13
|
|
{"CUFFT_NOT_IMPLEMENTED", {"HIPFFT_NOT_IMPLEMENTED", CONV_NUMERIC_LITERAL, API_FFT}}, // 0xE 14
|
|
{"CUFFT_LICENSE_ERROR", {"HIPFFT_LICENSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED}},
|
|
{"CUFFT_NOT_SUPPORTED", {"HIPFFT_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x10 16
|
|
{"cufftType_t", {"hipfftType_t", CONV_TYPE, API_FFT}},
|
|
{"cufftType", {"hipfftType", CONV_TYPE, API_FFT}},
|
|
{"CUFFT_R2C", {"HIPFFT_R2C", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x2a
|
|
{"CUFFT_C2R", {"HIPFFT_C2R", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x2c
|
|
{"CUFFT_C2C", {"HIPFFT_C2C", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x29
|
|
{"CUFFT_D2Z", {"HIPFFT_D2Z", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x6a
|
|
{"CUFFT_Z2D", {"HIPFFT_Z2D", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x6c
|
|
{"CUFFT_Z2Z", {"HIPFFT_Z2Z", CONV_NUMERIC_LITERAL, API_FFT}}, // 0x69
|
|
{"cufftCompatibility_t", {"hipfftCompatibility_t", CONV_TYPE, API_FFT, HIP_UNSUPPORTED}},
|
|
{"cufftCompatibility", {"hipfftCompatibility", CONV_TYPE, API_FFT, HIP_UNSUPPORTED}},
|
|
{"CUFFT_COMPATIBILITY_FFTW_PADDING", {"HIPFFT_COMPATIBILITY_FFTW_PADDING", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED}}, // 0x01
|
|
|
|
// cuFFT types
|
|
{"cufftReal", {"hipfftReal", CONV_TYPE, API_FFT}},
|
|
{"cufftDoubleReal", {"hipfftDoubleReal", CONV_TYPE, API_FFT}},
|
|
{"cufftComplex", {"hipfftComplex", CONV_TYPE, API_FFT}},
|
|
{"cufftDoubleComplex", {"hipfftDoubleComplex", CONV_TYPE, API_FFT}},
|
|
{"cufftHandle", {"hipfftHandle", CONV_TYPE, API_FFT}},
|
|
|
|
///////////////////////////// cuFFT functions /////////////////////////////
|
|
{"cufftPlan1d", {"hipfftPlan1d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftPlan2d", {"hipfftPlan2d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftPlan3d", {"hipfftPlan3d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftPlanMany", {"hipfftPlanMany", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftMakePlan1d", {"hipfftMakePlan1d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftMakePlan2d", {"hipfftMakePlan2d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftMakePlan3d", {"hipfftMakePlan3d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftMakePlanMany", {"hipfftMakePlanMany", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftMakePlanMany64", {"hipfftMakePlanMany64", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSizeMany64", {"hipfftGetSizeMany64", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftEstimate1d", {"hipfftEstimate1d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftEstimate2d", {"hipfftEstimate2d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftEstimate3d", {"hipfftEstimate3d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftEstimateMany", {"hipfftEstimateMany", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftCreate", {"hipfftCreate", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSize1d", {"hipfftGetSize1d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSize2d", {"hipfftGetSize2d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSize3d", {"hipfftGetSize3d", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSizeMany", {"hipfftGetSizeMany", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetSize", {"hipfftGetSize", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftSetWorkArea", {"hipfftSetWorkArea", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftSetAutoAllocation", {"hipfftSetAutoAllocation", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecC2C", {"hipfftExecC2C", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecR2C", {"hipfftExecR2C", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecC2R", {"hipfftExecC2R", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecZ2Z", {"hipfftExecZ2Z", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecD2Z", {"hipfftExecD2Z", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftExecZ2D", {"hipfftExecZ2D", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftSetStream", {"hipfftSetStream", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftDestroy", {"hipfftDestroy", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetVersion", {"hipfftGetVersion", CONV_MATH_FUNC, API_FFT}},
|
|
{"cufftGetProperty", {"hipfftGetProperty", CONV_MATH_FUNC, API_FFT, HIP_UNSUPPORTED}},
|
|
};
|
|
|
|
const std::map<llvm::StringRef, hipCounter>& CUDA_RENAMES_MAP() {
|
|
static std::map<llvm::StringRef, hipCounter> ret;
|
|
if (!ret.empty()) {
|
|
return ret;
|
|
}
|
|
// First run, so compute the union map.
|
|
ret = CUDA_IDENTIFIER_MAP;
|
|
ret.insert(CUDA_TYPE_NAME_MAP.begin(), CUDA_TYPE_NAME_MAP.end());
|
|
return ret;
|
|
};
|