Global enum and defines

Global enum and defines#

HIP Runtime API Reference: Global enum and defines
Global enum and defines

Data Structures

struct  hipDeviceArch_t
 
struct  hipUUID
 
struct  hipDeviceProp_t
 
struct  hipPointerAttribute_t
 
struct  hipIpcMemHandle_t
 
struct  hipIpcEventHandle_t
 
struct  hipFuncAttributes
 
struct  hipMemLocation
 
struct  hipMemAccessDesc
 
struct  hipMemPoolProps
 
struct  hipMemPoolPtrExportData
 
struct  dim3
 
struct  hipLaunchParams
 
struct  hipFunctionLaunchParams
 
struct  hipExternalMemoryHandleDesc
 
struct  hipExternalMemoryBufferDesc
 
struct  hipExternalSemaphoreHandleDesc
 
struct  hipExternalSemaphoreSignalParams
 
struct  hipExternalSemaphoreWaitParams
 
struct  hipHostNodeParams
 
struct  hipKernelNodeParams
 
struct  hipMemsetParams
 
struct  hipMemAllocNodeParams
 
struct  hipAccessPolicyWindow
 
union  hipKernelNodeAttrValue
 
struct  hipMemAllocationProp
 
struct  hipExternalSemaphoreSignalNodeParams
 
struct  hipExternalSemaphoreWaitNodeParams
 
struct  hipArrayMapInfo
 

Macros

#define __HIP_NODISCARD
 
#define GENERIC_GRID_LAUNCH   1
 
#define DEPRECATED(msg)   __attribute__ ((deprecated(msg)))
 
#define DEPRECATED_MSG   "This API is marked as deprecated and may not be supported in future releases. For more details please refer https://github.com/ROCm-Developer-Tools/HIP/blob/master/docs/markdown/hip_deprecated_api_list.md"
 
#define HIP_LAUNCH_PARAM_BUFFER_POINTER   ((void*)0x01)
 
#define HIP_LAUNCH_PARAM_BUFFER_SIZE   ((void*)0x02)
 
#define HIP_LAUNCH_PARAM_END   ((void*)0x03)
 
#define __dparm(x)
 
#define hipIpcMemLazyEnablePeerAccess   0
 
#define HIP_IPC_HANDLE_SIZE   64
 
#define hipStreamDefault   0x00
 
#define hipStreamNonBlocking   0x01
 
#define hipEventDefault   0x0
 
#define hipEventBlockingSync   0x1
 
#define hipEventDisableTiming   0x2
 
#define hipEventInterprocess   0x4
 
#define hipEventDisableSystemFence   0x20000000
 
#define hipEventReleaseToDevice   0x40000000
 
#define hipEventReleaseToSystem   0x80000000
 
#define hipHostMallocDefault   0x0
 
#define hipHostMallocPortable   0x1
 
#define hipHostMallocMapped   0x2
 
#define hipHostMallocWriteCombined   0x4
 
#define hipHostMallocNumaUser   0x20000000
 
#define hipHostMallocCoherent   0x40000000
 
#define hipHostMallocNonCoherent   0x80000000
 
#define hipMemAttachGlobal   0x01
 
#define hipMemAttachHost   0x02
 
#define hipMemAttachSingle   0x04
 
#define hipDeviceMallocDefault   0x0
 
#define hipDeviceMallocFinegrained   0x1
 
#define hipMallocSignalMemory   0x2
 
#define hipDeviceMallocUncached   0x3
 
#define hipHostRegisterDefault   0x0
 
#define hipHostRegisterPortable   0x1
 
#define hipHostRegisterMapped   0x2
 
#define hipHostRegisterIoMemory   0x4
 
#define hipHostRegisterReadOnly   0x08
 
#define hipExtHostRegisterCoarseGrained   0x8
 
#define hipDeviceScheduleAuto   0x0
 
#define hipDeviceScheduleSpin   0x1
 
#define hipDeviceScheduleYield   0x2
 
#define hipDeviceScheduleBlockingSync   0x4
 
#define hipDeviceScheduleMask   0x7
 
#define hipDeviceMapHost   0x8
 
#define hipDeviceLmemResizeToMax   0x10
 
#define hipArrayDefault   0x00
 
#define hipArrayLayered   0x01
 
#define hipArraySurfaceLoadStore   0x02
 
#define hipArrayCubemap   0x04
 
#define hipArrayTextureGather   0x08
 
#define hipOccupancyDefault   0x00
 
#define hipOccupancyDisableCachingOverride   0x01
 
#define hipCooperativeLaunchMultiDeviceNoPreSync   0x01
 
#define hipCooperativeLaunchMultiDeviceNoPostSync   0x02
 
#define hipCpuDeviceId   ((int)-1)
 
#define hipInvalidDeviceId   ((int)-2)
 
#define hipExtAnyOrderLaunch   0x01
 
#define hipStreamWaitValueGte   0x0
 
#define hipStreamWaitValueEq   0x1
 
#define hipStreamWaitValueAnd   0x2
 
#define hipStreamWaitValueNor   0x3
 
#define hipStreamPerThread   ((hipStream_t)2)
 
#define hipExternalMemoryDedicated   0x1
 

Typedefs

typedef enum __HIP_NODISCARD hipError_t hipError_t
 
typedef struct ihipCtx_t * hipCtx_t
 
typedef int hipDevice_t
 
typedef struct ihipStream_t * hipStream_t
 
typedef struct ihipModule_t * hipModule_t
 
typedef struct ihipModuleSymbol_t * hipFunction_t
 
typedef struct ihipMemPoolHandle_t * hipMemPool_t
 
typedef struct ihipEvent_t * hipEvent_t
 
typedef void * hipExternalMemory_t
 
typedef void * hipExternalSemaphore_t
 
typedef struct _hipGraphicsResource hipGraphicsResource
 
typedef hipGraphicsResourcehipGraphicsResource_t
 
typedef struct ihipGraph * hipGraph_t
 
typedef struct hipGraphNode * hipGraphNode_t
 
typedef struct hipGraphExec * hipGraphExec_t
 
typedef struct hipUserObject * hipUserObject_t
 
typedef void(* hipHostFn_t) (void *userData)
 
typedef struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t
 

Enumerations

enum  hipMemoryType {
  hipMemoryTypeHost = 0 ,
  hipMemoryTypeDevice = 1 ,
  hipMemoryTypeArray = 2 ,
  hipMemoryTypeUnified = 3 ,
  hipMemoryTypeManaged = 4
}
 
