Global enum and defines

Data Structures | Macros | Typedefs | Enumerations

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	hipExternalMemoryMipmappedArrayDesc
struct	hipExternalSemaphoreHandleDesc
struct	hipExternalSemaphoreSignalParams
struct	hipExternalSemaphoreWaitParams
struct	hipHostNodeParams
struct	hipKernelNodeParams
struct	hipMemsetParams
struct	hipMemAllocNodeParams
struct	hipAccessPolicyWindow
union	hipKernelNodeAttrValue
struct	HIP_MEMSET_NODE_PARAMS
struct	hipMemAllocationProp
struct	hipExternalSemaphoreSignalNodeParams
struct	hipExternalSemaphoreWaitNodeParams
struct	hipArrayMapInfo

Macros
#define	hipGetDeviceProperties   hipGetDevicePropertiesR0600
#define	hipDeviceProp_t   hipDeviceProp_tR0600
#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   0x01
#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 hipGraphicsResource *	hipGraphicsResource_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
typedef unsigned int	GLuint
typedef unsigned int	GLenum

Enumerations
enum	hipMemoryType {   hipMemoryTypeUnregistered = 0 ,   hipMemoryTypeHost = 1 ,   hipMemoryTypeDevice = 2 ,   hipMemoryTypeManaged = 3 ,   hipMemoryTypeArray = 10 ,   hipMemoryTypeUnified = 11 }
enum	hipDeviceAttribute_t {   hipDeviceAttributeCudaCompatibleBegin = 0 ,   hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin ,   hipDeviceAttributeAccessPolicyMaxWindowSize ,   hipDeviceAttributeAsyncEngineCount ,   hipDeviceAttributeCanMapHostMemory ,   hipDeviceAttributeCanUseHostPointerForRegisteredMem ,   hipDeviceAttributeClockRate ,   hipDeviceAttributeComputeMode ,   hipDeviceAttributeComputePreemptionSupported ,   hipDeviceAttributeConcurrentKernels ,   hipDeviceAttributeConcurrentManagedAccess ,   hipDeviceAttributeCooperativeLaunch ,   hipDeviceAttributeCooperativeMultiDeviceLaunch ,   hipDeviceAttributeHostRegisterSupported ,   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 ,   hipDeviceAttributeUnused1 ,   hipDeviceAttributePageableMemoryAccess ,   hipDeviceAttributePageableMemoryAccessUsesHostPageTables ,   hipDeviceAttributePciBusId ,   hipDeviceAttributePciDeviceId ,   hipDeviceAttributePciDomainID ,   hipDeviceAttributePersistingL2CacheMaxSize ,   hipDeviceAttributeMaxRegistersPerBlock ,   hipDeviceAttributeMaxRegistersPerMultiprocessor ,   hipDeviceAttributeReservedSharedMemPerBlock ,   hipDeviceAttributeMaxSharedMemoryPerBlock ,   hipDeviceAttributeSharedMemPerBlockOptin ,   hipDeviceAttributeSharedMemPerMultiprocessor ,   hipDeviceAttributeSingleToDoublePrecisionPerfRatio ,   hipDeviceAttributeStreamPrioritiesSupported ,   hipDeviceAttributeSurfaceAlignment ,   hipDeviceAttributeTccDriver ,   hipDeviceAttributeTextureAlignment ,   hipDeviceAttributeTexturePitchAlignment ,   hipDeviceAttributeTotalConstantMemory ,   hipDeviceAttributeTotalGlobalMem ,   hipDeviceAttributeUnifiedAddressing ,   hipDeviceAttributeUnused2 ,   hipDeviceAttributeWarpSize ,   hipDeviceAttributeMemoryPoolsSupported ,   hipDeviceAttributeVirtualMemoryManagementSupported ,   hipDeviceAttributeCudaCompatibleEnd = 9999 ,   hipDeviceAttributeAmdSpecificBegin = 10000 ,   hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin ,   hipDeviceAttributeUnused3 ,   hipDeviceAttributeMaxSharedMemoryPerMultiprocessor ,   hipDeviceAttributeUnused4 ,   hipDeviceAttributeUnused5 ,   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	hipFlushGPUDirectRDMAWritesOptions {   hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0 ,   hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1 }
enum	hipGPUDirectRDMAWritesOrdering {   hipGPUDirectRDMAWritesOrderingNone = 0 ,   hipGPUDirectRDMAWritesOrderingOwner = 100 ,   hipGPUDirectRDMAWritesOrderingAllDevices = 200 }
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 ,   hipExternalMemoryHandleTypeNvSciBuf = 8 }
enum	hipExternalSemaphoreHandleType {   hipExternalSemaphoreHandleTypeOpaqueFd = 1 ,   hipExternalSemaphoreHandleTypeOpaqueWin32 = 2 ,   hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3 ,   hipExternalSemaphoreHandleTypeD3D12Fence = 4 ,   hipExternalSemaphoreHandleTypeD3D11Fence = 5 ,   hipExternalSemaphoreHandleTypeNvSciSync = 6 ,   hipExternalSemaphoreHandleTypeKeyedMutex = 7 ,   hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8 ,   hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9 ,   hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 }
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) }
enum	hipGLDeviceList {   hipGLDeviceListAll = 1 ,   hipGLDeviceListCurrentFrame = 2 ,   hipGLDeviceListNextFrame = 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

◆ hipDeviceProp_t

#define hipDeviceProp_t   hipDeviceProp_tR0600

◆ 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.

◆ hipGetDeviceProperties

#define hipGetDeviceProperties   hipGetDevicePropertiesR0600

◆ 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   0x01

◆ 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

◆ GLenum

typedef unsigned int GLenum

GLenum as uint.

◆ GLuint

typedef unsigned int GLuint

GLuint as uint.

◆ hipCtx_t

typedef struct ihipCtx_t* hipCtx_t

◆ hipDevice_t

typedef int hipDevice_t

◆ hipError_t

enum __HIP_NODISCARD 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

typedef 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

enum hipAccessProperty

Enumerator
hipAccessPropertyNormal
hipAccessPropertyStreaming
hipAccessPropertyPersisting

◆ hipArraySparseSubresourceType

enum hipArraySparseSubresourceType

Subresource types for sparse arrays

Enumerator
hipArraySparseSubresourceTypeSparseLevel	Sparse level.
hipArraySparseSubresourceTypeMiptail	Miptail.

◆ hipComputeMode

enum hipComputeMode

Enumerator
hipComputeModeDefault
hipComputeModeExclusive
hipComputeModeProhibited
hipComputeModeExclusiveProcess

◆ hipDeviceAttribute_t

enum hipDeviceAttribute_t

hipDeviceAttribute_t hipDeviceAttributeUnused number: 5

Enumerator
hipDeviceAttributeCudaCompatibleBegin
hipDeviceAttributeEccEnabled	Whether ECC support is enabled.
hipDeviceAttributeAccessPolicyMaxWindowSize	Cuda only. The maximum size of the window policy in bytes.
hipDeviceAttributeAsyncEngineCount	Asynchronous engines number.
hipDeviceAttributeCanMapHostMemory	Whether host memory can be mapped into device address space.
hipDeviceAttributeCanUseHostPointerForRegisteredMem	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	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.
hipDeviceAttributeHostRegisterSupported	Can device support host memory registration via hipHostRegister.
hipDeviceAttributeDeviceOverlap	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	Device supports caching globals in L1.
hipDeviceAttributeHostNativeAtomicSupported	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	8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms
hipDeviceAttributeLuidDeviceNodeMask	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	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	Maximum dimensions of 1D layered texture.
hipDeviceAttributeMaxTexture1DLinear	Maximum number of elements allocatable in a 1D linear texture. Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda.
hipDeviceAttributeMaxTexture1DMipmap	Maximum size of 1D mipmapped texture.
hipDeviceAttributeMaxTexture2DWidth	Maximum dimension width of 2D texture.
hipDeviceAttributeMaxTexture2DHeight	Maximum dimension hight of 2D texture.
hipDeviceAttributeMaxTexture2DGather	Maximum dimensions of 2D texture if gather operations performed.
hipDeviceAttributeMaxTexture2DLayered	Maximum dimensions of 2D layered texture.
hipDeviceAttributeMaxTexture2DLinear	Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.
hipDeviceAttributeMaxTexture2DMipmap	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	Maximum dimensions of alternate 3D texture.
hipDeviceAttributeMaxTextureCubemap	Maximum dimensions of Cubemap texture.
hipDeviceAttributeMaxTextureCubemapLayered	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	Unique ID of device group on the same multi-GPU board.
hipDeviceAttributeMultiprocessorCount	Number of multiprocessors on the device.
hipDeviceAttributeUnused1	Previously hipDeviceAttributeName.
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	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	Shared memory reserved by CUDA driver per block.
hipDeviceAttributeMaxSharedMemoryPerBlock	Maximum shared memory available per block in bytes.
hipDeviceAttributeSharedMemPerBlockOptin	Maximum shared memory per block usable by special opt in.
hipDeviceAttributeSharedMemPerMultiprocessor	Shared memory available per multiprocessor.
hipDeviceAttributeSingleToDoublePrecisionPerfRatio	Cuda only. Performance ratio of single precision to double precision.
hipDeviceAttributeStreamPrioritiesSupported	Whether to support stream priorities.
hipDeviceAttributeSurfaceAlignment	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.
hipDeviceAttributeUnused2	Previously hipDeviceAttributeUuid.
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*".
hipDeviceAttributeUnused3	Previously hipDeviceAttributeArch.
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor	Maximum Shared Memory PerMultiprocessor.
hipDeviceAttributeUnused4	Previously hipDeviceAttributeGcnArch.
hipDeviceAttributeUnused5	Previously hipDeviceAttributeGcnArchName.
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

enum hipDeviceP2PAttr

Enumerator
hipDevP2PAttrPerformanceRank
hipDevP2PAttrAccessSupported
hipDevP2PAttrNativeAtomicSupported
hipDevP2PAttrHipArrayAccessSupported

◆ hipExternalMemoryHandleType

enum hipExternalMemoryHandleType

Enumerator
hipExternalMemoryHandleTypeOpaqueFd
hipExternalMemoryHandleTypeOpaqueWin32
hipExternalMemoryHandleTypeOpaqueWin32Kmt
hipExternalMemoryHandleTypeD3D12Heap
hipExternalMemoryHandleTypeD3D12Resource
hipExternalMemoryHandleTypeD3D11Resource
hipExternalMemoryHandleTypeD3D11ResourceKmt
hipExternalMemoryHandleTypeNvSciBuf

◆ hipExternalSemaphoreHandleType

enum hipExternalSemaphoreHandleType

Enumerator
hipExternalSemaphoreHandleTypeOpaqueFd
hipExternalSemaphoreHandleTypeOpaqueWin32
hipExternalSemaphoreHandleTypeOpaqueWin32Kmt
hipExternalSemaphoreHandleTypeD3D12Fence
hipExternalSemaphoreHandleTypeD3D11Fence
hipExternalSemaphoreHandleTypeNvSciSync
hipExternalSemaphoreHandleTypeKeyedMutex
hipExternalSemaphoreHandleTypeKeyedMutexKmt
hipExternalSemaphoreHandleTypeTimelineSemaphoreFd
hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

◆ hipFlushGPUDirectRDMAWritesOptions

enum hipFlushGPUDirectRDMAWritesOptions

Enumerator
hipFlushGPUDirectRDMAWritesOptionHost
hipFlushGPUDirectRDMAWritesOptionMemOps

◆ hipFuncAttribute

enum hipFuncAttribute

Warning

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

Enumerator
hipFuncAttributeMaxDynamicSharedMemorySize
hipFuncAttributePreferredSharedMemoryCarveout
hipFuncAttributeMax

◆ hipFuncCache_t

enum 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

enum 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

◆ hipGPUDirectRDMAWritesOrdering

enum hipGPUDirectRDMAWritesOrdering

Enumerator
hipGPUDirectRDMAWritesOrderingNone
hipGPUDirectRDMAWritesOrderingOwner
hipGPUDirectRDMAWritesOrderingAllDevices

◆ hipGraphDebugDotFlags

enum 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

enum 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

enum 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

enum 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

enum 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

enum 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

enum hipJitOption

hipJitOption

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

◆ hipKernelNodeAttrID

enum hipKernelNodeAttrID

Kernel node attributeID

Enumerator
hipKernelNodeAttributeAccessPolicyWindow
hipKernelNodeAttributeCooperative

◆ hipLimit_t

enum hipLimit_t

hipLimit

Note

In HIP device limit-related APIs, any input limit value other than those defined in the enum is treated as "UnsupportedLimit" by default.

Enumerator
hipLimitStackSize	Limit of stack size in bytes on the current device, per thread. The size is in units of 256 dwords, up to the limit of (128K - 16)
hipLimitPrintfFifoSize	Size limit in bytes of fifo used by printf call on the device. Currently not supported
hipLimitMallocHeapSize	Limit of heap size in bytes on the current device, should be less than the global memory size on the device
hipLimitRange	Supported limit range.

◆ hipMemAccessFlags

enum 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

enum hipMemAllocationGranularity_flags

Flags for granularity

Enumerator
hipMemAllocationGranularityMinimum	Minimum granularity.
hipMemAllocationGranularityRecommended	Recommended granularity for performance.

◆ hipMemAllocationHandleType

enum 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

enum 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

enum hipMemHandleType

Memory handle type

Enumerator
hipMemHandleTypeGeneric	Generic handle type.

◆ hipMemLocationType

enum hipMemLocationType

Specifies the type of location

Enumerator
hipMemLocationTypeInvalid
hipMemLocationTypeDevice	Device location, thus it's HIP device ID.

◆ hipMemOperationType

enum hipMemOperationType

Memory operation types

Enumerator
hipMemOperationTypeMap	Map operation.
hipMemOperationTypeUnmap	Unmap operation.

◆ hipMemoryAdvise

enum 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

enum hipMemoryType

hipMemoryType (for pointer attributes)

Note

hipMemoryType enum values are combination of cudaMemoryType and cuMemoryType and AMD specific enum values.

Enumerator
hipMemoryTypeUnregistered	Unregistered memory.
hipMemoryTypeHost	Memory is physically located on host.
hipMemoryTypeDevice	Memory is physically located on device. (see deviceId for specific device)
hipMemoryTypeManaged	Managed memory, automaticallly managed by the unified memory system place holder for new values.
hipMemoryTypeArray	Array memory, physically located on device. (see deviceId for specific device)
hipMemoryTypeUnified	unified address space

◆ hipMemPoolAttr

enum 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

enum 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

enum 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

enum 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

enum 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

enum 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

enum 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

enum hipStreamCaptureMode

Enumerator
hipStreamCaptureModeGlobal
hipStreamCaptureModeThreadLocal
hipStreamCaptureModeRelaxed

◆ hipStreamCaptureStatus

enum 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

enum hipStreamUpdateCaptureDependenciesFlags

Enumerator
hipStreamAddCaptureDependencies	Add new nodes to the dependency set.
hipStreamSetCaptureDependencies	Replace the dependency set with the new nodes.

◆ hipUserObjectFlags

enum hipUserObjectFlags

Enumerator
hipUserObjectNoDestructorSync	Destructor execution is not synchronized.

◆ hipUserObjectRetainFlags

enum hipUserObjectRetainFlags

Enumerator
hipGraphUserObjectMove	Add new reference or retain.