Maneesh Gupta
4582 строки
262 KiB
C++
4582 строки
262 KiB
C++
#include "CUDA2HipMap.h"
|
|
|
|
/// Maps the names of CUDA types to the corresponding hip types.
|
|
const std::map<llvm::StringRef, hipCounter> CUDA_TYPE_NAME_MAP{
|
|
// Error codes and return types
|
|
{"CUresult", {"hipError_t", CONV_TYPE, API_DRIVER}},
|
|
// {"cudaError_enum", {"hipError_t", CONV_TYPE, API_DRIVER}},
|
|
{"cudaError_t", {"hipError_t", CONV_TYPE, API_RUNTIME}},
|
|
{"cudaError", {"hipError_t", CONV_TYPE, API_RUNTIME}},
|
|
|
|
///////////////////////////// CUDA DRIVER API /////////////////////////////
|
|
{"CUDA_ARRAY3D_DESCRIPTOR", {"HIP_ARRAY3D_DESCRIPTOR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_ARRAY_DESCRIPTOR", {"HIP_ARRAY_DESCRIPTOR", CONV_TYPE, API_DRIVER}},
|
|
{"CUDA_MEMCPY2D", {"hip_Memcpy2D", CONV_TYPE, API_DRIVER}},
|
|
{"CUDA_MEMCPY3D", {"HIP_MEMCPY3D", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_MEMCPY3D_PEER", {"HIP_MEMCPY3D_PEER", 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", {"HIP_RESOURCE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUDA_RESOURCE_VIEW_DESC", {"HIP_RESOURCE_VIEW_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUipcEventHandle", {"hipIpcEventHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUipcMemHandle", {"hipIpcMemHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUaddress_mode", {"hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUarray_cubemap_face", {"hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUarray_format", {"hipArray_format", CONV_TYPE, API_DRIVER}},
|
|
{"CUcomputemode",
|
|
{"hipComputemode", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaComputeMode)
|
|
{"CUmem_advise",
|
|
{"hipMemAdvise", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaComputeMode)
|
|
{"CUmem_range_attribute",
|
|
{"hipMemRangeAttribute", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_RUNTIME ANALOGUE (cudaMemRangeAttribute)
|
|
{"CUctx_flags", {"hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// NOTE: CUdevice might be changed to typedef int in the future.
|
|
{"CUdevice", {"hipDevice_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUdevice_attribute_enum",
|
|
{"hipDeviceAttribute_t", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaDeviceAttr)
|
|
{"CUdevice_attribute",
|
|
{"hipDeviceAttribute_t", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaDeviceAttr)
|
|
{"CUdeviceptr", {"hipDeviceptr_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// CUDA: "The types::CUarray and struct ::cudaArray * represent the same data type and may be
|
|
// used interchangeably by casting the two types between each other."
|
|
// typedef struct cudaArray *cudaArray_t;
|
|
// typedef struct CUarray_st *CUarray;
|
|
{"CUarray_st", {"hipArray", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaArray)
|
|
{"CUarray", {"hipArray *", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaArray_t)
|
|
|
|
{"CUdevprop_st", {"hipDeviceProp_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUdevprop", {"hipDeviceProp_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// pointer to CUfunc_st
|
|
{"CUfunction", {"hipFunction_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// TODO: move "typedef struct ihipModuleSymbol_t *hipFunction_t;" from hcc_details to HIP
|
|
// typedef struct CUfunc_st *CUfunction;
|
|
// {"CUfunc_st", {"ihipModuleSymbol_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// typedef struct CUgraphicsResource_st *CUgraphicsResource;
|
|
{"CUgraphicsResource", {"hipGraphicsResource_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// typedef struct CUmipmappedArray_st *CUmipmappedArray;
|
|
{"CUmipmappedArray", {"hipMipmappedArray_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUfunction_attribute", {"hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUfunction_attribute_enum", {"hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUgraphicsMapResourceFlags",
|
|
{"hipGraphicsMapFlags", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsMapFlags)
|
|
{"CUgraphicsMapResourceFlags_enum",
|
|
{"hipGraphicsMapFlags", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsMapFlags)
|
|
|
|
{"CUgraphicsRegisterFlags",
|
|
{"hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsRegisterFlags)
|
|
{"CUgraphicsRegisterFlags_enum",
|
|
{"hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGraphicsRegisterFlags)
|
|
|
|
{"CUoccupancy_flags",
|
|
{"hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUoccupancy_flags_enum",
|
|
{"hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
|
|
{"CUfunc_cache_enum",
|
|
{"hipFuncCache", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaFuncCache)
|
|
{"CUfunc_cache",
|
|
{"hipFuncCache", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaFuncCache)
|
|
|
|
{"CUipcMem_flags",
|
|
{"hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUipcMem_flags_enum",
|
|
{"hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
|
|
{"CUjit_cacheMode",
|
|
{"hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUjit_cacheMode_enum", {"hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUjit_fallback",
|
|
{"hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUjit_fallback_enum", {"hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUjit_option", {"hipJitOption", CONV_JIT, API_DRIVER}}, // API_Runtime ANALOGUE (no)
|
|
{"CUjit_option_enum", {"hipJitOption", CONV_JIT, API_DRIVER}},
|
|
|
|
{"CUjit_target",
|
|
{"hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUjit_target_enum", {"hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUjitInputType",
|
|
{"hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUjitInputType_enum", {"hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUlimit", {"hipLimit_t", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaLimit)
|
|
{"CUlimit_enum", {"hipLimit_t", CONV_TYPE, API_DRIVER}}, // API_Runtime ANALOGUE (cudaLimit)
|
|
|
|
{"CUmemAttach_flags",
|
|
{"hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CUmemAttach_flags_enum",
|
|
{"hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
|
|
{"CUmemorytype",
|
|
{"hipMemType_t", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no - cudaMemoryType is not an analogue)
|
|
{"CUmemorytype_enum",
|
|
{"hipMemType_t", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no - cudaMemoryType is not an analogue)
|
|
|
|
{"CUresourcetype",
|
|
{"hipResourceType", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaResourceType)
|
|
{"CUresourcetype_enum",
|
|
{"hipResourceType", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaResourceType)
|
|
|
|
{"CUresourceViewFormat",
|
|
{"hipResourceViewFormat", CONV_TEX,
|
|
API_DRIVER}}, // API_Runtime ANALOGUE (cudaResourceViewFormat)
|
|
{"CUresourceViewFormat_enum",
|
|
{"hipResourceViewFormat", CONV_TEX,
|
|
API_DRIVER}}, // API_Runtime ANALOGUE (cudaResourceViewFormat)
|
|
|
|
{"CUsharedconfig", {"hipSharedMemConfig", CONV_TYPE, API_DRIVER}},
|
|
{"CUsharedconfig_enum", {"hipSharedMemConfig", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUcontext", {"hipCtx_t", CONV_TYPE, API_DRIVER}},
|
|
// TODO: move "typedef struct ihipCtx_t *hipCtx_t;" from hcc_details to HIP
|
|
// typedef struct CUctx_st *CUcontext;
|
|
// {"CUctx_st", {"ihipCtx_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUmodule", {"hipModule_t", CONV_TYPE, API_DRIVER}},
|
|
// TODO: move "typedef struct ihipModule_t *hipModule_t;" from hcc_details to HIP
|
|
// typedef struct CUmod_st *CUmodule;
|
|
// {"CUmod_st", {"ihipModule_t", CONV_TYPE, API_DRIVER}},
|
|
{"CUstream", {"hipStream_t", CONV_TYPE, API_DRIVER}},
|
|
// TODO: move "typedef struct ihipStream_t *hipStream_t;" from hcc_details to HIP
|
|
// typedef struct CUstream_st *CUstream;
|
|
// {"CUstream_st", {"ihipStream_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
// typedef void (*hipStreamCallback_t) (hipStream_t stream, hipError_t status, void*
|
|
// userData);
|
|
// typedef void (CUDA_CB *CUstreamCallback) (CUstream hStream, CUresult status, void* userData)
|
|
{"CUstreamCallback", {"hipStreamCallback_t", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUsurfObject", {"hipSurfaceObject", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// typedef struct CUsurfref_st *CUsurfref;
|
|
{"CUsurfref", {"hipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// {"CUsurfref_st", {"ihipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CUtexObject", {"hipTextureObject_t", CONV_TYPE, API_DRIVER}},
|
|
// typedef struct CUtexref_st *CUtexref;
|
|
{"CUtexref", {"textureReference", CONV_TYPE, API_DRIVER}},
|
|
// {"CUtexref_st", {"ihipTextureReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// Stream Flags enum
|
|
{"CUstream_flags", {"hipStreamFlags", CONV_TYPE, API_DRIVER}},
|
|
// TODO: ..?
|
|
// {"CUstream_flags_enum", {"hipStreamFlags", CONV_TYPE, API_DRIVER}},
|
|
|
|
{"CUstreamWaitValue_flags",
|
|
{"hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// TODO: ..?
|
|
// {"CUstreamWaitValue_flags_enum", {"hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
{"CUstreamWriteValue_flags",
|
|
{"hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// {"CUstreamWriteValue_flags", {"hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
{"CUstreamBatchMemOpType", {"hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// {"CUstreamBatchMemOpType_enum", {"hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
// P2P Attributes
|
|
{"CUdevice_P2PAttribute",
|
|
{"hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaDeviceP2PAttr)
|
|
// {"CUdevice_P2PAttribute_enum", {"hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
// pointer to CUevent_st
|
|
{"CUevent", {"hipEvent_t", CONV_TYPE, API_DRIVER}},
|
|
// ToDo:
|
|
// {"CUevent_st", {"XXXX", CONV_TYPE, API_DRIVER}},
|
|
// Event Flags
|
|
{"CUevent_flags", {"hipEventFlags", CONV_EVENT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
// ToDo:
|
|
// {"CUevent_flags_enum", {"hipEventFlags", CONV_EVENT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUfilter_mode",
|
|
{"hipTextureFilterMode", CONV_TEX,
|
|
API_DRIVER}}, // API_Runtime ANALOGUE (cudaTextureFilterMode)
|
|
// ToDo:
|
|
// {"CUfilter_mode", {"CUfilter_mode_enum", CONV_TEX, API_DRIVER}}, // API_Runtime
|
|
// ANALOGUE (cudaTextureFilterMode)
|
|
|
|
{"CUGLDeviceList",
|
|
{"hipGLDeviceList", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLDeviceList)
|
|
// {"CUGLDeviceList_enum", {"hipGLDeviceList", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUGLmap_flags",
|
|
{"hipGLMapFlags", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaGLMapFlags)
|
|
// {"CUGLmap_flags_enum", {"hipGLMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d9DeviceList",
|
|
{"hipD3D9DeviceList", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9DeviceList)
|
|
// {"CUd3d9DeviceList_enum", {"hipD3D9DeviceList", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d9map_flags",
|
|
{"hipD3D9MapFlags", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9MapFlags)
|
|
// {"CUd3d9map_flags_enum", {"hipD3D9MapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d9register_flags",
|
|
{"hipD3D9RegisterFlags", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D9RegisterFlags)
|
|
// {"CUd3d9register_flags_enum", {"hipD3D9RegisterFlags", CONV_D3D9, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d10DeviceList",
|
|
{"hipd3d10DeviceList", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10DeviceList)
|
|
// {"CUd3d10DeviceList_enum", {"hipD3D10DeviceList", CONV_D3D10, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d10map_flags",
|
|
{"hipD3D10MapFlags", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10MapFlags)
|
|
// {"CUd3d10map_flags_enum", {"hipD3D10MapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d10register_flags",
|
|
{"hipD3D10RegisterFlags", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D10RegisterFlags)
|
|
// {"CUd3d10register_flags_enum", {"hipD3D10RegisterFlags", CONV_D3D10, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
{"CUd3d11DeviceList",
|
|
{"hipd3d11DeviceList", CONV_D3D11, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaD3D11DeviceList)
|
|
// {"CUd3d11DeviceList_enum", {"hipD3D11DeviceList", CONV_D3D11, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
|
|
// EGL Interoperability
|
|
{"CUeglStreamConnection_st",
|
|
{"hipEglStreamConnection", CONV_EGL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEglStreamConnection)
|
|
{"CUeglStreamConnection",
|
|
{"hipEglStreamConnection", CONV_EGL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (cudaEglStreamConnection)
|
|
|
|
/////////////////////////////// CUDA RT API ///////////////////////////////
|
|
{"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,
|
|
HIP_UNSUPPORTED}}, // 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}},
|
|
|
|
// 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, HIP_UNSUPPORTED}},
|
|
|
|
{"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)
|
|
|
|
///////////////////////////// cuBLAS /////////////////////////////
|
|
{"cublasHandle_t", {"hipblasHandle_t", CONV_TYPE, API_BLAS}},
|
|
// TODO: dereferencing: typedef struct cublasContext *cublasHandle_t;
|
|
// {"cublasContext", {"hipblasHandle_t", CONV_TYPE, API_BLAS}},
|
|
|
|
{"cublasOperation_t", {"hipblasOperation_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasStatus_t", {"hipblasStatus_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasFillMode_t", {"hipblasFillMode_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasDiagType_t", {"hipblasDiagType_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasSideMode_t", {"hipblasSideMode_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasPointerMode_t", {"hipblasPointerMode_t", CONV_TYPE, API_BLAS}},
|
|
{"cublasAtomicsMode_t", {"hipblasAtomicsMode_t", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"cublasDataType_t", {"hipblasDataType_t", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
///////////////////////////// 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}},
|
|
};
|
|
|
|
/// 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}},
|
|
{"cuComplex.h", {"hip/hip_complex.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}},
|
|
|
|
// HIP includes
|
|
// TODO: uncomment this when hip/cudacommon.h will be renamed to hip/hipcommon.h
|
|
// {"cudacommon.h", {"hipcommon.h", CONV_INCLUDE, API_RUNTIME}},
|
|
};
|
|
|
|
/// All other identifiers: function and macro names.
|
|
const std::map<llvm::StringRef, hipCounter> CUDA_IDENTIFIER_MAP{
|
|
// Defines
|
|
{"__CUDACC__", {"__HIPCC__", CONV_DEF, API_RUNTIME}},
|
|
|
|
// CUDA Driver API error codes only
|
|
{"CUDA_ERROR_INVALID_CONTEXT", {"hipErrorInvalidContext", CONV_TYPE, API_DRIVER}}, // 201
|
|
{"CUDA_ERROR_CONTEXT_ALREADY_CURRENT",
|
|
{"hipErrorContextAlreadyCurrent", CONV_TYPE, API_DRIVER}}, // 202
|
|
{"CUDA_ERROR_ARRAY_IS_MAPPED", {"hipErrorArrayIsMapped", CONV_TYPE, API_DRIVER}}, // 207
|
|
{"CUDA_ERROR_ALREADY_MAPPED", {"hipErrorAlreadyMapped", CONV_TYPE, API_DRIVER}}, // 208
|
|
{"CUDA_ERROR_ALREADY_ACQUIRED", {"hipErrorAlreadyAcquired", CONV_TYPE, API_DRIVER}}, // 210
|
|
{"CUDA_ERROR_NOT_MAPPED", {"hipErrorNotMapped", CONV_TYPE, API_DRIVER}}, // 211
|
|
{"CUDA_ERROR_NOT_MAPPED_AS_ARRAY", {"hipErrorNotMappedAsArray", CONV_TYPE, API_DRIVER}}, // 212
|
|
{"CUDA_ERROR_NOT_MAPPED_AS_POINTER",
|
|
{"hipErrorNotMappedAsPointer", CONV_TYPE, API_DRIVER}}, // 213
|
|
{"CUDA_ERROR_CONTEXT_ALREADY_IN_USE",
|
|
{"hipErrorContextAlreadyInUse", CONV_TYPE, API_DRIVER}}, // 216
|
|
{"CUDA_ERROR_INVALID_SOURCE", {"hipErrorInvalidSource", CONV_TYPE, API_DRIVER}}, // 300
|
|
{"CUDA_ERROR_FILE_NOT_FOUND", {"hipErrorFileNotFound", CONV_TYPE, API_DRIVER}}, // 301
|
|
{"CUDA_ERROR_NOT_FOUND", {"hipErrorNotFound", CONV_TYPE, API_DRIVER}}, // 500
|
|
{"CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING",
|
|
{"hipErrorLaunchIncompatibleTexturing", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 703
|
|
{"CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE",
|
|
{"hipErrorPrimaryContextActive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 708
|
|
{"CUDA_ERROR_CONTEXT_IS_DESTROYED",
|
|
{"hipErrorContextIsDestroyed", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 709
|
|
{"CUDA_ERROR_NOT_PERMITTED",
|
|
{"hipErrorNotPermitted", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 800
|
|
{"CUDA_ERROR_NOT_SUPPORTED",
|
|
{"hipErrorNotSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 801
|
|
|
|
// CUDA RT API error code only
|
|
{"cudaErrorMissingConfiguration",
|
|
{"hipErrorMissingConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 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}}, // 0x7f
|
|
// Deprecated as of CUDA 4.1
|
|
{"cudaErrorApiFailureBase",
|
|
{"hipErrorApiFailureBase", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 10000
|
|
|
|
{"CUDA_SUCCESS", {"hipSuccess", CONV_TYPE, API_DRIVER}}, // 0
|
|
{"cudaSuccess", {"hipSuccess", CONV_TYPE, API_RUNTIME}}, // 0
|
|
|
|
{"CUDA_ERROR_INVALID_VALUE", {"hipErrorInvalidValue", CONV_TYPE, API_DRIVER}}, // 1
|
|
{"cudaErrorInvalidValue", {"hipErrorInvalidValue", CONV_TYPE, API_RUNTIME}}, // 11
|
|
|
|
{"CUDA_ERROR_OUT_OF_MEMORY", {"hipErrorMemoryAllocation", CONV_TYPE, API_DRIVER}}, // 2
|
|
{"cudaErrorMemoryAllocation", {"hipErrorMemoryAllocation", CONV_TYPE, API_RUNTIME}}, // 2
|
|
|
|
{"CUDA_ERROR_NOT_INITIALIZED", {"hipErrorNotInitialized", CONV_TYPE, API_DRIVER}}, // 3
|
|
{"cudaErrorInitializationError", {"hipErrorInitializationError", CONV_TYPE, API_RUNTIME}}, // 3
|
|
|
|
{"CUDA_ERROR_DEINITIALIZED", {"hipErrorDeinitialized", CONV_TYPE, API_DRIVER}}, // 4
|
|
// TODO: double check, that these errors match
|
|
{"cudaErrorCudartUnloading",
|
|
{"hipErrorDeinitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 29
|
|
|
|
{"CUDA_ERROR_PROFILER_DISABLED", {"hipErrorProfilerDisabled", CONV_TYPE, API_DRIVER}}, // 5
|
|
{"cudaErrorProfilerDisabled",
|
|
{"hipErrorProfilerDisabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 55
|
|
|
|
{"CUDA_ERROR_PROFILER_NOT_INITIALIZED",
|
|
{"hipErrorProfilerNotInitialized", CONV_TYPE, API_DRIVER}}, // 6
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerNotInitialized",
|
|
{"hipErrorProfilerNotInitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 56
|
|
|
|
{"CUDA_ERROR_PROFILER_ALREADY_STARTED",
|
|
{"hipErrorProfilerAlreadyStarted", CONV_TYPE, API_DRIVER}}, // 7
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerAlreadyStarted",
|
|
{"hipErrorProfilerAlreadyStarted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 57
|
|
|
|
{"CUDA_ERROR_PROFILER_ALREADY_STOPPED",
|
|
{"hipErrorProfilerAlreadyStopped", CONV_TYPE, API_DRIVER}}, // 8
|
|
// Deprecated as of CUDA 5.0
|
|
{"cudaErrorProfilerAlreadyStopped",
|
|
{"hipErrorProfilerAlreadyStopped", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 58
|
|
|
|
{"CUDA_ERROR_NO_DEVICE", {"hipErrorNoDevice", CONV_TYPE, API_DRIVER}}, // 100
|
|
{"cudaErrorNoDevice", {"hipErrorNoDevice", CONV_TYPE, API_RUNTIME}}, // 38
|
|
|
|
{"CUDA_ERROR_INVALID_DEVICE", {"hipErrorInvalidDevice", CONV_TYPE, API_DRIVER}}, // 101
|
|
{"cudaErrorInvalidDevice", {"hipErrorInvalidDevice", CONV_TYPE, API_RUNTIME}}, // 10
|
|
|
|
{"CUDA_ERROR_INVALID_IMAGE", {"hipErrorInvalidImage", CONV_TYPE, API_DRIVER}}, // 200
|
|
{"cudaErrorInvalidKernelImage",
|
|
{"hipErrorInvalidImage", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 47
|
|
|
|
{"CUDA_ERROR_MAP_FAILED", {"hipErrorMapFailed", CONV_TYPE, API_DRIVER}}, // 205
|
|
// TODO: double check, that these errors match
|
|
{"cudaErrorMapBufferObjectFailed",
|
|
{"hipErrorMapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 14
|
|
|
|
{"CUDA_ERROR_UNMAP_FAILED", {"hipErrorUnmapFailed", CONV_TYPE, API_DRIVER}}, // 206
|
|
// TODO: double check, that these errors match
|
|
{"cudaErrorUnmapBufferObjectFailed",
|
|
{"hipErrorUnmapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 15
|
|
|
|
{"CUDA_ERROR_NO_BINARY_FOR_GPU", {"hipErrorNoBinaryForGpu", CONV_TYPE, API_DRIVER}}, // 209
|
|
{"cudaErrorNoKernelImageForDevice",
|
|
{"hipErrorNoBinaryForGpu", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 48
|
|
|
|
{"CUDA_ERROR_ECC_UNCORRECTABLE", {"hipErrorECCNotCorrectable", CONV_TYPE, API_DRIVER}}, // 214
|
|
{"cudaErrorECCUncorrectable",
|
|
{"hipErrorECCNotCorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 39
|
|
|
|
{"CUDA_ERROR_UNSUPPORTED_LIMIT", {"hipErrorUnsupportedLimit", CONV_TYPE, API_DRIVER}}, // 215
|
|
{"cudaErrorUnsupportedLimit",
|
|
{"hipErrorUnsupportedLimit", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 42
|
|
|
|
{"CUDA_ERROR_PEER_ACCESS_UNSUPPORTED",
|
|
{"hipErrorPeerAccessUnsupported", CONV_TYPE, API_DRIVER}}, // 217
|
|
{"cudaErrorPeerAccessUnsupported",
|
|
{"hipErrorPeerAccessUnsupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 64
|
|
|
|
{"CUDA_ERROR_INVALID_PTX", {"hipErrorInvalidKernelFile", CONV_TYPE, API_DRIVER}}, // 218
|
|
{"cudaErrorInvalidPtx",
|
|
{"hipErrorInvalidKernelFile", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 78
|
|
|
|
{"CUDA_ERROR_INVALID_GRAPHICS_CONTEXT",
|
|
{"hipErrorInvalidGraphicsContext", CONV_TYPE, API_DRIVER}}, // 219
|
|
{"cudaErrorInvalidGraphicsContext",
|
|
{"hipErrorInvalidGraphicsContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 79
|
|
|
|
{"CUDA_ERROR_NVLINK_UNCORRECTABLE",
|
|
{"hipErrorNvlinkUncorrectable", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 220
|
|
{"cudaErrorNvlinkUncorrectable",
|
|
{"hipErrorNvlinkUncorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 80
|
|
|
|
{"CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND",
|
|
{"hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_DRIVER}}, // 302
|
|
{"cudaErrorSharedObjectSymbolNotFound",
|
|
{"hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 40
|
|
|
|
{"CUDA_ERROR_SHARED_OBJECT_INIT_FAILED",
|
|
{"hipErrorSharedObjectInitFailed", CONV_TYPE, API_DRIVER}}, // 303
|
|
{"cudaErrorSharedObjectInitFailed",
|
|
{"hipErrorSharedObjectInitFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 41
|
|
|
|
{"CUDA_ERROR_OPERATING_SYSTEM", {"hipErrorOperatingSystem", CONV_TYPE, API_DRIVER}}, // 304
|
|
{"cudaErrorOperatingSystem",
|
|
{"hipErrorOperatingSystem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 63
|
|
|
|
{"CUDA_ERROR_INVALID_HANDLE", {"hipErrorInvalidResourceHandle", CONV_TYPE, API_DRIVER}}, // 400
|
|
{"cudaErrorInvalidResourceHandle",
|
|
{"hipErrorInvalidResourceHandle", CONV_TYPE, API_RUNTIME}}, // 33
|
|
|
|
{"CUDA_ERROR_NOT_READY", {"hipErrorNotReady", CONV_TYPE, API_DRIVER}}, // 600
|
|
{"cudaErrorNotReady", {"hipErrorNotReady", CONV_TYPE, API_RUNTIME}}, // 34
|
|
|
|
{"CUDA_ERROR_ILLEGAL_ADDRESS", {"hipErrorIllegalAddress", CONV_TYPE, API_DRIVER}}, // 700
|
|
{"cudaErrorIllegalAddress",
|
|
{"hipErrorIllegalAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 77
|
|
|
|
{"CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES",
|
|
{"hipErrorLaunchOutOfResources", CONV_TYPE, API_DRIVER}}, // 701
|
|
{"cudaErrorLaunchOutOfResources",
|
|
{"hipErrorLaunchOutOfResources", CONV_TYPE, API_RUNTIME}}, // 7
|
|
|
|
{"CUDA_ERROR_LAUNCH_TIMEOUT", {"hipErrorLaunchTimeOut", CONV_TYPE, API_DRIVER}}, // 702
|
|
{"cudaErrorLaunchTimeout",
|
|
{"hipErrorLaunchTimeOut", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 6
|
|
|
|
{"CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED",
|
|
{"hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_DRIVER}}, // 704
|
|
{"cudaErrorPeerAccessAlreadyEnabled",
|
|
{"hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_RUNTIME}}, // 50
|
|
|
|
{"CUDA_ERROR_PEER_ACCESS_NOT_ENABLED",
|
|
{"hipErrorPeerAccessNotEnabled", CONV_TYPE, API_DRIVER}}, // 705
|
|
{"cudaErrorPeerAccessNotEnabled",
|
|
{"hipErrorPeerAccessNotEnabled", CONV_TYPE, API_RUNTIME}}, // 51
|
|
|
|
{"CUDA_ERROR_ASSERT", {"hipErrorAssert", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 710
|
|
{"cudaErrorAssert", {"hipErrorAssert", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 59
|
|
|
|
{"CUDA_ERROR_TOO_MANY_PEERS",
|
|
{"hipErrorTooManyPeers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 711
|
|
{"cudaErrorTooManyPeers",
|
|
{"hipErrorTooManyPeers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 60
|
|
|
|
{"CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED",
|
|
{"hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_DRIVER}}, // 712
|
|
{"cudaErrorHostMemoryAlreadyRegistered",
|
|
{"hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_RUNTIME}}, // 61
|
|
|
|
{"CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED",
|
|
{"hipErrorHostMemoryNotRegistered", CONV_TYPE, API_DRIVER}}, // 713
|
|
{"cudaErrorHostMemoryNotRegistered",
|
|
{"hipErrorHostMemoryNotRegistered", CONV_TYPE, API_RUNTIME}}, // 62
|
|
|
|
{"CUDA_ERROR_HARDWARE_STACK_ERROR",
|
|
{"hipErrorHardwareStackError", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 714
|
|
{"cudaErrorHardwareStackError",
|
|
{"hipErrorHardwareStackError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 72
|
|
|
|
{"CUDA_ERROR_ILLEGAL_INSTRUCTION",
|
|
{"hipErrorIllegalInstruction", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 715
|
|
{"cudaErrorIllegalInstruction",
|
|
{"hipErrorIllegalInstruction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 73
|
|
|
|
{"CUDA_ERROR_MISALIGNED_ADDRESS",
|
|
{"hipErrorMisalignedAddress", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 716
|
|
{"cudaErrorMisalignedAddress",
|
|
{"hipErrorMisalignedAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 74
|
|
|
|
{"CUDA_ERROR_INVALID_ADDRESS_SPACE",
|
|
{"hipErrorInvalidAddressSpace", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 717
|
|
{"cudaErrorInvalidAddressSpace",
|
|
{"hipErrorInvalidAddressSpace", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 75
|
|
|
|
{"CUDA_ERROR_INVALID_PC",
|
|
{"hipErrorInvalidPc", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 718
|
|
{"cudaErrorInvalidPc", {"hipErrorInvalidPc", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 76
|
|
|
|
{"CUDA_ERROR_LAUNCH_FAILED",
|
|
{"hipErrorLaunchFailure", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 719
|
|
{"cudaErrorLaunchFailure",
|
|
{"hipErrorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}}, // 4
|
|
|
|
{"CUDA_ERROR_UNKNOWN", {"hipErrorUnknown", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 999
|
|
{"cudaErrorUnknown", {"hipErrorUnknown", CONV_TYPE, API_RUNTIME}}, // 30
|
|
|
|
///////////////////////////// CUDA DRIVER API /////////////////////////////
|
|
// CUaddress_mode enum
|
|
{"CU_TR_ADDRESS_MODE_WRAP",
|
|
{"HIP_TR_ADDRESS_MODE_WRAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0
|
|
{"CU_TR_ADDRESS_MODE_CLAMP",
|
|
{"HIP_TR_ADDRESS_MODE_CLAMP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
{"CU_TR_ADDRESS_MODE_MIRROR",
|
|
{"HIP_TR_ADDRESS_MODE_MIRROR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
{"CU_TR_ADDRESS_MODE_BORDER",
|
|
{"HIP_TR_ADDRESS_MODE_BORDER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
|
|
// CUarray_cubemap_face enum
|
|
{"CU_CUBEMAP_FACE_POSITIVE_X",
|
|
{"HIP_CUBEMAP_FACE_POSITIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_X",
|
|
{"HIP_CUBEMAP_FACE_NEGATIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_CUBEMAP_FACE_POSITIVE_Y",
|
|
{"HIP_CUBEMAP_FACE_POSITIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_Y",
|
|
{"HIP_CUBEMAP_FACE_NEGATIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x03
|
|
{"CU_CUBEMAP_FACE_POSITIVE_Z",
|
|
{"HIP_CUBEMAP_FACE_POSITIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CUBEMAP_FACE_NEGATIVE_Z",
|
|
{"HIP_CUBEMAP_FACE_NEGATIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x05
|
|
|
|
// CUarray_format enum
|
|
{"CU_AD_FORMAT_UNSIGNED_INT8", {"HIP_AD_FORMAT_UNSIGNED_INT8", CONV_TYPE, API_DRIVER}}, // 0x01
|
|
{"CU_AD_FORMAT_UNSIGNED_INT16",
|
|
{"HIP_AD_FORMAT_UNSIGNED_INT16", CONV_TYPE, API_DRIVER}}, // 0x02
|
|
{"CU_AD_FORMAT_UNSIGNED_INT32",
|
|
{"HIP_AD_FORMAT_UNSIGNED_INT32", CONV_TYPE, API_DRIVER}}, // 0x03
|
|
{"CU_AD_FORMAT_SIGNED_INT8", {"HIP_AD_FORMAT_SIGNED_INT8", CONV_TYPE, API_DRIVER}}, // 0x08
|
|
{"CU_AD_FORMAT_SIGNED_INT16", {"HIP_AD_FORMAT_SIGNED_INT16", CONV_TYPE, API_DRIVER}}, // 0x09
|
|
{"CU_AD_FORMAT_SIGNED_INT32", {"HIP_AD_FORMAT_SIGNED_INT32", CONV_TYPE, API_DRIVER}}, // 0x0a
|
|
{"CU_AD_FORMAT_HALF", {"HIP_AD_FORMAT_HALF", CONV_TYPE, API_DRIVER}}, // 0x10
|
|
{"CU_AD_FORMAT_FLOAT", {"HIP_AD_FORMAT_FLOAT", CONV_TYPE, API_DRIVER}}, // 0x20
|
|
|
|
// CUcomputemode enum
|
|
{"CU_COMPUTEMODE_DEFAULT",
|
|
{"hipComputeModeDefault", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0 // API_RUNTIME ANALOGUE (cudaComputeModeDefault = 0)
|
|
{"CU_COMPUTEMODE_EXCLUSIVE",
|
|
{"hipComputeModeExclusive", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_RUNTIME ANALOGUE (cudaComputeModeExclusive = 1)
|
|
{"CU_COMPUTEMODE_PROHIBITED",
|
|
{"hipComputeModeProhibited", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 2 // API_RUNTIME ANALOGUE (cudaComputeModeProhibited = 2)
|
|
{"CU_COMPUTEMODE_EXCLUSIVE_PROCESS",
|
|
{"hipComputeModeExclusiveProcess", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 3 // API_RUNTIME ANALOGUE (cudaComputeModeExclusiveProcess = 3)
|
|
|
|
// Memory advise values
|
|
// {"CUmem_advise_enum", {"hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_MEM_ADVISE_SET_READ_MOSTLY",
|
|
{"hipMemAdviseSetReadMostly", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_RUNTIME ANALOGUE (cudaMemAdviseSetReadMostly = 1)
|
|
{"CU_MEM_ADVISE_UNSET_READ_MOSTLY",
|
|
{"hipMemAdviseUnsetReadMostly", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 2 // API_RUNTIME ANALOGUE (cudaMemAdviseUnsetReadMostly = 2)
|
|
{"CU_MEM_ADVISE_SET_PREFERRED_LOCATION",
|
|
{"hipMemAdviseSetPreferredLocation", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 3 // API_RUNTIME ANALOGUE (cudaMemAdviseSetPreferredLocation = 3)
|
|
{"CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION",
|
|
{"hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 4 // API_RUNTIME ANALOGUE (cudaMemAdviseUnsetPreferredLocation = 4)
|
|
{"CU_MEM_ADVISE_SET_ACCESSED_BY",
|
|
{"hipMemAdviseSetAccessedBy", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 5 // API_RUNTIME ANALOGUE (cudaMemAdviseSetAccessedBy = 5)
|
|
{"CU_MEM_ADVISE_UNSET_ACCESSED_BY",
|
|
{"hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 6 // API_RUNTIME ANALOGUE (cudaMemAdviseUnsetAccessedBy = 6)
|
|
|
|
// CUmem_range_attribute
|
|
// {"CUmem_range_attribute_enum", {"hipMemRangeAttribute", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}},
|
|
{"CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY",
|
|
{"hipMemRangeAttributeReadMostly", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_RUNTIME ANALOGUE (cudaMemRangeAttributeReadMostly = 1)
|
|
{"CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION",
|
|
{"hipMemRangeAttributePreferredLocation", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 2 // API_RUNTIME ANALOGUE (cudaMemRangeAttributePreferredLocation = 2)
|
|
{"CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY",
|
|
{"hipMemRangeAttributeAccessedBy", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 3 // API_RUNTIME ANALOGUE (cudaMemRangeAttributeAccessedBy = 3)
|
|
{"CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION",
|
|
{"hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 4 // API_RUNTIME ANALOGUE (cudaMemRangeAttributeLastPrefetchLocation =
|
|
// 4)
|
|
|
|
// CUctx_flags enum
|
|
{"CU_CTX_SCHED_AUTO", {"HIP_CTX_SCHED_AUTO", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x00
|
|
{"CU_CTX_SCHED_SPIN", {"HIP_CTX_SCHED_SPIN", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_CTX_SCHED_YIELD",
|
|
{"HIP_CTX_SCHED_YIELD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_CTX_SCHED_BLOCKING_SYNC",
|
|
{"HIP_CTX_SCHED_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CTX_BLOCKING_SYNC",
|
|
{"HIP_CTX_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_CTX_SCHED_MASK", {"HIP_CTX_SCHED_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x07
|
|
{"CU_CTX_MAP_HOST", {"HIP_CTX_MAP_HOST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
{"CU_CTX_LMEM_RESIZE_TO_MAX",
|
|
{"HIP_CTX_LMEM_RESIZE_TO_MAX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
{"CU_CTX_FLAGS_MASK", {"HIP_CTX_FLAGS_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1f
|
|
|
|
// Defines
|
|
{"CU_LAUNCH_PARAM_BUFFER_POINTER",
|
|
{"HIP_LAUNCH_PARAM_BUFFER_POINTER", CONV_TYPE, API_DRIVER}}, // ((void*)0x01)
|
|
{"CU_LAUNCH_PARAM_BUFFER_SIZE",
|
|
{"HIP_LAUNCH_PARAM_BUFFER_SIZE", CONV_TYPE, API_DRIVER}}, // ((void*)0x02)
|
|
{"CU_LAUNCH_PARAM_END", {"HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER}}, // ((void*)0x00)
|
|
{"CU_IPC_HANDLE_SIZE", {"HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 64
|
|
{"CU_MEMHOSTALLOC_DEVICEMAP",
|
|
{"HIP_MEMHOSTALLOC_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_MEMHOSTALLOC_PORTABLE",
|
|
{"HIP_MEMHOSTALLOC_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_MEMHOSTALLOC_WRITECOMBINED",
|
|
{"HIP_MEMHOSTALLOC_WRITECOMBINED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_MEMHOSTREGISTER_DEVICEMAP",
|
|
{"HIP_MEMHOSTREGISTER_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_MEMHOSTREGISTER_IOMEMORY",
|
|
{"HIP_MEMHOSTREGISTER_IOMEMORY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CU_MEMHOSTREGISTER_PORTABLE",
|
|
{"HIP_MEMHOSTREGISTER_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_PARAM_TR_DEFAULT",
|
|
{"HIP_PARAM_TR_DEFAULT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // -1
|
|
{"CU_STREAM_LEGACY",
|
|
{"HIP_STREAM_LEGACY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUstream)0x1)
|
|
{"CU_STREAM_PER_THREAD",
|
|
{"HIP_STREAM_PER_THREAD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // ((CUstream)0x2)
|
|
{"CU_TRSA_OVERRIDE_FORMAT",
|
|
{"HIP_TRSA_OVERRIDE_FORMAT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_TRSF_NORMALIZED_COORDINATES",
|
|
{"HIP_TRSF_NORMALIZED_COORDINATES", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CU_TRSF_READ_AS_INTEGER",
|
|
{"HIP_TRSF_READ_AS_INTEGER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CU_TRSF_SRGB", {"HIP_TRSF_SRGB", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
|
|
// Deprecated, use CUDA_ARRAY3D_LAYERED
|
|
{"CUDA_ARRAY3D_2DARRAY",
|
|
{"HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CUDA_ARRAY3D_CUBEMAP",
|
|
{"HIP_ARRAY3D_CUBEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x04
|
|
{"CUDA_ARRAY3D_DEPTH_TEXTURE",
|
|
{"HIP_ARRAY3D_DEPTH_TEXTURE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x10
|
|
{"CUDA_ARRAY3D_LAYERED",
|
|
{"HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x01
|
|
{"CUDA_ARRAY3D_SURFACE_LDST",
|
|
{"HIP_ARRAY3D_SURFACE_LDST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x02
|
|
{"CUDA_ARRAY3D_TEXTURE_GATHER",
|
|
{"HIP_ARRAY3D_TEXTURE_GATHER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x08
|
|
{"CUDA_VERSION", {"HIP_VERSION", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 7050
|
|
|
|
// CUdevice_attribute_enum values...
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK",
|
|
{"hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_Runtime ANALOGUE (cudaDevAttrMaxThreadsPerBlock = 1)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X",
|
|
{"hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 2 // API_Runtime ANALOGUE (cudaDevAttrMaxBlockDimX = 2)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y",
|
|
{"hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 3 // API_Runtime ANALOGUE (cudaDevAttrMaxBlockDimY = 3)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z",
|
|
{"hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 4 // API_Runtime ANALOGUE (cudaDevAttrMaxBlockDimZ = 4)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X",
|
|
{"hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 5 // API_Runtime ANALOGUE (cudaDevAttrMaxGridDimX =5)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y",
|
|
{"hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 6 // API_Runtime ANALOGUE (cudaDevAttrMaxGridDimY = 6)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z",
|
|
{"hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 7 // API_Runtime ANALOGUE (cudaDevAttrMaxGridDimZ - 7)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK",
|
|
{"hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 8 // API_Runtime ANALOGUE (cudaDevAttrMaxSharedMemoryPerBlock = 8)
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
|
|
{"CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK",
|
|
{"hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 8
|
|
{"CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY",
|
|
{"hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 9 // API_Runtime ANALOGUE (cudaDevAttrTotalConstantMemory = 9)
|
|
{"CU_DEVICE_ATTRIBUTE_WARP_SIZE",
|
|
{"hipDeviceAttributeWarpSize", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 10 // API_Runtime ANALOGUE (cudaDevAttrWarpSize = 10)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_PITCH",
|
|
{"hipDeviceAttributeMaxPitch", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 11 // API_Runtime ANALOGUE (cudaDevAttrMaxPitch = 11)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK",
|
|
{"hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 12 // API_Runtime ANALOGUE (cudaDevAttrMaxRegistersPerBlock = 12)
|
|
{"CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK",
|
|
{"hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 12
|
|
{"CU_DEVICE_ATTRIBUTE_CLOCK_RATE",
|
|
{"hipDeviceAttributeClockRate", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 13 // API_Runtime ANALOGUE (cudaDevAttrMaxRegistersPerBlock = 13)
|
|
{"CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT",
|
|
{"hipDeviceAttributeTextureAlignment", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 14 // API_Runtime ANALOGUE (cudaDevAttrTextureAlignment = 14)
|
|
// Deprecated. Use instead CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT
|
|
{"CU_DEVICE_ATTRIBUTE_GPU_OVERLAP",
|
|
{"hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 15 // API_Runtime ANALOGUE (cudaDevAttrGpuOverlap = 15)
|
|
{"CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT",
|
|
{"hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 16 // API_Runtime ANALOGUE (cudaDevAttrMultiProcessorCount = 16)
|
|
{"CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT",
|
|
{"hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 17 // API_Runtime ANALOGUE (cudaDevAttrKernelExecTimeout = 17)
|
|
{"CU_DEVICE_ATTRIBUTE_INTEGRATED",
|
|
{"hipDeviceAttributeIntegrated", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 18 // API_Runtime ANALOGUE (cudaDevAttrIntegrated = 18)
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY",
|
|
{"hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 19 // API_Runtime ANALOGUE (cudaDevAttrCanMapHostMemory = 19)
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_MODE",
|
|
{"hipDeviceAttributeComputeMode", CONV_TYPE,
|
|
API_DRIVER}}, // 20 // API_Runtime ANALOGUE (cudaDevAttrComputeMode = 20)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 21 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture1DWidth = 21)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 22 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DWidth = 22)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 23 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DHeight = 23)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 24 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DWidth = 24)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 25 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DHeight = 25)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH",
|
|
{"hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 26 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DDepth = 26)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 27 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredWidth = 27)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 28 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredHeight = 28)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 29 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredLayers = 29)
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 27 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredWidth = 27)
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 28 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredHeight = 28)
|
|
// Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES",
|
|
{"hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 29 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLayeredLayers = 29)
|
|
{"CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT",
|
|
{"hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 30 // API_Runtime ANALOGUE (cudaDevAttrSurfaceAlignment = 30)
|
|
{"CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS",
|
|
{"hipDeviceAttributeConcurrentKernels", CONV_TYPE,
|
|
API_DRIVER}}, // 31 // API_Runtime ANALOGUE (cudaDevAttrConcurrentKernels = 31)
|
|
{"CU_DEVICE_ATTRIBUTE_ECC_ENABLED",
|
|
{"hipDeviceAttributeEccEnabled", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 32 // API_Runtime ANALOGUE (cudaDevAttrEccEnabled = 32)
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_BUS_ID",
|
|
{"hipDeviceAttributePciBusId", CONV_TYPE,
|
|
API_DRIVER}}, // 33 // API_Runtime ANALOGUE (cudaDevAttrPciBusId = 33)
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID",
|
|
{"hipDeviceAttributePciDeviceId", CONV_TYPE,
|
|
API_DRIVER}}, // 34 // API_Runtime ANALOGUE (cudaDevAttrPciDeviceId = 34)
|
|
{"CU_DEVICE_ATTRIBUTE_TCC_DRIVER",
|
|
{"hipDeviceAttributeTccDriver", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 35 // API_Runtime ANALOGUE (cudaDevAttrTccDriver = 35)
|
|
{"CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE",
|
|
{"hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 36 // API_Runtime ANALOGUE (cudaDevAttrMemoryClockRate = 36)
|
|
{"CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH",
|
|
{"hipDeviceAttributeMemoryBusWidth", CONV_TYPE,
|
|
API_DRIVER}}, // 37 // API_Runtime ANALOGUE (cudaDevAttrGlobalMemoryBusWidth = 37)
|
|
{"CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE",
|
|
{"hipDeviceAttributeL2CacheSize", CONV_TYPE,
|
|
API_DRIVER}}, // 38 // API_Runtime ANALOGUE (cudaDevAttrL2CacheSize = 38)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR",
|
|
{"hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE,
|
|
API_DRIVER}}, // 39 // API_Runtime ANALOGUE (cudaDevAttrMaxThreadsPerMultiProcessor = 39)
|
|
{"CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT",
|
|
{"hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 40 // API_Runtime ANALOGUE (cudaDevAttrAsyncEngineCount = 40)
|
|
{"CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING",
|
|
{"hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 41 // API_Runtime ANALOGUE (cudaDevAttrUnifiedAddressing = 41)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 42 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture1DLayeredWidth = 42)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 43 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture1DLayeredLayers = 43)
|
|
// deprecated, do not use
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER",
|
|
{"hipDeviceAttributeCanTex2DGather", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 44 // API_Runtime ANALOGUE (no)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 45 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DGatherWidth = 45)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 46 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DGatherHeight = 46)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE",
|
|
{"hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 47 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DWidthAlt = 47)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE",
|
|
{"hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 48 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DHeightAlt = 48)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE",
|
|
{"hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 49 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture3DDepthAlt = 49)
|
|
{"CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID",
|
|
{"hipDeviceAttributePciDomainId", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 50 // API_Runtime ANALOGUE (cudaDevAttrPciDomainId = 50)
|
|
{"CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT",
|
|
{"hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 51 // API_Runtime ANALOGUE (cudaDevAttrTexturePitchAlignment = 51)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH",
|
|
{"hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 52 // API_Runtime ANALOGUE (cudaDevAttrMaxTextureCubemapWidth = 52)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 53 // API_Runtime ANALOGUE (cudaDevAttrMaxTextureCubemapLayeredWidth =
|
|
// 53)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 54 // API_Runtime ANALOGUE (cudaDevAttrMaxTextureCubemapLayeredLayers =
|
|
// 54)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH",
|
|
{"hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 55 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface1DWidth = 55)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH",
|
|
{"hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 56 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface2DWidth = 56)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT",
|
|
{"hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 57 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface2DHeight = 57)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH",
|
|
{"hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 58 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface3DWidth = 58)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT",
|
|
{"hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 59 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface3DHeight = 59)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH",
|
|
{"hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 60 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface3DDepth = 60)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 61 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface1DLayeredWidth = 61)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 62 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface1DLayeredLayers = 62)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 63 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface2DLayeredWidth = 63)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT",
|
|
{"hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 64 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface2DLayeredHeight = 64)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 65 // API_Runtime ANALOGUE (cudaDevAttrMaxSurface2DLayeredLayers = 65)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH",
|
|
{"hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 66 // API_Runtime ANALOGUE (cudaDevAttrMaxSurfaceCubemapWidth = 66)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH",
|
|
{"hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 67 // API_Runtime ANALOGUE (cudaDevAttrMaxSurfaceCubemapLayeredWidth =
|
|
// 67)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS",
|
|
{"hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 68 // API_Runtime ANALOGUE (cudaDevAttrMaxSurfaceCubemapLayeredLayers =
|
|
// 68)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 69 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture1DLinearWidth = 69)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 70 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLinearWidth = 70)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 71 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLinearHeight = 71)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH",
|
|
{"hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 72 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DLinearPitch = 72)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 73 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DMipmappedWidth = 73)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT",
|
|
{"hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 74 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture2DMipmappedHeight =
|
|
// 74)
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR",
|
|
{"hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE,
|
|
API_DRIVER}}, // 75 // API_Runtime ANALOGUE (cudaDevAttrComputeCapabilityMajor = 75)
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR",
|
|
{"hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE,
|
|
API_DRIVER}}, // 76 // API_Runtime ANALOGUE (cudaDevAttrComputeCapabilityMinor = 76)
|
|
{"CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH",
|
|
{"hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 77 // API_Runtime ANALOGUE (cudaDevAttrMaxTexture1DMipmappedWidth = 77)
|
|
{"CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED",
|
|
{"hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 78 // API_Runtime ANALOGUE (cudaDevAttrStreamPrioritiesSupported = 78)
|
|
{"CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED",
|
|
{"hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 79 // API_Runtime ANALOGUE (cudaDevAttrGlobalL1CacheSupported = 79)
|
|
{"CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED",
|
|
{"hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 80 // API_Runtime ANALOGUE (cudaDevAttrLocalL1CacheSupported = 80)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR",
|
|
{"hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE,
|
|
API_DRIVER}}, // 81 // API_Runtime ANALOGUE (cudaDevAttrMaxSharedMemoryPerMultiprocessor =
|
|
// 81)
|
|
{"CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR",
|
|
{"hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 82 // API_Runtime ANALOGUE (cudaDevAttrMaxRegistersPerMultiprocessor =
|
|
// 82)
|
|
{"CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY",
|
|
{"hipDeviceAttributeManagedMemory", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 83 // API_Runtime ANALOGUE (cudaDevAttrManagedMemory = 83)
|
|
{"CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD",
|
|
{"hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE,
|
|
API_DRIVER}}, // 84 // API_Runtime ANALOGUE (cudaDevAttrIsMultiGpuBoard = 84)
|
|
{"CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID",
|
|
{"hipDeviceAttributeMultiGpuBoardGroupId", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 85 // API_Runtime ANALOGUE (cudaDevAttrMultiGpuBoardGroupID = 85)
|
|
{"CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED",
|
|
{"hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 86 // API_Runtime ANALOGUE (cudaDevAttrHostNativeAtomicSupported = 86)
|
|
{"CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO",
|
|
{"hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 87 // API_Runtime ANALOGUE (cudaDevAttrSingleToDoublePrecisionPerfRatio
|
|
// = 87)
|
|
{"CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS",
|
|
{"hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 88 // API_Runtime ANALOGUE (cudaDevAttrPageableMemoryAccess = 88)
|
|
{"CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS",
|
|
{"hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 89 // API_Runtime ANALOGUE (cudaDevAttrConcurrentManagedAccess = 89)
|
|
{"CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED",
|
|
{"hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 90 // API_Runtime ANALOGUE (cudaDevAttrComputePreemptionSupported = 90)
|
|
{"CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM",
|
|
{"hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 91 // API_Runtime ANALOGUE
|
|
// (cudaDevAttrCanUseHostPointerForRegisteredMem = 91)
|
|
|
|
{"CU_DEVICE_ATTRIBUTE_MAX",
|
|
{"hipDeviceAttributeMax", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 92 // API_Runtime ANALOGUE (no)
|
|
|
|
// TODO: Analogous enum is needed in HIP. Couldn't map enum to struct hipPointerAttribute_t.
|
|
// TODO: Do for Pointer Attributes the same as for Device Attributes.
|
|
// {"CUpointer_attribute_enum", {"hipPointerAttribute_t", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
// {"CUpointer_attribute", {"hipPointerAttribute_t", CONV_TYPE, API_DRIVER,
|
|
// HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_CONTEXT",
|
|
{"hipPointerAttributeContext", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_MEMORY_TYPE",
|
|
{"hipPointerAttributeMemoryType", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 2 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_DEVICE_POINTER",
|
|
{"hipPointerAttributeDevicePointer", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 3 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_HOST_POINTER",
|
|
{"hipPointerAttributeHostPointer", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 4 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_P2P_TOKENS",
|
|
{"hipPointerAttributeP2pTokens", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 5 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_SYNC_MEMOPS",
|
|
{"hipPointerAttributeSyncMemops", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 6 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_BUFFER_ID",
|
|
{"hipPointerAttributeBufferId", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 7 // API_Runtime ANALOGUE (no)
|
|
{"CU_POINTER_ATTRIBUTE_IS_MANAGED",
|
|
{"hipPointerAttributeIsManaged", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 8 // API_Runtime ANALOGUE (no)
|
|
|
|
// CUfunction_attribute_enum values
|
|
{"CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK",
|
|
{"hipFuncAttributeMaxThreadsPerBlocks", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES",
|
|
{"hipFuncAttributeSharedSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES",
|
|
{"hipFuncAttributeConstSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES",
|
|
{"hipFuncAttributeLocalSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_NUM_REGS",
|
|
{"hipFuncAttributeNumRegs", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_PTX_VERSION",
|
|
{"hipFuncAttributePtxVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_BINARY_VERSION",
|
|
{"hipFuncAttributeBinaryVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_CACHE_MODE_CA",
|
|
{"hipFuncAttributeCacheModeCA", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_FUNC_ATTRIBUTE_MAX", {"hipFuncAttributeMax", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// enum CUgraphicsMapResourceFlags/CUgraphicsMapResourceFlags_enum
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE",
|
|
{"hipGraphicsMapFlagsNone", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaGraphicsMapFlagsNone = 0)
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY",
|
|
{"hipGraphicsMapFlagsReadOnly", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaGraphicsMapFlagsReadOnly = 1)
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD",
|
|
{"hipGraphicsMapFlagsWriteDiscard", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaGraphicsMapFlagsWriteDiscard = 2)
|
|
|
|
// enum CUgraphicsRegisterFlags/CUgraphicsRegisterFlags_enum
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE",
|
|
{"hipGraphicsRegisterFlagsNone", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaGraphicsRegisterFlagsNone = 0)
|
|
{"CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY",
|
|
{"hipGraphicsRegisterFlagsReadOnly", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaGraphicsRegisterFlagsReadOnly = 1)
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD",
|
|
{"hipGraphicsRegisterFlagsWriteDiscard", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaGraphicsRegisterFlagsWriteDiscard =
|
|
// 2)
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST",
|
|
{"hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x04 // API_Runtime ANALOGUE (cudaGraphicsRegisterFlagsSurfaceLoadStore
|
|
// = 4)
|
|
{"CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER",
|
|
{"hipGraphicsRegisterFlagsTextureGather", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x08 // API_Runtime ANALOGUE (cudaGraphicsRegisterFlagsTextureGather =
|
|
// 8)
|
|
|
|
// enum CUoccupancy_flags/CUoccupancy_flags_enum
|
|
{"CU_OCCUPANCY_DEFAULT",
|
|
{"hipOccupancyDefault", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaOccupancyDefault = 0x0)
|
|
{"CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE",
|
|
{"hipOccupancyDisableCachingOverride", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaOccupancyDisableCachingOverride =
|
|
// 0x1)
|
|
|
|
// enum CUfunc_cache/CUfunc_cache_enum
|
|
{"CU_FUNC_CACHE_PREFER_NONE",
|
|
{"hipFuncCachePreferNone", CONV_CACHE,
|
|
API_DRIVER}}, // 0x00 // API_Runtime ANALOGUE (cudaFilterModePoint = 0)
|
|
{"CU_FUNC_CACHE_PREFER_SHARED",
|
|
{"hipFuncCachePreferShared", CONV_CACHE,
|
|
API_DRIVER}}, // 0x01 // API_Runtime ANALOGUE (cudaFuncCachePreferShared = 1)
|
|
{"CU_FUNC_CACHE_PREFER_L1",
|
|
{"hipFuncCachePreferL1", CONV_CACHE,
|
|
API_DRIVER}}, // 0x02 // API_Runtime ANALOGUE (cudaFuncCachePreferL1 = 2)
|
|
{"CU_FUNC_CACHE_PREFER_EQUAL",
|
|
{"hipFuncCachePreferEqual", CONV_CACHE,
|
|
API_DRIVER}}, // 0x03 // API_Runtime ANALOGUE (cudaFuncCachePreferEqual = 3)
|
|
|
|
// enum CUipcMem_flags/CUipcMem_flags_enum
|
|
{"CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS",
|
|
{"hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x1 // API_Runtime ANALOGUE (cudaIpcMemLazyEnablePeerAccess = 0x01)
|
|
|
|
// JIT
|
|
// enum CUjit_cacheMode/CUjit_cacheMode_enum
|
|
{"CU_JIT_CACHE_OPTION_NONE",
|
|
{"hipJitCacheModeOptionNone", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_CACHE_OPTION_CG", {"hipJitCacheModeOptionCG", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_CACHE_OPTION_CA", {"hipJitCacheModeOptionCA", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// enum CUjit_fallback/CUjit_fallback_enum
|
|
{"CU_PREFER_PTX", {"hipJitFallbackPreferPtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_PREFER_BINARY", {"hipJitFallbackPreferBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// enum CUjit_option/CUjit_option_enum
|
|
{"CU_JIT_MAX_REGISTERS", {"hipJitOptionMaxRegisters", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_THREADS_PER_BLOCK", {"hipJitOptionThreadsPerBlock", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_WALL_TIME", {"hipJitOptionWallTime", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_INFO_LOG_BUFFER", {"hipJitOptionInfoLogBuffer", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES",
|
|
{"hipJitOptionInfoLogBufferSizeBytes", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_ERROR_LOG_BUFFER", {"hipJitOptionErrorLogBuffer", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES",
|
|
{"hipJitOptionErrorLogBufferSizeBytes", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_OPTIMIZATION_LEVEL", {"hipJitOptionOptimizationLevel", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_TARGET_FROM_CUCONTEXT", {"hipJitOptionTargetFromContext", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_TARGET", {"hipJitOptionTarget", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_FALLBACK_STRATEGY", {"hipJitOptionFallbackStrategy", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_GENERATE_DEBUG_INFO", {"hipJitOptionGenerateDebugInfo", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_LOG_VERBOSE", {"hipJitOptionLogVerbose", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_GENERATE_LINE_INFO", {"hipJitOptionGenerateLineInfo", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_CACHE_MODE", {"hipJitOptionCacheMode", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_NEW_SM3X_OPT", {"hipJitOptionSm3xOpt", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_FAST_COMPILE", {"hipJitOptionFastCompile", CONV_JIT, API_DRIVER}},
|
|
{"CU_JIT_NUM_OPTIONS", {"hipJitOptionNumOptions", CONV_JIT, API_DRIVER}},
|
|
|
|
// enum CUjit_target/CUjit_target_enum
|
|
{"CU_TARGET_COMPUTE_10", {"hipJitTargetCompute10", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_11", {"hipJitTargetCompute11", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_12", {"hipJitTargetCompute12", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_13", {"hipJitTargetCompute13", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_20", {"hipJitTargetCompute20", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_21", {"hipJitTargetCompute21", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_30", {"hipJitTargetCompute30", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_32", {"hipJitTargetCompute32", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_35", {"hipJitTargetCompute35", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_37", {"hipJitTargetCompute37", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_50", {"hipJitTargetCompute50", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_52", {"hipJitTargetCompute52", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_53", {"hipJitTargetCompute53", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_60", {"hipJitTargetCompute60", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_61", {"hipJitTargetCompute61", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_TARGET_COMPUTE_62", {"hipJitTargetCompute62", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// enum CUjitInputType/CUjitInputType_enum
|
|
{"CU_JIT_INPUT_CUBIN", {"hipJitInputTypeBin", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_PTX", {"hipJitInputTypePtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_FATBINARY", {"hipJitInputTypeFatBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_OBJECT", {"hipJitInputTypeObject", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_INPUT_LIBRARY", {"hipJitInputTypeLibrary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"CU_JIT_NUM_INPUT_TYPES",
|
|
{"hipJitInputTypeNumInputTypes", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED}},
|
|
|
|
// enum CUlimit/CUlimit_enum
|
|
{"CU_LIMIT_STACK_SIZE",
|
|
{"hipLimitStackSize", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaLimitStackSize = 0x00)
|
|
{"CU_LIMIT_PRINTF_FIFO_SIZE",
|
|
{"hipLimitPrintfFifoSize", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaLimitPrintfFifoSize = 0x01)
|
|
{"CU_LIMIT_MALLOC_HEAP_SIZE",
|
|
{"hipLimitMallocHeapSize", CONV_TYPE,
|
|
API_DRIVER}}, // 0x02 // API_Runtime ANALOGUE (cudaLimitMallocHeapSize = 0x02)
|
|
{"CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH",
|
|
{"hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaLimitDevRuntimeSyncDepth = 0x03)
|
|
{"CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT",
|
|
{"hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x04 // API_Runtime ANALOGUE (cudaLimitDevRuntimePendingLaunchCount =
|
|
// 0x04)
|
|
{"CU_LIMIT_STACK_SIZE",
|
|
{"hipLimitStackSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // API_Runtime ANALOGUE (no)
|
|
|
|
// enum CUmemAttach_flags/CUmemAttach_flags_enum
|
|
{"CU_MEM_ATTACH_GLOBAL",
|
|
{"hipMemAttachGlobal", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x1 // API_Runtime ANALOGUE (#define cudaMemAttachGlobal 0x01)
|
|
{"CU_MEM_ATTACH_HOST",
|
|
{"hipMemAttachHost", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x2 // API_Runtime ANALOGUE (#define cudaMemAttachHost 0x02)
|
|
{"CU_MEM_ATTACH_SINGLE",
|
|
{"hipMemAttachSingle", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x4 // API_Runtime ANALOGUE (#define cudaMemAttachSingle 0x04)
|
|
|
|
// enum CUmemorytype/CUmemorytype_enum
|
|
{"CU_MEMORYTYPE_HOST",
|
|
{"hipMemTypeHost", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (no)
|
|
{"CU_MEMORYTYPE_DEVICE",
|
|
{"hipMemTypeDevice", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (no)
|
|
{"CU_MEMORYTYPE_ARRAY",
|
|
{"hipMemTypeArray", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (no)
|
|
{"CU_MEMORYTYPE_UNIFIED",
|
|
{"hipMemTypeUnified", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x04 // API_Runtime ANALOGUE (no)
|
|
|
|
// enum CUresourcetype/CUresourcetype_enum
|
|
{"CU_RESOURCE_TYPE_ARRAY",
|
|
{"hipResourceTypeArray", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaResourceTypeArray = 0x00)
|
|
{"CU_RESOURCE_TYPE_MIPMAPPED_ARRAY",
|
|
{"hipResourceTypeMipmappedArray", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaResourceTypeMipmappedArray = 0x01)
|
|
{"CU_RESOURCE_TYPE_LINEAR",
|
|
{"hipResourceTypeLinear", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaResourceTypeLinear = 0x02)
|
|
{"CU_RESOURCE_TYPE_PITCH2D",
|
|
{"hipResourceTypePitch2D", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaResourceTypePitch2D = 0x03)
|
|
|
|
// enum CUresourceViewFormat/CUresourceViewFormat_enum
|
|
{"CU_RES_VIEW_FORMAT_NONE",
|
|
{"hipResViewFormatNone", CONV_TEX,
|
|
API_DRIVER}}, // 0x00 // API_Runtime ANALOGUE (cudaResViewFormatNone = 0x00)
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X8",
|
|
{"hipResViewFormatUnsignedChar1", CONV_TEX,
|
|
API_DRIVER}}, // 0x01 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedChar1 = 0x01)
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X8",
|
|
{"hipResViewFormatUnsignedChar2", CONV_TEX,
|
|
API_DRIVER}}, // 0x02 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedChar2 = 0x02)
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X8",
|
|
{"hipResViewFormatUnsignedChar4", CONV_TEX,
|
|
API_DRIVER}}, // 0x03 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedChar4 = 0x03)
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X8",
|
|
{"hipResViewFormatSignedChar1", CONV_TEX,
|
|
API_DRIVER}}, // 0x04 // API_Runtime ANALOGUE (cudaResViewFormatSignedChar1 = 0x04)
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X8",
|
|
{"hipResViewFormatSignedChar2", CONV_TEX,
|
|
API_DRIVER}}, // 0x05 // API_Runtime ANALOGUE (cudaResViewFormatSignedChar2 = 0x05)
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X8",
|
|
{"hipResViewFormatSignedChar4", CONV_TEX,
|
|
API_DRIVER}}, // 0x06 // API_Runtime ANALOGUE (cudaResViewFormatSignedChar4 = 0x06)
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X16",
|
|
{"hipResViewFormatUnsignedShort1", CONV_TEX,
|
|
API_DRIVER}}, // 0x07 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedShort1 = 0x07)
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X16",
|
|
{"hipResViewFormatUnsignedShort2", CONV_TEX,
|
|
API_DRIVER}}, // 0x08 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedShort2 = 0x08)
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X16",
|
|
{"hipResViewFormatUnsignedShort4", CONV_TEX,
|
|
API_DRIVER}}, // 0x09 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedShort4 = 0x09)
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X16",
|
|
{"hipResViewFormatSignedShort1", CONV_TEX,
|
|
API_DRIVER}}, // 0x0a // API_Runtime ANALOGUE (cudaResViewFormatSignedShort1 = 0x0a)
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X16",
|
|
{"hipResViewFormatSignedShort2", CONV_TEX,
|
|
API_DRIVER}}, // 0x0b // API_Runtime ANALOGUE (cudaResViewFormatSignedShort2 = 0x0b)
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X16",
|
|
{"hipResViewFormatSignedShort4", CONV_TEX,
|
|
API_DRIVER}}, // 0x0c // API_Runtime ANALOGUE (cudaResViewFormatSignedShort4 = 0x0c)
|
|
{"CU_RES_VIEW_FORMAT_UINT_1X32",
|
|
{"hipResViewFormatUnsignedInt1", CONV_TEX,
|
|
API_DRIVER}}, // 0x0d // API_Runtime ANALOGUE (cudaResViewFormatUnsignedInt1 = 0x0d)
|
|
{"CU_RES_VIEW_FORMAT_UINT_2X32",
|
|
{"hipResViewFormatUnsignedInt2", CONV_TEX,
|
|
API_DRIVER}}, // 0x0e // API_Runtime ANALOGUE (cudaResViewFormatUnsignedInt2 = 0x0e)
|
|
{"CU_RES_VIEW_FORMAT_UINT_4X32",
|
|
{"hipResViewFormatUnsignedInt4", CONV_TEX,
|
|
API_DRIVER}}, // 0x0f // API_Runtime ANALOGUE (cudaResViewFormatUnsignedInt4 = 0x0f)
|
|
{"CU_RES_VIEW_FORMAT_SINT_1X32",
|
|
{"hipResViewFormatSignedInt1", CONV_TEX,
|
|
API_DRIVER}}, // 0x10 // API_Runtime ANALOGUE (cudaResViewFormatSignedInt1 = 0x10)
|
|
{"CU_RES_VIEW_FORMAT_SINT_2X32",
|
|
{"hipResViewFormatSignedInt2", CONV_TEX,
|
|
API_DRIVER}}, // 0x11 // API_Runtime ANALOGUE (cudaResViewFormatSignedInt2 = 0x11)
|
|
{"CU_RES_VIEW_FORMAT_SINT_4X32",
|
|
{"hipResViewFormatSignedInt4", CONV_TEX,
|
|
API_DRIVER}}, // 0x12 // API_Runtime ANALOGUE (cudaResViewFormatSignedInt4 = 0x12)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_1X16",
|
|
{"hipResViewFormatHalf1", CONV_TEX,
|
|
API_DRIVER}}, // 0x13 // API_Runtime ANALOGUE (cudaResViewFormatHalf1 = 0x13)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_2X16",
|
|
{"hipResViewFormatHalf2", CONV_TEX,
|
|
API_DRIVER}}, // 0x14 // API_Runtime ANALOGUE (cudaResViewFormatHalf2 = 0x14)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_4X16",
|
|
{"hipResViewFormatHalf4", CONV_TEX,
|
|
API_DRIVER}}, // 0x15 // API_Runtime ANALOGUE (cudaResViewFormatHalf4 = 0x15)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_1X32",
|
|
{"hipResViewFormatFloat1", CONV_TEX,
|
|
API_DRIVER}}, // 0x16 // API_Runtime ANALOGUE (cudaResViewFormatFloat1 = 0x16)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_2X32",
|
|
{"hipResViewFormatFloat2", CONV_TEX,
|
|
API_DRIVER}}, // 0x17 // API_Runtime ANALOGUE (cudaResViewFormatFloat2 = 0x17)
|
|
{"CU_RES_VIEW_FORMAT_FLOAT_4X32",
|
|
{"hipResViewFormatFloat4", CONV_TEX,
|
|
API_DRIVER}}, // 0x18 // API_Runtime ANALOGUE (cudaResViewFormatFloat4 = 0x18)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC1",
|
|
{"hipResViewFormatUnsignedBlockCompressed1", CONV_TEX,
|
|
API_DRIVER}}, // 0x19 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed1 =
|
|
// 0x19)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC2",
|
|
{"hipResViewFormatUnsignedBlockCompressed2", CONV_TEX,
|
|
API_DRIVER}}, // 0x1a // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed2 =
|
|
// 0x1a)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC3",
|
|
{"hipResViewFormatUnsignedBlockCompressed3", CONV_TEX,
|
|
API_DRIVER}}, // 0x1b // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed3 =
|
|
// 0x1b)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC4",
|
|
{"hipResViewFormatUnsignedBlockCompressed4", CONV_TEX,
|
|
API_DRIVER}}, // 0x1c // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed4 =
|
|
// 0x1c)
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC4",
|
|
{"hipResViewFormatSignedBlockCompressed4", CONV_TEX,
|
|
API_DRIVER}}, // 0x1d // API_Runtime ANALOGUE (cudaResViewFormatSignedBlockCompressed4 =
|
|
// 0x1d)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC5",
|
|
{"hipResViewFormatUnsignedBlockCompressed5", CONV_TEX,
|
|
API_DRIVER}}, // 0x1e // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed5 =
|
|
// 0x1e)
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC5",
|
|
{"hipResViewFormatSignedBlockCompressed5", CONV_TEX,
|
|
API_DRIVER}}, // 0x1f // API_Runtime ANALOGUE (cudaResViewFormatSignedBlockCompressed5 =
|
|
// 0x1f)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC6H",
|
|
{"hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX,
|
|
API_DRIVER}}, // 0x20 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed6H =
|
|
// 0x20)
|
|
{"CU_RES_VIEW_FORMAT_SIGNED_BC6H",
|
|
{"hipResViewFormatSignedBlockCompressed6H", CONV_TEX,
|
|
API_DRIVER}}, // 0x21 // API_Runtime ANALOGUE (cudaResViewFormatSignedBlockCompressed6H =
|
|
// 0x21)
|
|
{"CU_RES_VIEW_FORMAT_UNSIGNED_BC7",
|
|
{"hipResViewFormatUnsignedBlockCompressed7", CONV_TEX,
|
|
API_DRIVER}}, // 0x22 // API_Runtime ANALOGUE (cudaResViewFormatUnsignedBlockCompressed7 =
|
|
// 0x22)
|
|
|
|
{"CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE",
|
|
{"hipSharedMemBankSizeDefault", CONV_TYPE, API_DRIVER}},
|
|
{"CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE",
|
|
{"hipSharedMemBankSizeFourByte", CONV_TYPE, API_DRIVER}},
|
|
{"CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE",
|
|
{"hipSharedMemBankSizeEightByte", CONV_TYPE, API_DRIVER}},
|
|
|
|
// enum CUstream_flags/CUstream_flags_enum
|
|
{"CU_STREAM_DEFAULT", {"hipStreamDefault", CONV_TYPE, API_DRIVER}},
|
|
{"CU_STREAM_NON_BLOCKING", {"hipStreamNonBlocking", CONV_TYPE, API_DRIVER}},
|
|
|
|
// Flags for ::cuStreamWaitValue32 (enum CUstreamWaitValue_flags/CUstreamWaitValue_flags_enum)
|
|
{"CU_STREAM_WAIT_VALUE_GEQ",
|
|
{"hipStreamWaitValueGeq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0
|
|
{"CU_STREAM_WAIT_VALUE_EQ",
|
|
{"hipStreamWaitValueEq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
{"CU_STREAM_WAIT_VALUE_AND",
|
|
{"hipStreamWaitValueAnd", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x2
|
|
{"CU_STREAM_WAIT_VALUE_FLUSH",
|
|
{"hipStreamWaitValueFlush", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 1<<30
|
|
|
|
// Flags for ::cuStreamWriteValue32 (enum
|
|
// CUstreamWriteValue_flags/CUstreamWriteValue_flags_enum)
|
|
{"CU_STREAM_WRITE_VALUE_DEFAULT",
|
|
{"hipStreamWriteValueDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x0
|
|
{"CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER",
|
|
{"hipStreamWriteValueNoMemoryBarrier", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 0x1
|
|
|
|
// Flags for ::cuStreamBatchMemOp (enum CUstreamBatchMemOpType/CUstreamBatchMemOpType_enum)
|
|
{"CU_STREAM_MEM_OP_WAIT_VALUE_32",
|
|
{"hipStreamBatchMemOpWaitValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 1
|
|
{"CU_STREAM_MEM_OP_WRITE_VALUE_32",
|
|
{"hipStreamBatchMemOpWriteValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 2
|
|
{"CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES",
|
|
{"hipStreamBatchMemOpFlushRemoteWrites", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED}}, // 3
|
|
|
|
// 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}},
|
|
|
|
// 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)
|
|
|
|
// 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}},
|
|
|
|
// 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}},
|
|
|
|
// 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}},
|
|
|
|
// enum CUdevice_P2PAttribute/CUdevice_P2PAttribute_enum
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK",
|
|
{"hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaDevP2PAttrPerformanceRank = 0x01)
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED",
|
|
{"hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaDevP2PAttrAccessSupported = 0x02)
|
|
{"CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED",
|
|
{"hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaDevP2PAttrNativeAtomicSupported =
|
|
// 0x03)
|
|
|
|
// Events
|
|
{"CU_EVENT_DEFAULT", {"hipEventDefault", CONV_EVENT, API_DRIVER}},
|
|
{"CU_EVENT_BLOCKING_SYNC", {"hipEventBlockingSync", CONV_EVENT, API_DRIVER}},
|
|
{"CU_EVENT_DISABLE_TIMING", {"hipEventDisableTiming", CONV_EVENT, API_DRIVER}},
|
|
{"CU_EVENT_INTERPROCESS", {"hipEventInterprocess", CONV_EVENT, 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}},
|
|
|
|
// Execution Control
|
|
{"cuFuncGetAttribute", {"hipFuncGetAttribute", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuFuncSetCacheConfig", {"hipFuncSetCacheConfig", CONV_MODULE, API_DRIVER}},
|
|
{"cuFuncSetSharedMemConfig",
|
|
{"hipFuncSetSharedMemConfig", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED}},
|
|
{"cuLaunchKernel", {"hipModuleLaunchKernel", CONV_MODULE, API_DRIVER}},
|
|
|
|
// 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}},
|
|
|
|
// 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
|
|
{"cuStreamWriteValue32",
|
|
{"hipStreamWriteValue32", CONV_STREAM, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // // no API_Runtime ANALOGUE
|
|
{"cuStreamBatchMemOp",
|
|
{"hipStreamBatchMemOp", CONV_STREAM, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // // no API_Runtime ANALOGUE
|
|
|
|
// 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
|
|
// Texture reference filtering modes
|
|
// enum CUfilter_mode/CUfilter_mode_enum
|
|
{"CU_TR_FILTER_MODE_POINT",
|
|
{"hipFilterModePoint", CONV_TEX,
|
|
API_DRIVER}}, // 0 // API_Runtime ANALOGUE (cudaFilterModePoint = 0)
|
|
{"CU_TR_FILTER_MODE_LINEAR",
|
|
{"hipFilterModeLinear", CONV_TEX, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 1 // API_Runtime ANALOGUE (cudaFilterModeLinear = 1)
|
|
|
|
{"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)
|
|
|
|
// OpenGL Interoperability
|
|
// enum CUGLDeviceList/CUGLDeviceList_enum
|
|
{"CU_GL_DEVICE_LIST_ALL",
|
|
{"HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaGLDeviceListAll)
|
|
{"CU_GL_DEVICE_LIST_CURRENT_FRAME",
|
|
{"HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaGLDeviceListCurrentFrame)
|
|
{"CU_GL_DEVICE_LIST_NEXT_FRAME",
|
|
{"HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaGLDeviceListNextFrame)
|
|
|
|
{"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)
|
|
|
|
// OpenGL Interoperability [DEPRECATED]
|
|
// enum CUGLmap_flags/CUGLmap_flags_enum
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_NONE",
|
|
{"HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaGLMapFlagsNone)
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY",
|
|
{"HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaGLMapFlagsReadOnly)
|
|
{"CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD",
|
|
{"HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaGLMapFlagsWriteDiscard)
|
|
|
|
{"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)
|
|
|
|
// Direct3D 9 Interoperability
|
|
// enum CUd3d9DeviceList/CUd3d9DeviceList_enum
|
|
{"CU_D3D9_DEVICE_LIST_ALL",
|
|
{"HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D9DeviceListAll)
|
|
{"CU_D3D9_DEVICE_LIST_CURRENT_FRAME",
|
|
{"HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaD3D9DeviceListCurrentFrame)
|
|
{"CU_D3D9_DEVICE_LIST_NEXT_FRAME",
|
|
{"HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaD3D9DeviceListNextFrame)
|
|
|
|
{"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)
|
|
|
|
// Direct3D 9 Interoperability [DEPRECATED]
|
|
// enum CUd3d9map_flags/CUd3d9map_flags_enum
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_NONE",
|
|
{"HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaD3D9MapFlagsNone)
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_READONLY",
|
|
{"HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D9MapFlagsReadOnly)
|
|
{"CU_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD",
|
|
{"HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaD3D9MapFlagsWriteDiscard)
|
|
|
|
// enum CUd3d9register_flags/CUd3d9register_flags_enum
|
|
{"CU_D3D9_REGISTER_FLAGS_NONE",
|
|
{"HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaD3D9RegisterFlagsNone)
|
|
{"CU_D3D9_REGISTER_FLAGS_ARRAY",
|
|
{"HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D9RegisterFlagsArray)
|
|
|
|
{"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
|
|
// enum CUd3d10DeviceList/CUd3d10DeviceList_enum
|
|
{"CU_D3D10_DEVICE_LIST_ALL",
|
|
{"HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D10DeviceListAll)
|
|
{"CU_D3D10_DEVICE_LIST_CURRENT_FRAME",
|
|
{"HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaD3D10DeviceListCurrentFrame)
|
|
{"CU_D3D10_DEVICE_LIST_NEXT_FRAME",
|
|
{"HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaD3D10DeviceListNextFrame)
|
|
|
|
{"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]
|
|
// enum CUd3d10map_flags/CUd3d10map_flags_enum
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_NONE",
|
|
{"HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaD3D10MapFlagsNone)
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_READONLY",
|
|
{"HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D10MapFlagsReadOnly)
|
|
{"CU_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD",
|
|
{"HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaD3D10MapFlagsWriteDiscard)
|
|
|
|
// enum CUd3d10register_flags/CUd3d10register_flags_enum
|
|
{"CU_D3D10_REGISTER_FLAGS_NONE",
|
|
{"HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x00 // API_Runtime ANALOGUE (cudaD3D10RegisterFlagsNone)
|
|
{"CU_D3D10_REGISTER_FLAGS_ARRAY",
|
|
{"HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D10RegisterFlagsArray)
|
|
|
|
{"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
|
|
// enum CUd3d11DeviceList/CUd3d11DeviceList_enum
|
|
{"CU_D3D11_DEVICE_LIST_ALL",
|
|
{"HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x01 // API_Runtime ANALOGUE (cudaD3D11DeviceListAll)
|
|
{"CU_D3D11_DEVICE_LIST_CURRENT_FRAME",
|
|
{"HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x02 // API_Runtime ANALOGUE (cudaD3D11DeviceListCurrentFrame)
|
|
{"CU_D3D11_DEVICE_LIST_NEXT_FRAME",
|
|
{"HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_DRIVER,
|
|
HIP_UNSUPPORTED}}, // 0x03 // API_Runtime ANALOGUE (cudaD3D11DeviceListNextFrame)
|
|
|
|
{"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)
|
|
|
|
/////////////////////////////// CUDA RT API ///////////////////////////////
|
|
// Data types
|
|
{"cudaDataType_t", {"hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaDataType", {"hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_16F", {"hipR16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_16F", {"hipC16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_32F", {"hipR32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_32F", {"hipC32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_64F", {"hipR64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_64F", {"hipC64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_8I", {"hipR8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_8I", {"hipC8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_8U", {"hipR8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_8U", {"hipC8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_32I", {"hipR32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_32I", {"hipC32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_R_32U", {"hipR32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"CUDA_C_32U", {"hipC32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// 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, HIP_UNSUPPORTED}},
|
|
{"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,
|
|
HIP_UNSUPPORTED}}, // 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,
|
|
HIP_UNSUPPORTED}}, // 0 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_DEFAULT = 0)
|
|
{"cudaComputeModeExclusive",
|
|
{"hipComputeModeExclusive", CONV_TYPE, API_RUNTIME,
|
|
HIP_UNSUPPORTED}}, // 1 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_EXCLUSIVE = 1)
|
|
{"cudaComputeModeProhibited",
|
|
{"hipComputeModeProhibited", CONV_TYPE, API_RUNTIME,
|
|
HIP_UNSUPPORTED}}, // 2 // API_DRIVER ANALOGUE (CU_COMPUTEMODE_PROHIBITED = 2)
|
|
{"cudaComputeModeExclusiveProcess",
|
|
{"hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME,
|
|
HIP_UNSUPPORTED}}, // 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, HIP_UNSUPPORTED}},
|
|
{"cudaLaunch", {"hipLaunch", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaSetupArgument", {"hipSetupArgument", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// 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, HIP_UNSUPPORTED}},
|
|
{"cudaBoundaryModeClamp", {"hipBoundaryModeClamp", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"cudaBoundaryModeTrap", {"hipBoundaryModeTrap", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
|
|
// 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, HIP_UNSUPPORTED}},
|
|
{"cudaDestroySurfaceObject",
|
|
{"hipDestroySurfaceObject", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED}},
|
|
{"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)
|
|
|
|
{"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)
|
|
|
|
// Direct3D 9 Interoperability [DEPRECATED]
|
|
// enum cudaD3D9MapFlags
|
|
{"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)
|
|
|
|
// 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 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 operations (cublasOperation_t)
|
|
{"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_t)
|
|
{"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_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_BLAS}},
|
|
|
|
// Blas Fill Modes (cublasFillMode_t)
|
|
{"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)
|
|
{"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
|
|
{"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)
|
|
{"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)
|
|
{"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)
|
|
{"CUBLAS_DATA_FLOAT", {"HIPBLAS_DATA_FLOAT", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_DATA_DOUBLE",
|
|
{"HIPBLAS_DATA_DOUBLE", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_DATA_HALF", {"HIPBLAS_DATA_HALF", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"CUBLAS_DATA_INT8", {"HIPBLAS_DATA_INT8", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED}},
|
|
|
|
// Blas1 (v1) Routines
|
|
{"cublasCreate", {"hipblasCreate", CONV_MATH_FUNC, API_BLAS}},
|
|
{"cublasDestroy", {"hipblasDestroy", 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, HIP_UNSUPPORTED}},
|
|
{"cublasDnrm2", {"hipblasDnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"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}},
|
|
{"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}},
|
|
{"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, HIP_UNSUPPORTED}},
|
|
|
|
// 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, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsm", {"hipblasDtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"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}},
|
|
{"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, HIP_UNSUPPORTED}},
|
|
{"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, 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, HIP_UNSUPPORTED}},
|
|
{"cublasDtrsm_v2", {"hipblasDtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"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, HIP_UNSUPPORTED}},
|
|
{"cublasDnrm2_v2", {"hipblasDnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED}},
|
|
{"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
|
|
};
|
|
|
|
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;
|
|
};
|