enum  hipDeviceAttribute_t {
  hipDeviceAttributeCudaCompatibleBegin = 0 ,
  hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin ,
  hipDeviceAttributeAccessPolicyMaxWindowSize ,
  hipDeviceAttributeAsyncEngineCount ,
  hipDeviceAttributeCanMapHostMemory ,
  hipDeviceAttributeCanUseHostPointerForRegisteredMem ,
  hipDeviceAttributeClockRate ,
  hipDeviceAttributeComputeMode ,
  hipDeviceAttributeComputePreemptionSupported ,
  hipDeviceAttributeConcurrentKernels ,
  hipDeviceAttributeConcurrentManagedAccess ,
  hipDeviceAttributeCooperativeLaunch ,
  hipDeviceAttributeCooperativeMultiDeviceLaunch ,
  hipDeviceAttributeDeviceOverlap ,
  hipDeviceAttributeDirectManagedMemAccessFromHost ,
  hipDeviceAttributeGlobalL1CacheSupported ,
  hipDeviceAttributeHostNativeAtomicSupported ,
  hipDeviceAttributeIntegrated ,
  hipDeviceAttributeIsMultiGpuBoard ,
  hipDeviceAttributeKernelExecTimeout ,
  hipDeviceAttributeL2CacheSize ,
  hipDeviceAttributeLocalL1CacheSupported ,
  hipDeviceAttributeLuid ,
  hipDeviceAttributeLuidDeviceNodeMask ,
  hipDeviceAttributeComputeCapabilityMajor ,
  hipDeviceAttributeManagedMemory ,
  hipDeviceAttributeMaxBlocksPerMultiProcessor ,
  hipDeviceAttributeMaxBlockDimX ,
  hipDeviceAttributeMaxBlockDimY ,
  hipDeviceAttributeMaxBlockDimZ ,
  hipDeviceAttributeMaxGridDimX ,
  hipDeviceAttributeMaxGridDimY ,
  hipDeviceAttributeMaxGridDimZ ,
  hipDeviceAttributeMaxSurface1D ,
  hipDeviceAttributeMaxSurface1DLayered ,
  hipDeviceAttributeMaxSurface2D ,
  hipDeviceAttributeMaxSurface2DLayered ,
  hipDeviceAttributeMaxSurface3D ,
  hipDeviceAttributeMaxSurfaceCubemap ,
  hipDeviceAttributeMaxSurfaceCubemapLayered ,
  hipDeviceAttributeMaxTexture1DWidth ,
  hipDeviceAttributeMaxTexture1DLayered ,
  hipDeviceAttributeMaxTexture1DLinear ,
  hipDeviceAttributeMaxTexture1DMipmap ,
  hipDeviceAttributeMaxTexture2DWidth ,
  hipDeviceAttributeMaxTexture2DHeight ,
  hipDeviceAttributeMaxTexture2DGather ,
  hipDeviceAttributeMaxTexture2DLayered ,
  hipDeviceAttributeMaxTexture2DLinear ,
  hipDeviceAttributeMaxTexture2DMipmap ,
  hipDeviceAttributeMaxTexture3DWidth ,
  hipDeviceAttributeMaxTexture3DHeight ,
  hipDeviceAttributeMaxTexture3DDepth ,
  hipDeviceAttributeMaxTexture3DAlt ,
  hipDeviceAttributeMaxTextureCubemap ,
  hipDeviceAttributeMaxTextureCubemapLayered ,
  hipDeviceAttributeMaxThreadsDim ,
  hipDeviceAttributeMaxThreadsPerBlock ,
  hipDeviceAttributeMaxThreadsPerMultiProcessor ,
  hipDeviceAttributeMaxPitch ,
  hipDeviceAttributeMemoryBusWidth ,
  hipDeviceAttributeMemoryClockRate ,
  hipDeviceAttributeComputeCapabilityMinor ,
  hipDeviceAttributeMultiGpuBoardGroupID ,
  hipDeviceAttributeMultiprocessorCount ,
  hipDeviceAttributeName ,
  hipDeviceAttributePageableMemoryAccess ,
  hipDeviceAttributePageableMemoryAccessUsesHostPageTables ,
  hipDeviceAttributePciBusId ,
  hipDeviceAttributePciDeviceId ,
  hipDeviceAttributePciDomainID ,
  hipDeviceAttributePersistingL2CacheMaxSize ,
  hipDeviceAttributeMaxRegistersPerBlock ,
  hipDeviceAttributeMaxRegistersPerMultiprocessor ,
  hipDeviceAttributeReservedSharedMemPerBlock ,
  hipDeviceAttributeMaxSharedMemoryPerBlock ,
  hipDeviceAttributeSharedMemPerBlockOptin ,
  hipDeviceAttributeSharedMemPerMultiprocessor ,
  hipDeviceAttributeSingleToDoublePrecisionPerfRatio ,
  hipDeviceAttributeStreamPrioritiesSupported ,
  hipDeviceAttributeSurfaceAlignment ,
  hipDeviceAttributeTccDriver ,
  hipDeviceAttributeTextureAlignment ,
  hipDeviceAttributeTexturePitchAlignment ,
  hipDeviceAttributeTotalConstantMemory ,
  hipDeviceAttributeTotalGlobalMem ,
  hipDeviceAttributeUnifiedAddressing ,
  hipDeviceAttributeUuid ,
  hipDeviceAttributeWarpSize ,
  hipDeviceAttributeMemoryPoolsSupported ,
  hipDeviceAttributeVirtualMemoryManagementSupported ,
  hipDeviceAttributeCudaCompatibleEnd = 9999 ,
  hipDeviceAttributeAmdSpecificBegin = 10000 ,
  hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin ,
  hipDeviceAttributeArch ,
  hipDeviceAttributeMaxSharedMemoryPerMultiprocessor ,
  hipDeviceAttributeGcnArch ,
  hipDeviceAttributeGcnArchName ,
  hipDeviceAttributeHdpMemFlushCntl ,
  hipDeviceAttributeHdpRegFlushCntl ,
  hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc ,
  hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim ,
  hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim ,
  hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem ,
  hipDeviceAttributeIsLargeBar ,
  hipDeviceAttributeAsicRevision ,
  hipDeviceAttributeCanUseStreamWaitValue ,
  hipDeviceAttributeImageSupport ,
  hipDeviceAttributePhysicalMultiProcessorCount ,
  hipDeviceAttributeFineGrainSupport ,
  hipDeviceAttributeWallClockRate ,
  hipDeviceAttributeAmdSpecificEnd = 19999 ,
  hipDeviceAttributeVendorSpecificBegin = 20000
}
 
enum  hipComputeMode {
  hipComputeModeDefault = 0 ,
  hipComputeModeExclusive = 1 ,
  hipComputeModeProhibited = 2 ,
  hipComputeModeExclusiveProcess = 3
}
 
enum  hipDeviceP2PAttr {
  hipDevP2PAttrPerformanceRank = 0 ,
  hipDevP2PAttrAccessSupported ,
  hipDevP2PAttrNativeAtomicSupported ,
  hipDevP2PAttrHipArrayAccessSupported
}
 
enum  hipLimit_t {
  hipLimitStackSize = 0x0 ,
  hipLimitPrintfFifoSize = 0x01 ,
  hipLimitMallocHeapSize = 0x02 ,
  hipLimitRange
}
 
enum  hipMemoryAdvise {
  hipMemAdviseSetReadMostly = 1 ,
  hipMemAdviseUnsetReadMostly = 2 ,
  hipMemAdviseSetPreferredLocation = 3 ,
  hipMemAdviseUnsetPreferredLocation = 4 ,
  hipMemAdviseSetAccessedBy = 5 ,
  hipMemAdviseUnsetAccessedBy = 6 ,
  hipMemAdviseSetCoarseGrain = 100 ,
  hipMemAdviseUnsetCoarseGrain = 101
}
 
enum  hipMemRangeCoherencyMode {
  hipMemRangeCoherencyModeFineGrain = 0 ,
  hipMemRangeCoherencyModeCoarseGrain = 1 ,
  hipMemRangeCoherencyModeIndeterminate = 2
}
 
enum  hipMemRangeAttribute {
  hipMemRangeAttributeReadMostly = 1 ,
  hipMemRangeAttributePreferredLocation = 2 ,
  hipMemRangeAttributeAccessedBy = 3 ,
  hipMemRangeAttributeLastPrefetchLocation = 4 ,
  hipMemRangeAttributeCoherencyMode = 100
}
 
enum  hipMemPoolAttr {
  hipMemPoolReuseFollowEventDependencies = 0x1 ,
  hipMemPoolReuseAllowOpportunistic = 0x2 ,
  hipMemPoolReuseAllowInternalDependencies = 0x3 ,
  hipMemPoolAttrReleaseThreshold = 0x4 ,
  hipMemPoolAttrReservedMemCurrent = 0x5 ,
  hipMemPoolAttrReservedMemHigh = 0x6 ,
  hipMemPoolAttrUsedMemCurrent = 0x7 ,
  hipMemPoolAttrUsedMemHigh = 0x8
}
 
enum  hipMemLocationType {
  hipMemLocationTypeInvalid = 0 ,
  hipMemLocationTypeDevice = 1
}
 
enum  hipMemAccessFlags {
  hipMemAccessFlagsProtNone = 0 ,
  hipMemAccessFlagsProtRead = 1 ,
  hipMemAccessFlagsProtReadWrite = 3
}
 
enum  hipMemAllocationType {
  hipMemAllocationTypeInvalid = 0x0 ,
  hipMemAllocationTypePinned = 0x1 ,
  hipMemAllocationTypeMax = 0x7FFFFFFF
}
 
enum  hipMemAllocationHandleType {
  hipMemHandleTypeNone = 0x0 ,
  hipMemHandleTypePosixFileDescriptor = 0x1 ,
  hipMemHandleTypeWin32 = 0x2 ,
  hipMemHandleTypeWin32Kmt = 0x4
}
 
enum  hipJitOption {
  hipJitOptionMaxRegisters = 0 ,
  hipJitOptionThreadsPerBlock ,
  hipJitOptionWallTime ,
  hipJitOptionInfoLogBuffer ,
  hipJitOptionInfoLogBufferSizeBytes ,
  hipJitOptionErrorLogBuffer ,
  hipJitOptionErrorLogBufferSizeBytes ,
  hipJitOptionOptimizationLevel ,
  hipJitOptionTargetFromContext ,
  hipJitOptionTarget ,
  hipJitOptionFallbackStrategy ,
  hipJitOptionGenerateDebugInfo ,
  hipJitOptionLogVerbose ,
  hipJitOptionGenerateLineInfo ,
  hipJitOptionCacheMode ,
  hipJitOptionSm3xOpt ,
  hipJitOptionFastCompile ,
  hipJitOptionNumOptions
}
 
enum  hipFuncAttribute {
  hipFuncAttributeMaxDynamicSharedMemorySize = 8 ,
  hipFuncAttributePreferredSharedMemoryCarveout = 9 ,
  hipFuncAttributeMax
}
 
enum  hipFuncCache_t {
  hipFuncCachePreferNone ,
  hipFuncCachePreferShared ,
  hipFuncCachePreferL1 ,
  hipFuncCachePreferEqual
}
 
enum  hipSharedMemConfig {
  hipSharedMemBankSizeDefault ,
  hipSharedMemBankSizeFourByte ,
  hipSharedMemBankSizeEightByte
}
 
enum  hipExternalMemoryHandleType {
  hipExternalMemoryHandleTypeOpaqueFd = 1 ,
  hipExternalMemoryHandleTypeOpaqueWin32 = 2 ,
  hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3 ,
  hipExternalMemoryHandleTypeD3D12Heap = 4 ,
  hipExternalMemoryHandleTypeD3D12Resource = 5 ,
  hipExternalMemoryHandleTypeD3D11Resource = 6 ,
  hipExternalMemoryHandleTypeD3D11ResourceKmt = 7
}
 
enum  hipExternalSemaphoreHandleType {
  hipExternalSemaphoreHandleTypeOpaqueFd = 1 ,
  hipExternalSemaphoreHandleTypeOpaqueWin32 = 2 ,
  hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3 ,
  hipExternalSemaphoreHandleTypeD3D12Fence = 4
}
 
enum  hipGLDeviceList {
  hipGLDeviceListAll = 1 ,
  hipGLDeviceListCurrentFrame = 2 ,
  hipGLDeviceListNextFrame = 3
}
 
enum  hipGraphicsRegisterFlags {
  hipGraphicsRegisterFlagsNone = 0 ,
  hipGraphicsRegisterFlagsReadOnly = 1 ,
  hipGraphicsRegisterFlagsWriteDiscard ,
  hipGraphicsRegisterFlagsSurfaceLoadStore = 4 ,
  hipGraphicsRegisterFlagsTextureGather
}
 
enum  hipGraphNodeType {
  hipGraphNodeTypeKernel = 0 ,
  hipGraphNodeTypeMemcpy = 1 ,
  hipGraphNodeTypeMemset = 2 ,
  hipGraphNodeTypeHost = 3 ,
  hipGraphNodeTypeGraph = 4 ,
  hipGraphNodeTypeEmpty = 5 ,
  hipGraphNodeTypeWaitEvent = 6 ,
  hipGraphNodeTypeEventRecord = 7 ,
  hipGraphNodeTypeExtSemaphoreSignal = 8 ,
  hipGraphNodeTypeExtSemaphoreWait = 9 ,
  hipGraphNodeTypeMemAlloc = 10 ,
  hipGraphNodeTypeMemFree = 11 ,
  hipGraphNodeTypeMemcpyFromSymbol = 12 ,
  hipGraphNodeTypeMemcpyToSymbol = 13 ,
  hipGraphNodeTypeCount
}
 
enum  hipKernelNodeAttrID {
  hipKernelNodeAttributeAccessPolicyWindow = 1 ,
  hipKernelNodeAttributeCooperative = 2
}
 
enum  hipAccessProperty {
  hipAccessPropertyNormal = 0 ,
  hipAccessPropertyStreaming = 1 ,
  hipAccessPropertyPersisting = 2
}
 
enum  hipGraphExecUpdateResult {
  hipGraphExecUpdateSuccess = 0x0 ,
  hipGraphExecUpdateError = 0x1 ,
  hipGraphExecUpdateErrorTopologyChanged = 0x2 ,
  hipGraphExecUpdateErrorNodeTypeChanged = 0x3 ,
  hipGraphExecUpdateErrorFunctionChanged ,
  hipGraphExecUpdateErrorParametersChanged ,
  hipGraphExecUpdateErrorNotSupported ,
  hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7
}
 
enum  hipStreamCaptureMode {
  hipStreamCaptureModeGlobal = 0 ,
  hipStreamCaptureModeThreadLocal ,
  hipStreamCaptureModeRelaxed
}
 
enum  hipStreamCaptureStatus {
  hipStreamCaptureStatusNone = 0 ,
  hipStreamCaptureStatusActive ,
  hipStreamCaptureStatusInvalidated
}
 
enum  hipStreamUpdateCaptureDependenciesFlags {
  hipStreamAddCaptureDependencies = 0 ,
  hipStreamSetCaptureDependencies
}
 
enum  hipGraphMemAttributeType {
  hipGraphMemAttrUsedMemCurrent = 0 ,
  hipGraphMemAttrUsedMemHigh ,
  hipGraphMemAttrReservedMemCurrent ,
  hipGraphMemAttrReservedMemHigh
}
 
enum  hipUserObjectFlags { hipUserObjectNoDestructorSync = 0x1 }
 
enum  hipUserObjectRetainFlags { hipGraphUserObjectMove = 0x1 }
 
enum  hipGraphInstantiateFlags {
  hipGraphInstantiateFlagAutoFreeOnLaunch ,
  hipGraphInstantiateFlagUpload ,
  hipGraphInstantiateFlagDeviceLaunch ,
  hipGraphInstantiateFlagUseNodePriority
}
 
enum  hipGraphDebugDotFlags {
  hipGraphDebugDotFlagsVerbose ,
  hipGraphDebugDotFlagsKernelNodeParams = 1 << 2 ,
  hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3 ,
  hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4 ,
  hipGraphDebugDotFlagsHostNodeParams = 1 << 5 ,
  hipGraphDebugDotFlagsEventNodeParams ,
  hipGraphDebugDotFlagsExtSemasSignalNodeParams ,
  hipGraphDebugDotFlagsExtSemasWaitNodeParams ,
  hipGraphDebugDotFlagsKernelNodeAttributes ,
  hipGraphDebugDotFlagsHandles
}
 
enum  hipMemAllocationGranularity_flags {
  hipMemAllocationGranularityMinimum = 0x0 ,
  hipMemAllocationGranularityRecommended = 0x1
}
 
enum  hipMemHandleType { hipMemHandleTypeGeneric = 0x0 }
 
enum  hipMemOperationType {
  hipMemOperationTypeMap = 0x1 ,
  hipMemOperationTypeUnmap = 0x2
}
 
enum  hipArraySparseSubresourceType {
  hipArraySparseSubresourceTypeSparseLevel = 0x0 ,
  hipArraySparseSubresourceTypeMiptail = 0x1
}
 
enum  hiprtcResult {
  HIPRTC_SUCCESS = 0 ,
  HIPRTC_ERROR_OUT_OF_MEMORY = 1 ,
  HIPRTC_ERROR_PROGRAM_CREATION_FAILURE = 2 ,
  HIPRTC_ERROR_INVALID_INPUT = 3 ,
  HIPRTC_ERROR_INVALID_PROGRAM = 4 ,
  HIPRTC_ERROR_INVALID_OPTION = 5 ,
  HIPRTC_ERROR_COMPILATION = 6 ,
  HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE = 7 ,
  HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = 8 ,
  HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = 9 ,
  HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID = 10 ,
  HIPRTC_ERROR_INTERNAL_ERROR = 11 ,
  HIPRTC_ERROR_LINKING = 100
}
 
enum  hiprtcJIT_option {
  HIPRTC_JIT_MAX_REGISTERS = 0 ,
  HIPRTC_JIT_THREADS_PER_BLOCK ,
  HIPRTC_JIT_WALL_TIME ,
  HIPRTC_JIT_INFO_LOG_BUFFER ,
  HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES ,
  HIPRTC_JIT_ERROR_LOG_BUFFER ,
  HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES ,
  HIPRTC_JIT_OPTIMIZATION_LEVEL ,
  HIPRTC_JIT_TARGET_FROM_HIPCONTEXT ,
  HIPRTC_JIT_TARGET ,
  HIPRTC_JIT_FALLBACK_STRATEGY ,
  HIPRTC_JIT_GENERATE_DEBUG_INFO ,
  HIPRTC_JIT_LOG_VERBOSE ,
  HIPRTC_JIT_GENERATE_LINE_INFO ,
  HIPRTC_JIT_CACHE_MODE ,
  HIPRTC_JIT_NEW_SM3X_OPT ,
  HIPRTC_JIT_FAST_COMPILE ,
  HIPRTC_JIT_GLOBAL_SYMBOL_NAMES ,
  HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS ,
  HIPRTC_JIT_GLOBAL_SYMBOL_COUNT ,
  HIPRTC_JIT_LTO ,
  HIPRTC_JIT_FTZ ,
  HIPRTC_JIT_PREC_DIV ,
  HIPRTC_JIT_PREC_SQRT ,
  HIPRTC_JIT_FMA ,
  HIPRTC_JIT_NUM_OPTIONS ,
  HIPRTC_JIT_IR_TO_ISA_OPT_EXT = 10000 ,
  HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT
}
 
enum  hiprtcJITInputType {
  HIPRTC_JIT_INPUT_CUBIN = 0 ,
  HIPRTC_JIT_INPUT_PTX ,
  HIPRTC_JIT_INPUT_FATBINARY ,
  HIPRTC_JIT_INPUT_OBJECT ,
  HIPRTC_JIT_INPUT_LIBRARY ,
  HIPRTC_JIT_INPUT_NVVM ,
  HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES ,
  HIPRTC_JIT_INPUT_LLVM_BITCODE = 100 ,
  HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE = 101 ,
  HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE = 102 ,
  HIPRTC_JIT_NUM_INPUT_TYPES = (HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES + 3)
}
 

Detailed Description

Macro Definition Documentation

◆ __dparm

#define __dparm (   x)

◆ __HIP_NODISCARD

#define __HIP_NODISCARD

◆ DEPRECATED

#define DEPRECATED (   msg)    __attribute__ ((deprecated(msg)))

◆ DEPRECATED_MSG

#define DEPRECATED_MSG   "This API is marked as deprecated and may not be supported in future releases. For more details please refer https://github.com/ROCm-Developer-Tools/HIP/blob/master/docs/markdown/hip_deprecated_api_list.md"

◆ GENERIC_GRID_LAUNCH

#define GENERIC_GRID_LAUNCH   1

◆ HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE   64

◆ HIP_LAUNCH_PARAM_BUFFER_POINTER

#define HIP_LAUNCH_PARAM_BUFFER_POINTER   ((void*)0x01)

◆ HIP_LAUNCH_PARAM_BUFFER_SIZE

#define HIP_LAUNCH_PARAM_BUFFER_SIZE   ((void*)0x02)

◆ HIP_LAUNCH_PARAM_END

#define HIP_LAUNCH_PARAM_END   ((void*)0x03)

◆ hipArrayCubemap

#define hipArrayCubemap   0x04

◆ hipArrayDefault

#define hipArrayDefault   0x00

Default HIP array allocation flag.

◆ hipArrayLayered

#define hipArrayLayered   0x01

◆ hipArraySurfaceLoadStore

#define hipArraySurfaceLoadStore   0x02

◆ hipArrayTextureGather

#define hipArrayTextureGather   0x08

◆ hipCooperativeLaunchMultiDeviceNoPostSync

#define hipCooperativeLaunchMultiDeviceNoPostSync   0x02

◆ hipCooperativeLaunchMultiDeviceNoPreSync

#define hipCooperativeLaunchMultiDeviceNoPreSync   0x01

◆ hipCpuDeviceId

#define hipCpuDeviceId   ((int)-1)

◆ hipDeviceLmemResizeToMax

#define hipDeviceLmemResizeToMax   0x10

◆ hipDeviceMallocDefault

#define hipDeviceMallocDefault   0x0

◆ hipDeviceMallocFinegrained

#define hipDeviceMallocFinegrained   0x1

Memory is allocated in fine grained region of device.

◆ hipDeviceMallocUncached

#define hipDeviceMallocUncached   0x3

Memory allocated will be uncached.

◆ hipDeviceMapHost

#define hipDeviceMapHost   0x8

◆ hipDeviceScheduleAuto

#define hipDeviceScheduleAuto   0x0

Automatically select between Spin and Yield.

◆ hipDeviceScheduleBlockingSync

#define hipDeviceScheduleBlockingSync   0x4

◆ hipDeviceScheduleMask

#define hipDeviceScheduleMask   0x7

◆ hipDeviceScheduleSpin

#define hipDeviceScheduleSpin   0x1

Dedicate a CPU core to spin-wait. Provides lowest latency, but burns a CPU core and may consume more power.

◆ hipDeviceScheduleYield

#define hipDeviceScheduleYield   0x2

Yield the CPU to the operating system when waiting. May increase latency, but lowers power and is friendlier to other threads in the system.

◆ hipEventBlockingSync

#define hipEventBlockingSync   0x1

Waiting will yield CPU. Power-friendly and usage-friendly but may increase latency.

◆ hipEventDefault

#define hipEventDefault   0x0

Default flags.

◆ hipEventDisableSystemFence

#define hipEventDisableSystemFence   0x20000000

Disable performing a system scope sequentially consistent memory fence when the event transitions from recording to recorded. This can be used for events that are only being used to measure timing, and do not require the event inspection operations (see hipEventSynchronize, hipEventQuery, and hipEventElapsedTime) to synchronize-with the work on which the recorded event (see hipEventRecord) is waiting. On some AMD GPU devices this can improve the accuracy of timing measurements by avoiding the cost of cache writeback and invalidation, and the performance impact of those actions on the execution of following work.

◆ hipEventDisableTiming

#define hipEventDisableTiming   0x2

Disable event's capability to record timing information. May improve performance.

◆ hipEventInterprocess

#define hipEventInterprocess   0x4

Event can support IPC. hipEventDisableTiming also must be set.

◆ hipEventReleaseToDevice

#define hipEventReleaseToDevice   0x40000000

Use a device-scope release when recording this event. This flag is useful to obtain more precise timings of commands between events. The flag is a no-op on CUDA platforms.

◆ hipEventReleaseToSystem

#define hipEventReleaseToSystem   0x80000000

Use a system-scope release when recording this event. This flag is useful to make non-coherent host memory visible to the host. The flag is a no-op on CUDA platforms.

◆ hipExtAnyOrderLaunch

#define hipExtAnyOrderLaunch   0x01

AnyOrderLaunch of kernels.

◆ hipExternalMemoryDedicated

#define hipExternalMemoryDedicated   0x1

◆ hipExtHostRegisterCoarseGrained

#define hipExtHostRegisterCoarseGrained   0x8

Coarse Grained host memory lock.

◆ hipHostMallocCoherent

#define hipHostMallocCoherent   0x40000000

Allocate coherent memory. Overrides HIP_COHERENT_HOST_ALLOC for specific allocation.

◆ hipHostMallocDefault

#define hipHostMallocDefault   0x0

Default pinned memory allocation on the host.

◆ hipHostMallocMapped

#define hipHostMallocMapped   0x2

Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer.

◆ hipHostMallocNonCoherent

#define hipHostMallocNonCoherent   0x80000000

Allocate non-coherent memory. Overrides HIP_COHERENT_HOST_ALLOC for specific allocation.

◆ hipHostMallocNumaUser

#define hipHostMallocNumaUser   0x20000000

Host memory allocation will follow numa policy set by user.

Note
This numa allocation flag is applicable on Linux, under development on Windows.

◆ hipHostMallocPortable

#define hipHostMallocPortable   0x1

Memory is considered allocated by all contexts.

◆ hipHostMallocWriteCombined

#define hipHostMallocWriteCombined   0x4

Allocates the memory as write-combined. On some system configurations, write-combined allocation may be transferred faster across the PCI Express bus, however, could have low read efficiency by most CPUs. It's a good option for data tranfer from host to device via mapped pinned memory.

◆ hipHostRegisterDefault

#define hipHostRegisterDefault   0x0

Memory is Mapped and Portable.

◆ hipHostRegisterIoMemory

#define hipHostRegisterIoMemory   0x4

Not supported.

◆ hipHostRegisterMapped

#define hipHostRegisterMapped   0x2

Map the allocation into the address space for the current device. The device pointer can be obtained with hipHostGetDevicePointer.

◆ hipHostRegisterPortable

#define hipHostRegisterPortable   0x1

Memory is considered registered by all contexts.

◆ hipHostRegisterReadOnly

#define hipHostRegisterReadOnly   0x08

This flag is ignored On AMD devices.

◆ hipInvalidDeviceId

#define hipInvalidDeviceId   ((int)-2)

◆ hipIpcMemLazyEnablePeerAccess

#define hipIpcMemLazyEnablePeerAccess   0

◆ hipMallocSignalMemory

#define hipMallocSignalMemory   0x2

Memory represents a HSA signal.

◆ hipMemAttachGlobal

#define hipMemAttachGlobal   0x01

Memory can be accessed by any stream on any device

◆ hipMemAttachHost

#define hipMemAttachHost   0x02

Memory cannot be accessed by any stream on any device.

◆ hipMemAttachSingle

#define hipMemAttachSingle   0x04

Memory can only be accessed by a single stream on the associated device.

◆ hipOccupancyDefault

#define hipOccupancyDefault   0x00

◆ hipOccupancyDisableCachingOverride

#define hipOccupancyDisableCachingOverride   0x01

◆ hipStreamDefault

#define hipStreamDefault   0x00

Flags that can be used with hipStreamCreateWithFlags. Default stream creation flags. These are used with hipStreamCreate().

◆ hipStreamNonBlocking

#define hipStreamNonBlocking   0x01

Stream does not implicitly synchronize with null stream.

◆ hipStreamPerThread

#define hipStreamPerThread   ((hipStream_t)2)

Implicit stream per application thread.

◆ hipStreamWaitValueAnd

#define hipStreamWaitValueAnd   0x2

◆ hipStreamWaitValueEq

#define hipStreamWaitValueEq   0x1

◆ hipStreamWaitValueGte

#define hipStreamWaitValueGte   0x0

◆ hipStreamWaitValueNor

#define hipStreamWaitValueNor   0x3

Typedef Documentation

◆ hipCtx_t

typedef struct ihipCtx_t* hipCtx_t

◆ hipDevice_t

typedef int hipDevice_t

◆ hipError_t

HIP error type

◆ hipEvent_t

typedef struct ihipEvent_t* hipEvent_t

◆ hipExternalMemory_t

typedef void* hipExternalMemory_t

◆ hipExternalSemaphore_t

typedef void* hipExternalSemaphore_t

◆ hipFunction_t

typedef struct ihipModuleSymbol_t* hipFunction_t

◆ hipGraph_t

typedef struct ihipGraph* hipGraph_t

An opaque value that represents a hip graph

◆ hipGraphExec_t

typedef struct hipGraphExec* hipGraphExec_t

An opaque value that represents a hip graph Exec

◆ hipGraphicsResource

typedef struct _hipGraphicsResource hipGraphicsResource

◆ hipGraphicsResource_t

◆ hipGraphNode_t

typedef struct hipGraphNode* hipGraphNode_t

An opaque value that represents a hip graph node

◆ hipHostFn_t

typedef void(* hipHostFn_t) (void *userData)

◆ hipMemGenericAllocationHandle_t

typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t

Generic handle for memory allocation

◆ hipMemPool_t

typedef struct ihipMemPoolHandle_t* hipMemPool_t

HIP memory pool

◆ hipModule_t

typedef struct ihipModule_t* hipModule_t

◆ hipStream_t

typedef struct ihipStream_t* hipStream_t

◆ hipUserObject_t

typedef struct hipUserObject* hipUserObject_t

An opaque value that represents a user obj

Enumeration Type Documentation

◆ hipAccessProperty

Enumerator
hipAccessPropertyNormal 
hipAccessPropertyStreaming 
hipAccessPropertyPersisting 

◆ hipArraySparseSubresourceType

Subresource types for sparse arrays

Enumerator
hipArraySparseSubresourceTypeSparseLevel 

Sparse level.

hipArraySparseSubresourceTypeMiptail 

Miptail.

◆ hipComputeMode

Enumerator
hipComputeModeDefault 
hipComputeModeExclusive 
hipComputeModeProhibited 
hipComputeModeExclusiveProcess 

◆ hipDeviceAttribute_t

hipDeviceAttribute_t

Enumerator
hipDeviceAttributeCudaCompatibleBegin 
hipDeviceAttributeEccEnabled 

Whether ECC support is enabled.

hipDeviceAttributeAccessPolicyMaxWindowSize 

Cuda only. The maximum size of the window policy in bytes.

hipDeviceAttributeAsyncEngineCount 

Cuda only. Asynchronous engines number.

hipDeviceAttributeCanMapHostMemory 

Whether host memory can be mapped into device address space.

hipDeviceAttributeCanUseHostPointerForRegisteredMem 

Cuda only. Device can access host registered memory at the same virtual address as the CPU

hipDeviceAttributeClockRate 

Peak clock frequency in kilohertz.

hipDeviceAttributeComputeMode 

Compute mode that device is currently in.

hipDeviceAttributeComputePreemptionSupported 

Cuda only. Device supports Compute Preemption.

hipDeviceAttributeConcurrentKernels 

Device can possibly execute multiple kernels concurrently.

hipDeviceAttributeConcurrentManagedAccess 

Device can coherently access managed memory concurrently with the CPU.

hipDeviceAttributeCooperativeLaunch 

Support cooperative launch.

hipDeviceAttributeCooperativeMultiDeviceLaunch 

Support cooperative launch on multiple devices.

hipDeviceAttributeDeviceOverlap 

Cuda only. Device can concurrently copy memory and execute a kernel. Deprecated. Use instead asyncEngineCount.

hipDeviceAttributeDirectManagedMemAccessFromHost 

Host can directly access managed memory on the device without migration

hipDeviceAttributeGlobalL1CacheSupported 

Cuda only. Device supports caching globals in L1.

hipDeviceAttributeHostNativeAtomicSupported 

Cuda only. Link between the device and the host supports native atomic operations.

hipDeviceAttributeIntegrated 

Device is integrated GPU.

hipDeviceAttributeIsMultiGpuBoard 

Multiple GPU devices.

hipDeviceAttributeKernelExecTimeout 

Run time limit for kernels executed on the device.

hipDeviceAttributeL2CacheSize 

Size of L2 cache in bytes. 0 if the device doesn't have L2 cache.

hipDeviceAttributeLocalL1CacheSupported 

caching locals in L1 is supported

hipDeviceAttributeLuid 

Cuda only. 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms.

hipDeviceAttributeLuidDeviceNodeMask 

Cuda only. Luid device node mask. Undefined on TCC and non-Windows platforms.

hipDeviceAttributeComputeCapabilityMajor 

Major compute capability version number.

hipDeviceAttributeManagedMemory 

Device supports allocating managed memory on this system.

hipDeviceAttributeMaxBlocksPerMultiProcessor 

Cuda only. Max block size per multiprocessor.

hipDeviceAttributeMaxBlockDimX 

Max block size in width.

hipDeviceAttributeMaxBlockDimY 

Max block size in height.

hipDeviceAttributeMaxBlockDimZ 

Max block size in depth.

hipDeviceAttributeMaxGridDimX 

Max grid size in width.

hipDeviceAttributeMaxGridDimY 

Max grid size in height.

hipDeviceAttributeMaxGridDimZ 

Max grid size in depth.

hipDeviceAttributeMaxSurface1D 

Maximum size of 1D surface.

hipDeviceAttributeMaxSurface1DLayered 

Cuda only. Maximum dimensions of 1D layered surface.

hipDeviceAttributeMaxSurface2D 

Maximum dimension (width, height) of 2D surface.

hipDeviceAttributeMaxSurface2DLayered 

Cuda only. Maximum dimensions of 2D layered surface.

hipDeviceAttributeMaxSurface3D 

Maximum dimension (width, height, depth) of 3D surface.

hipDeviceAttributeMaxSurfaceCubemap 

Cuda only. Maximum dimensions of Cubemap surface.

hipDeviceAttributeMaxSurfaceCubemapLayered 

Cuda only. Maximum dimension of Cubemap layered surface.

hipDeviceAttributeMaxTexture1DWidth 

Maximum size of 1D texture.

hipDeviceAttributeMaxTexture1DLayered 

Cuda only. Maximum dimensions of 1D layered texture.

hipDeviceAttributeMaxTexture1DLinear 

Maximum number of elements allocatable in a 1D linear texture. Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda.

hipDeviceAttributeMaxTexture1DMipmap 

Cuda only. Maximum size of 1D mipmapped texture.

hipDeviceAttributeMaxTexture2DWidth 

Maximum dimension width of 2D texture.

hipDeviceAttributeMaxTexture2DHeight 

Maximum dimension hight of 2D texture.

hipDeviceAttributeMaxTexture2DGather 

Cuda only. Maximum dimensions of 2D texture if gather operations performed.

hipDeviceAttributeMaxTexture2DLayered 

Cuda only. Maximum dimensions of 2D layered texture.

hipDeviceAttributeMaxTexture2DLinear 

Cuda only. Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.

hipDeviceAttributeMaxTexture2DMipmap 

Cuda only. Maximum dimensions of 2D mipmapped texture.

hipDeviceAttributeMaxTexture3DWidth 

Maximum dimension width of 3D texture.

hipDeviceAttributeMaxTexture3DHeight 

Maximum dimension height of 3D texture.

hipDeviceAttributeMaxTexture3DDepth 

Maximum dimension depth of 3D texture.

hipDeviceAttributeMaxTexture3DAlt 

Cuda only. Maximum dimensions of alternate 3D texture.

hipDeviceAttributeMaxTextureCubemap 

Cuda only. Maximum dimensions of Cubemap texture.

hipDeviceAttributeMaxTextureCubemapLayered 

Cuda only. Maximum dimensions of Cubemap layered texture.

hipDeviceAttributeMaxThreadsDim 

Maximum dimension of a block.

hipDeviceAttributeMaxThreadsPerBlock 

Maximum number of threads per block.

hipDeviceAttributeMaxThreadsPerMultiProcessor 

Maximum resident threads per multiprocessor.

hipDeviceAttributeMaxPitch 

Maximum pitch in bytes allowed by memory copies.

hipDeviceAttributeMemoryBusWidth 

Global memory bus width in bits.

hipDeviceAttributeMemoryClockRate 

Peak memory clock frequency in kilohertz.

hipDeviceAttributeComputeCapabilityMinor 

Minor compute capability version number.

hipDeviceAttributeMultiGpuBoardGroupID 

Cuda only. Unique ID of device group on the same multi-GPU board.

hipDeviceAttributeMultiprocessorCount 

Number of multiprocessors on the device.

hipDeviceAttributeName 

Device name.

hipDeviceAttributePageableMemoryAccess 

Device supports coherently accessing pageable memory without calling hipHostRegister on it

hipDeviceAttributePageableMemoryAccessUsesHostPageTables 

Device accesses pageable memory via the host's page tables.

hipDeviceAttributePciBusId 

PCI Bus ID.

hipDeviceAttributePciDeviceId 

PCI Device ID.

hipDeviceAttributePciDomainID 

PCI Domain ID.

hipDeviceAttributePersistingL2CacheMaxSize 

Cuda11 only. Maximum l2 persisting lines capacity in bytes.

hipDeviceAttributeMaxRegistersPerBlock 

32-bit registers available to a thread block. This number is shared by all thread blocks simultaneously resident on a multiprocessor.

hipDeviceAttributeMaxRegistersPerMultiprocessor 

32-bit registers available per block.

hipDeviceAttributeReservedSharedMemPerBlock 

Cuda11 only. Shared memory reserved by CUDA driver per block.

hipDeviceAttributeMaxSharedMemoryPerBlock 

Maximum shared memory available per block in bytes.

hipDeviceAttributeSharedMemPerBlockOptin 

Cuda only. Maximum shared memory per block usable by special opt in.

hipDeviceAttributeSharedMemPerMultiprocessor 

Cuda only. Shared memory available per multiprocessor.

hipDeviceAttributeSingleToDoublePrecisionPerfRatio 

Cuda only. Performance ratio of single precision to double precision.

hipDeviceAttributeStreamPrioritiesSupported 

Cuda only. Whether to support stream priorities.

hipDeviceAttributeSurfaceAlignment 

Cuda only. Alignment requirement for surfaces.

hipDeviceAttributeTccDriver 

Cuda only. Whether device is a Tesla device using TCC driver.

hipDeviceAttributeTextureAlignment 

Alignment requirement for textures.

hipDeviceAttributeTexturePitchAlignment 

Pitch alignment requirement for 2D texture references bound to pitched memory;.

hipDeviceAttributeTotalConstantMemory 

Constant memory size in bytes.

hipDeviceAttributeTotalGlobalMem 

Global memory available on devicice.

hipDeviceAttributeUnifiedAddressing 

Cuda only. An unified address space shared with the host.

hipDeviceAttributeUuid 

Cuda only. Unique ID in 16 byte.

hipDeviceAttributeWarpSize 

Warp size in threads.

hipDeviceAttributeMemoryPoolsSupported 

Device supports HIP Stream Ordered Memory Allocator.

hipDeviceAttributeVirtualMemoryManagementSupported 

Device supports HIP virtual memory management.

hipDeviceAttributeCudaCompatibleEnd 
hipDeviceAttributeAmdSpecificBegin 
hipDeviceAttributeClockInstructionRate 

Frequency in khz of the timer used by the device-side "clock*".

hipDeviceAttributeArch 

Device architecture.

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor 

Maximum Shared Memory PerMultiprocessor.

hipDeviceAttributeGcnArch 

Device gcn architecture.

hipDeviceAttributeGcnArchName 

Device gcnArch name in 256 bytes.

hipDeviceAttributeHdpMemFlushCntl 

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

hipDeviceAttributeHdpRegFlushCntl 

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc 

Supports cooperative launch on multiple devices with unmatched functions

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim 

Supports cooperative launch on multiple devices with unmatched grid dimensions

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim 

Supports cooperative launch on multiple devices with unmatched block dimensions

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem 

Supports cooperative launch on multiple devices with unmatched shared memories

hipDeviceAttributeIsLargeBar 

Whether it is LargeBar.

hipDeviceAttributeAsicRevision 

Revision of the GPU in this device.

hipDeviceAttributeCanUseStreamWaitValue 

'1' if Device supports hipStreamWaitValue32() and hipStreamWaitValue64(), '0' otherwise.

hipDeviceAttributeImageSupport 

'1' if Device supports image, '0' otherwise.

hipDeviceAttributePhysicalMultiProcessorCount 

All available physical compute units for the device

hipDeviceAttributeFineGrainSupport 

'1' if Device supports fine grain, '0' otherwise

hipDeviceAttributeWallClockRate 

Constant frequency of wall clock in kilohertz.

hipDeviceAttributeAmdSpecificEnd 
hipDeviceAttributeVendorSpecificBegin 

◆ hipDeviceP2PAttr

Enumerator
hipDevP2PAttrPerformanceRank 
hipDevP2PAttrAccessSupported 
hipDevP2PAttrNativeAtomicSupported 
hipDevP2PAttrHipArrayAccessSupported 

◆ hipExternalMemoryHandleType

Enumerator
hipExternalMemoryHandleTypeOpaqueFd 
hipExternalMemoryHandleTypeOpaqueWin32 
hipExternalMemoryHandleTypeOpaqueWin32Kmt 
hipExternalMemoryHandleTypeD3D12Heap 
hipExternalMemoryHandleTypeD3D12Resource 
hipExternalMemoryHandleTypeD3D11Resource 
hipExternalMemoryHandleTypeD3D11ResourceKmt 

◆ hipExternalSemaphoreHandleType

Enumerator
hipExternalSemaphoreHandleTypeOpaqueFd 
hipExternalSemaphoreHandleTypeOpaqueWin32 
hipExternalSemaphoreHandleTypeOpaqueWin32Kmt 
hipExternalSemaphoreHandleTypeD3D12Fence 

◆ hipFuncAttribute

Warning
On AMD devices and some Nvidia devices, these hints and controls are ignored.
Enumerator
hipFuncAttributeMaxDynamicSharedMemorySize 
hipFuncAttributePreferredSharedMemoryCarveout 
hipFuncAttributeMax 

◆ hipFuncCache_t

Warning
On AMD devices and some Nvidia devices, these hints and controls are ignored.
Enumerator
hipFuncCachePreferNone 

no preference for shared memory or L1 (default)

hipFuncCachePreferShared 

prefer larger shared memory and smaller L1 cache

hipFuncCachePreferL1 

prefer larger L1 cache and smaller shared memory

hipFuncCachePreferEqual 

prefer equal size L1 cache and shared memory

◆ hipGLDeviceList

HIP Devices used by current OpenGL Context.

Enumerator
hipGLDeviceListAll 

All hip devices used by current OpenGL context.

hipGLDeviceListCurrentFrame 

frame

Hip devices used by current OpenGL context in current

hipGLDeviceListNextFrame 

frame.

Hip devices used by current OpenGL context in next

◆ hipGraphDebugDotFlags

Enumerator
hipGraphDebugDotFlagsVerbose 

Output all debug data as if every debug flag is enabled

hipGraphDebugDotFlagsKernelNodeParams 

Adds hipKernelNodeParams to output

hipGraphDebugDotFlagsMemcpyNodeParams 

Adds hipMemcpy3DParms to output

hipGraphDebugDotFlagsMemsetNodeParams 

Adds hipMemsetParams to output

hipGraphDebugDotFlagsHostNodeParams 

Adds hipHostNodeParams to output

hipGraphDebugDotFlagsEventNodeParams 

Adds hipEvent_t handle from record and wait nodes to output

hipGraphDebugDotFlagsExtSemasSignalNodeParams 

Adds hipExternalSemaphoreSignalNodeParams values to output

hipGraphDebugDotFlagsExtSemasWaitNodeParams 

Adds hipExternalSemaphoreWaitNodeParams to output

hipGraphDebugDotFlagsKernelNodeAttributes 

Adds hipKernelNodeAttrID values to output

hipGraphDebugDotFlagsHandles 

Adds node handles and every kernel function handle to output

◆ hipGraphExecUpdateResult

Graph execution update result

Enumerator
hipGraphExecUpdateSuccess 

The update succeeded.

hipGraphExecUpdateError 

The update failed for an unexpected reason which is described in the return value of the function

hipGraphExecUpdateErrorTopologyChanged 

The update failed because the topology changed.

hipGraphExecUpdateErrorNodeTypeChanged 

The update failed because a node type changed.

hipGraphExecUpdateErrorFunctionChanged 

The update failed because the function of a kernel node changed.

hipGraphExecUpdateErrorParametersChanged 

The update failed because the parameters changed in a way that is not supported.

hipGraphExecUpdateErrorNotSupported 

The update failed because something about the node is not supported.

hipGraphExecUpdateErrorUnsupportedFunctionChange 

◆ hipGraphicsRegisterFlags

HIP Access falgs for Interop resources.

Enumerator
hipGraphicsRegisterFlagsNone 
hipGraphicsRegisterFlagsReadOnly 

HIP will not write to this registered resource.

hipGraphicsRegisterFlagsWriteDiscard 

HIP will only write and will not read from this registered resource.

hipGraphicsRegisterFlagsSurfaceLoadStore 

HIP will bind this resource to a surface.

hipGraphicsRegisterFlagsTextureGather 

HIP will perform texture gather operations on this registered resource.

◆ hipGraphInstantiateFlags

Enumerator
hipGraphInstantiateFlagAutoFreeOnLaunch 

Automatically free memory allocated in a graph before relaunching.

hipGraphInstantiateFlagUpload 

Automatically upload the graph after instantiaton.

hipGraphInstantiateFlagDeviceLaunch 

Instantiate the graph to be launchable from the device.

hipGraphInstantiateFlagUseNodePriority 

Run the graph using the per-node priority attributes rather than the priority of the stream it is launched into.

◆ hipGraphMemAttributeType

Enumerator
hipGraphMemAttrUsedMemCurrent 

Amount of memory, in bytes, currently associated with graphs.

hipGraphMemAttrUsedMemHigh 

High watermark of memory, in bytes, associated with graphs since the last time.

hipGraphMemAttrReservedMemCurrent 

Amount of memory, in bytes, currently allocated for graphs.

hipGraphMemAttrReservedMemHigh 

High watermark of memory, in bytes, currently allocated for graphs.

◆ hipGraphNodeType

hipGraphNodeType

Enumerator
hipGraphNodeTypeKernel 

GPU kernel node.

hipGraphNodeTypeMemcpy 

Memcpy node.

hipGraphNodeTypeMemset 

Memset node.

hipGraphNodeTypeHost 

Host (executable) node.

hipGraphNodeTypeGraph 

Node which executes an embedded graph.

hipGraphNodeTypeEmpty 

Empty (no-op) node.

hipGraphNodeTypeWaitEvent 

External event wait node.

hipGraphNodeTypeEventRecord 

External event record node.

hipGraphNodeTypeExtSemaphoreSignal 

External Semaphore signal node.

hipGraphNodeTypeExtSemaphoreWait 

External Semaphore wait node.

hipGraphNodeTypeMemAlloc 

Memory alloc node.

hipGraphNodeTypeMemFree 

Memory free node.

hipGraphNodeTypeMemcpyFromSymbol 

MemcpyFromSymbol node.

hipGraphNodeTypeMemcpyToSymbol 

MemcpyToSymbol node.

hipGraphNodeTypeCount 

◆ hipJitOption

hipJitOption

Enumerator
hipJitOptionMaxRegisters 
hipJitOptionThreadsPerBlock 
hipJitOptionWallTime 
hipJitOptionInfoLogBuffer 
hipJitOptionInfoLogBufferSizeBytes 
hipJitOptionErrorLogBuffer 
hipJitOptionErrorLogBufferSizeBytes 
hipJitOptionOptimizationLevel 
hipJitOptionTargetFromContext 
hipJitOptionTarget 
hipJitOptionFallbackStrategy 
hipJitOptionGenerateDebugInfo 
hipJitOptionLogVerbose 
hipJitOptionGenerateLineInfo 
hipJitOptionCacheMode 
hipJitOptionSm3xOpt 
hipJitOptionFastCompile 
hipJitOptionNumOptions 

◆ hipKernelNodeAttrID

Kernel node attributeID

Enumerator
hipKernelNodeAttributeAccessPolicyWindow 
hipKernelNodeAttributeCooperative 

◆ hipLimit_t

enum hipLimit_t
Enumerator
hipLimitStackSize 

limit of stack size in bytes on the current device

hipLimitPrintfFifoSize 

size limit in bytes of fifo used by printf call on the device

hipLimitMallocHeapSize 

limit of heap size in bytes on the current device

hipLimitRange 

supported limit range

◆ hipMemAccessFlags

Specifies the memory protection flags for mapping

Enumerator
hipMemAccessFlagsProtNone 

Default, make the address range not accessible.

hipMemAccessFlagsProtRead 

Set the address range read accessible.

hipMemAccessFlagsProtReadWrite 

Set the address range read-write accessible.

◆ hipMemAllocationGranularity_flags

Flags for granularity

Enumerator
hipMemAllocationGranularityMinimum 

Minimum granularity.

hipMemAllocationGranularityRecommended 

Recommended granularity for performance.

◆ hipMemAllocationHandleType

Flags for specifying handle types for memory pool allocations

Enumerator
hipMemHandleTypeNone 

Does not allow any export mechanism.

hipMemHandleTypePosixFileDescriptor 

Allows a file descriptor for exporting. Permitted only on POSIX systems.

hipMemHandleTypeWin32 

Allows a Win32 NT handle for exporting. (HANDLE)

hipMemHandleTypeWin32Kmt 

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

◆ hipMemAllocationType

Defines the allocation types

Enumerator
hipMemAllocationTypeInvalid 
hipMemAllocationTypePinned 

This allocation type is 'pinned', i.e. cannot migrate from its current location while the application is actively using it

hipMemAllocationTypeMax 

◆ hipMemHandleType

Memory handle type

Enumerator
hipMemHandleTypeGeneric 

Generic handle type.

◆ hipMemLocationType

Specifies the type of location

Enumerator
hipMemLocationTypeInvalid 
hipMemLocationTypeDevice 

Device location, thus it's HIP device ID.

◆ hipMemOperationType

Memory operation types

Enumerator
hipMemOperationTypeMap 

Map operation.

hipMemOperationTypeUnmap 

Unmap operation.

◆ hipMemoryAdvise

HIP Memory Advise values

Note
This memory advise enumeration is used on Linux, not Windows.
Enumerator
hipMemAdviseSetReadMostly 

Data will mostly be read and only occassionally be written to

hipMemAdviseUnsetReadMostly 

Undo the effect of hipMemAdviseSetReadMostly.

hipMemAdviseSetPreferredLocation 

Set the preferred location for the data as the specified device

hipMemAdviseUnsetPreferredLocation 

Clear the preferred location for the data.

hipMemAdviseSetAccessedBy 

Data will be accessed by the specified device so prevent page faults as much as possible

hipMemAdviseUnsetAccessedBy 

Let HIP to decide on the page faulting policy for the specified device

hipMemAdviseSetCoarseGrain 

The default memory model is fine-grain. That allows coherent operations between host and device, while executing kernels. The coarse-grain can be used for data that only needs to be coherent at dispatch boundaries for better performance

hipMemAdviseUnsetCoarseGrain 

Restores cache coherency policy back to fine-grain.

◆ hipMemoryType

hipMemoryType (for pointer attributes)

Note
hipMemoryType enum values are different from cudaMemoryType enum values. In this case, memory type translation for hipPointerGetAttributes needs to be handled properly on nvidia platform to get the correct memory type in CUDA. Developers should use '#ifdef' in order to assign the correct enum values depending on Nvidia or AMD platform.
cudaMemoryTypeUnregistered is currently not supported due to HIP functionality backward compatibility.
Enumerator
hipMemoryTypeHost 

Memory is physically located on host.

hipMemoryTypeDevice 

Memory is physically located on device. (see deviceId for specific device)

hipMemoryTypeArray 

Array memory, physically located on device. (see deviceId for specific device)

hipMemoryTypeUnified 

Not used currently.

hipMemoryTypeManaged 

Managed memory, automaticallly managed by the unified memory system

◆ hipMemPoolAttr

HIP memory pool attributes

Enumerator
hipMemPoolReuseFollowEventDependencies 

(value type = int) Allow hipMemAllocAsync to use memory asynchronously freed in another streams as long as a stream ordering dependency of the allocating stream on the free action exists. hip events and null stream interactions can create the required stream ordered dependencies. (default enabled)

hipMemPoolReuseAllowOpportunistic 

(value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)

hipMemPoolReuseAllowInternalDependencies 

(value type = int) Allow hipMemAllocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by cuFreeAsync (default enabled).

hipMemPoolAttrReleaseThreshold 

(value type = uint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)

hipMemPoolAttrReservedMemCurrent 

(value type = uint64_t) Amount of backing memory currently allocated for the mempool.

hipMemPoolAttrReservedMemHigh 

(value type = uint64_t) High watermark of backing memory allocated for the mempool since the last time it was reset. High watermark can only be reset to zero.

hipMemPoolAttrUsedMemCurrent 

(value type = uint64_t) Amount of memory from the pool that is currently in use by the application.

hipMemPoolAttrUsedMemHigh 

(value type = uint64_t) High watermark of the amount of memory from the pool that was in use by the application since the last time it was reset. High watermark can only be reset to zero.

◆ hipMemRangeAttribute

HIP range attributes

Enumerator
hipMemRangeAttributeReadMostly 

Whether the range will mostly be read and only occassionally be written to

hipMemRangeAttributePreferredLocation 

The preferred location of the range.

hipMemRangeAttributeAccessedBy 

Memory range has hipMemAdviseSetAccessedBy set for the specified device

hipMemRangeAttributeLastPrefetchLocation 

prefetched

The last location to where the range was

hipMemRangeAttributeCoherencyMode 

Returns coherency mode hipMemRangeCoherencyMode for the range

◆ hipMemRangeCoherencyMode

HIP Coherency Mode

Enumerator
hipMemRangeCoherencyModeFineGrain 

Updates to memory with this attribute can be done coherently from all devices

hipMemRangeCoherencyModeCoarseGrain 

Writes to memory with this attribute can be performed by a single device at a time

hipMemRangeCoherencyModeIndeterminate 

Memory region queried contains subregions with both hipMemRangeCoherencyModeFineGrain and hipMemRangeCoherencyModeCoarseGrain attributes

◆ hiprtcJIT_option

hiprtc JIT option

Enumerator
HIPRTC_JIT_MAX_REGISTERS 

Maximum registers.

HIPRTC_JIT_THREADS_PER_BLOCK 

Thread per block.

HIPRTC_JIT_WALL_TIME 

Time from aall clock.

HIPRTC_JIT_INFO_LOG_BUFFER 

Log buffer info.

HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES 

Log buffer size in bytes.

HIPRTC_JIT_ERROR_LOG_BUFFER 

Log buffer error.

HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES 

Log buffer size in bytes.

HIPRTC_JIT_OPTIMIZATION_LEVEL 

Optimization level.

HIPRTC_JIT_TARGET_FROM_HIPCONTEXT 
HIPRTC_JIT_TARGET 

JIT target.

HIPRTC_JIT_FALLBACK_STRATEGY 

Fallback strategy.

HIPRTC_JIT_GENERATE_DEBUG_INFO 

Generate debug information.

HIPRTC_JIT_LOG_VERBOSE 

Log verbose.

HIPRTC_JIT_GENERATE_LINE_INFO 

Generate line information.

HIPRTC_JIT_CACHE_MODE 

Cache mode.

HIPRTC_JIT_NEW_SM3X_OPT 

New SM3X option.

HIPRTC_JIT_FAST_COMPILE 

Fast compile.

HIPRTC_JIT_GLOBAL_SYMBOL_NAMES 

Global symbol names.

HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS 

Global symbol address.

HIPRTC_JIT_GLOBAL_SYMBOL_COUNT 

Global symbol count.

HIPRTC_JIT_LTO 

LTO.

HIPRTC_JIT_FTZ 

FTZ.

HIPRTC_JIT_PREC_DIV 

Prec_VIV.

HIPRTC_JIT_PREC_SQRT 

PREC_SQRT.

HIPRTC_JIT_FMA 

FMA.

HIPRTC_JIT_NUM_OPTIONS 

Number of options.

HIPRTC_JIT_IR_TO_ISA_OPT_EXT 

AMD only. Linker options to be passed on to.

HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT 

AMD only. Count of linker options.

◆ hiprtcJITInputType

hiprtc JIT input type

Enumerator
HIPRTC_JIT_INPUT_CUBIN 

Input cubin.

HIPRTC_JIT_INPUT_PTX 

Input PTX.

HIPRTC_JIT_INPUT_FATBINARY 

Input fat binary.

HIPRTC_JIT_INPUT_OBJECT 

Input object.

HIPRTC_JIT_INPUT_LIBRARY 

Input library.

HIPRTC_JIT_INPUT_NVVM 

Input NVVM.

HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES 

Number of legacy input type.

HIPRTC_JIT_INPUT_LLVM_BITCODE 

LLVM bitcode.

HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE 

LLVM bundled bitcode.

HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE 

LLVM archives of boundled bitcode.

HIPRTC_JIT_NUM_INPUT_TYPES 

◆ hiprtcResult

hiprtc error code

Enumerator
HIPRTC_SUCCESS 

Success.

HIPRTC_ERROR_OUT_OF_MEMORY 

Out of memory.

HIPRTC_ERROR_PROGRAM_CREATION_FAILURE 

Failed to create program.

HIPRTC_ERROR_INVALID_INPUT 

Invalid input.

HIPRTC_ERROR_INVALID_PROGRAM 

Invalid program.

HIPRTC_ERROR_INVALID_OPTION 

Invalid option.

HIPRTC_ERROR_COMPILATION 

Compilation error.

HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE 

Failed in builtin operation.

HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION 

No name expression after compilation.

HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION 

No lowered names before compilation.

HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID 

Invalid name expression.

HIPRTC_ERROR_INTERNAL_ERROR 

Internal error.

HIPRTC_ERROR_LINKING 

Error in linking.

◆ hipSharedMemConfig

Warning
On AMD devices and some Nvidia devices, these hints and controls are ignored.
Enumerator
hipSharedMemBankSizeDefault 

The compiler selects a device-specific value for the banking.

hipSharedMemBankSizeFourByte 

Shared mem is banked at 4-bytes intervals and performs best when adjacent threads access data 4 bytes apart.

hipSharedMemBankSizeEightByte 

Shared mem is banked at 8-byte intervals and performs best when adjacent threads access data 4 bytes apart.

◆ hipStreamCaptureMode

Enumerator
hipStreamCaptureModeGlobal 
hipStreamCaptureModeThreadLocal 
hipStreamCaptureModeRelaxed 

◆ hipStreamCaptureStatus

Enumerator
hipStreamCaptureStatusNone 

Stream is not capturing.

hipStreamCaptureStatusActive 

Stream is actively capturing.

hipStreamCaptureStatusInvalidated 

Stream is part of a capture sequence that has been invalidated, but not terminated

◆ hipStreamUpdateCaptureDependenciesFlags

Enumerator
hipStreamAddCaptureDependencies 

Add new nodes to the dependency set.

hipStreamSetCaptureDependencies 

Replace the dependency set with the new nodes.

◆ hipUserObjectFlags

Enumerator
hipUserObjectNoDestructorSync 

Destructor execution is not synchronized.

◆ hipUserObjectRetainFlags

Enumerator
hipGraphUserObjectMove 

Add new reference or retain.