Global enum and defines

Global enum and defines#

HIP Runtime API Reference: Global enum and defines

Namespaces
namespace	hip_impl

Data Structures
struct	hipDeviceArch_t

struct	hipUUID

struct	hipDeviceProp_t

struct	hipPointerAttribute_t

struct	hipDevSmResource

struct	hipDevWorkqueueConfigResource

struct	hipDevWorkqueueResource

struct	hipDevResource

struct	hipDevSmResourceGroupParams

struct	hipIpcMemHandle_t

struct	hipIpcEventHandle_t

struct	hipMemFabricHandle_t

struct	hipFuncAttributes

union	hipStreamBatchMemOpParams
	Union representing batch memory operation parameters for HIP streams. More...

struct	hipBatchMemOpNodeParams
	Structure representing node parameters for batch memory operations in HIP graphs. More...

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

struct	hipLaunchMemSyncDomainMap

struct	hipExtDynDataPrefetchRegion
	Describes one 2D memory region to prefetch into L2 cache. More...

struct	hipExtDynDataPrefetchConfig
	Configuration for dynamic data prefetch. More...

union	hipLaunchAttributeValue

struct	hipGraphInstantiateParams

struct	hipMemAllocationProp

struct	hipExternalSemaphoreSignalNodeParams

struct	hipExternalSemaphoreWaitNodeParams

struct	hipArrayMapInfo

struct	hipMemcpyNodeParams

struct	hipChildGraphNodeParams

struct	hipEventWaitNodeParams

struct	hipEventRecordNodeParams

struct	hipMemFreeNodeParams

struct	hipGraphNodeParams

struct	hipGraphEdgeData

struct	hipLaunchAttribute

struct	hipLaunchConfig_t

struct	HIP_LAUNCH_CONFIG

struct	hipArrayMemoryRequirements

union	hipDevResource.__unnamed16__

union	hipExternalMemoryHandleDesc.handle

struct	hipExternalMemoryHandleDesc.handle.win32

union	hipExternalSemaphoreHandleDesc.handle

struct	hipExternalSemaphoreHandleDesc.handle.win32

struct	hipExternalSemaphoreSignalParams.params

struct	hipExternalSemaphoreSignalParams.params.fence

union	hipExternalSemaphoreSignalParams.params.nvSciSync

struct	hipExternalSemaphoreSignalParams.params.keyedMutex

struct	hipExternalSemaphoreWaitParams.params

struct	hipExternalSemaphoreWaitParams.params.fence

union	hipExternalSemaphoreWaitParams.params.nvSciSync

struct	hipExternalSemaphoreWaitParams.params.keyedMutex

struct	hipLaunchAttributeValue.clusterDim
	Specifies the desired cluster dimensions for a kernel launch. More...

union	hipMemAllocationProp.__unnamed35__

struct	hipMemAllocationProp.allocFlags

union	hipArrayMapInfo.resource

union	hipArrayMapInfo.subresource

struct	hipArrayMapInfo.subresource.sparseLevel

struct	hipArrayMapInfo.subresource.miptail

union	hipArrayMapInfo.memHandle

union	hipGraphNodeParams.__unnamed43__

union	hipLaunchAttribute.__unnamed45__

Macros
#define	hipGetDeviceProperties hipGetDevicePropertiesR0600

#define	hipDeviceProp_t hipDeviceProp_tR0600

#define	hipChooseDevice hipChooseDeviceR0600

#define	__HIP_NODISCARD

#define	HIP_GET_PROC_ADDRESS_DEFAULT 0x0

#define	HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

#define	HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

#define	GENERIC_GRID_LAUNCH 1

#define	HIP_DEPRECATED(msg) __attribute__((deprecated(msg)))

#define	HIP_DEPRECATED_MSG

#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) = x

#define	HIP_RESOURCE_ABI_BYTES 40

#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	hipEventRecordDefault 0x00

#define	hipEventRecordExternal 0x01

#define	hipEventWaitDefault 0x00

#define	hipEventWaitExternal 0x01

#define	hipEventDisableSystemFence 0x20000000

#define	hipEventReleaseToDevice 0x40000000

#define	hipEventReleaseToSystem 0x80000000

#define	hipEnableDefault 0x0

#define	hipEnableLegacyStream 0x1

#define	hipEnablePerThreadDefaultStream 0x2

#define	hipHostAllocDefault 0x0

#define	hipHostMallocDefault 0x0

#define	hipHostAllocPortable 0x1

#define	hipHostMallocPortable 0x1

#define	hipHostAllocMapped 0x2

#define	hipHostMallocMapped 0x2

#define	hipHostAllocWriteCombined 0x4

#define	hipHostMallocWriteCombined 0x4

#define	hipHostMallocUncached 0x10000000

#define	hipHostAllocUncached hipHostMallocUncached

#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	hipDeviceMallocContiguous 0x4

#define	hipHostRegisterDefault 0x0

#define	hipHostRegisterPortable 0x1

#define	hipHostRegisterMapped 0x2

#define	hipHostRegisterIoMemory 0x4

#define	hipHostRegisterReadOnly 0x08

#define	hipExtHostRegisterCoarseGrained 0x8

#define	hipExtHostRegisterUncached 0x80000000

#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	hipStreamWriteValueDefault 0x0

#define	hipExtStreamWriteValueIncrement 0x1000

#define	hipExtStreamWriteValueDecrement 0x1001

#define	hipStreamPerThread ((hipStream_t)2)

#define	hipStreamLegacy ((hipStream_t)1)

#define	hipExternalMemoryDedicated 0x1

#define	HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

#define	hipStreamAttrID hipLaunchAttributeID

#define	hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

#define	hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

#define	hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

#define	hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

#define	hipStreamAttributePriority hipLaunchAttributePriority

#define	hipStreamAttrValue hipLaunchAttributeValue

#define	hipKernelNodeAttrID hipLaunchAttributeID

#define	hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

#define	hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

#define	hipKernelNodeAttributePriority hipLaunchAttributePriority

#define	hipKernelNodeAttrValue hipLaunchAttributeValue

#define	hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

#define	hipDrvLaunchAttributeID hipLaunchAttributeID

#define	hipDrvLaunchAttributeValue hipLaunchAttributeValue

#define	hipDrvLaunchAttribute hipLaunchAttribute

#define	hipGraphKernelNodePortDefault 0

#define	hipGraphKernelNodePortLaunchCompletion 2

#define	hipGraphKernelNodePortProgrammatic 1

#define	hiprtcJIT_option hipJitOption

#define	HIPRTC_JIT_MAX_REGISTERS hipJitOptionMaxRegisters

#define	HIPRTC_JIT_THREADS_PER_BLOCK hipJitOptionThreadsPerBlock
	CUDA Only Number of thread per block/#end#‍/.

#define	HIPRTC_JIT_WALL_TIME hipJitOptionWallTime
	CUDA Only Value for total wall clock time.

#define	HIPRTC_JIT_INFO_LOG_BUFFER hipJitOptionInfoLogBuffer

#define	HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES hipJitOptionInfoLogBufferSizeBytes

#define	HIPRTC_JIT_ERROR_LOG_BUFFER hipJitOptionErrorLogBuffer

#define	HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES hipJitOptionErrorLogBufferSizeBytes

#define	HIPRTC_JIT_OPTIMIZATION_LEVEL hipJitOptionOptimizationLevel

#define	HIPRTC_JIT_TARGET_FROM_HIPCONTEXT hipJitOptionTargetFromContext

#define	HIPRTC_JIT_TARGET hipJitOptionTarget
	CUDA Only JIT target.

#define	HIPRTC_JIT_FALLBACK_STRATEGY hipJitOptionFallbackStrategy
	CUDA Only Fallback strategy.

#define	HIPRTC_JIT_GENERATE_DEBUG_INFO hipJitOptionGenerateDebugInfo
	CUDA Only Generate debug information/#end#‍/.

#define	HIPRTC_JIT_LOG_VERBOSE hipJitOptionLogVerbose
	CUDA Only Generate log verbose.

#define	HIPRTC_JIT_GENERATE_LINE_INFO hipJitOptionGenerateLineInfo
	CUDA Only Generate line number information/#end#‍/.

#define	HIPRTC_JIT_CACHE_MODE hipJitOptionCacheMode
	CUDA Only Set cache mode.

#define	HIPRTC_JIT_NEW_SM3X_OPT hipJitOptionSm3xOpt

#define	HIPRTC_JIT_FAST_COMPILE hipJitOptionFastCompile
	CUDA Only Set fast compile.

#define	HIPRTC_JIT_GLOBAL_SYMBOL_NAMES hipJitOptionGlobalSymbolNames

#define	HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS hipJitOptionGlobalSymbolAddresses

#define	HIPRTC_JIT_GLOBAL_SYMBOL_COUNT hipJitOptionGlobalSymbolCount
	CUDA Only Number of symbol count./#end#‍/.

#define	HIPRTC_JIT_LTO hipJitOptionLto

#define	HIPRTC_JIT_FTZ hipJitOptionFtz

#define	HIPRTC_JIT_PREC_DIV hipJitOptionPrecDiv

#define	HIPRTC_JIT_PREC_SQRT hipJitOptionPrecSqrt

#define	HIPRTC_JIT_FMA hipJitOptionFma

#define	HIPRTC_JIT_POSITION_INDEPENDENT_CODE hipJitOptionPositionIndependentCode

#define	HIPRTC_JIT_MIN_CTA_PER_SM hipJitOptionMinCTAPerSM

#define	HIPRTC_JIT_MAX_THREADS_PER_BLOCK hipJitOptionMaxThreadsPerBlock

#define	HIPRTC_JIT_OVERRIDE_DIRECT_VALUES hipJitOptionOverrideDirectiveValues

#define	HIPRTC_JIT_NUM_OPTIONS hipJitOptionNumOptions
	Number of options.

#define	HIPRTC_JIT_IR_TO_ISA_OPT_EXT hipJitOptionIRtoISAOptExt

#define	HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT hipJitOptionIRtoISAOptCountExt

#define	hiprtcJITInputType hipJitInputType

#define	HIPRTC_JIT_INPUT_CUBIN hipJitInputCubin
	Cuda only Input Cubin.

#define	HIPRTC_JIT_INPUT_PTX hipJitInputPtx
	Cuda only Input PTX.

#define	HIPRTC_JIT_INPUT_FATBINARY hipJitInputFatBinary
	Cuda Only Input FAT Binary.

#define	HIPRTC_JIT_INPUT_OBJECT hipJitInputObject
	Cuda Only Host Object with embedded device code/#end#‍/.

#define	HIPRTC_JIT_INPUT_LIBRARY hipJitInputLibrary
	Cuda Only Archive of Host Objects with embedded device code/#end#‍/.

#define	HIPRTC_JIT_INPUT_NVVM hipJitInputNvvm

#define	HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES hipJitNumLegacyInputTypes
	Count of Legacy Input Types/#end#‍/.

#define	HIPRTC_JIT_INPUT_LLVM_BITCODE hipJitInputLLVMBitcode
	HIP Only LLVM Bitcode or IR assembly/#end#‍/.

#define	HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE hipJitInputLLVMBundledBitcode
	HIP Only LLVM Clang Bundled Code/#end#‍/.

#define	HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE hipJitInputLLVMArchivesOfBundledBitcode

#define	HIPRTC_JIT_INPUT_SPIRV hipJitInputSpirv
	HIP Only SPIRV Code Object.

#define	HIPRTC_JIT_NUM_INPUT_TYPES hipJitNumInputTypes
	Count of Input Types.

Typedefs
typedef enum __HIP_NODISCARD hipError_t	hipError_t

typedef struct ihipCtx_t *	hipCtx_t

typedef struct ihipExecutionCtx_t *	hipExecutionCtx_t

typedef struct ihipDevResourceDesc_t *	hipDevResourceDesc_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 ihipLinkState_t *	hipLinkState_t

typedef struct ihipLibrary_t *	hipLibrary_t

typedef struct ihipKernel_t *	hipKernel_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 , 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 , hipDeviceAttributeUnused1 , hipDeviceAttributePageableMemoryAccess , hipDeviceAttributePageableMemoryAccessUsesHostPageTables , hipDeviceAttributePciBusId , hipDeviceAttributePciDeviceId , hipDeviceAttributePciDomainId , hipDeviceAttributePciDomainID , hipDeviceAttributePersistingL2CacheMaxSize , hipDeviceAttributeMaxRegistersPerBlock , hipDeviceAttributeMaxRegistersPerMultiprocessor , hipDeviceAttributeReservedSharedMemPerBlock , hipDeviceAttributeMaxSharedMemoryPerBlock , hipDeviceAttributeSharedMemPerBlockOptin , hipDeviceAttributeSharedMemPerMultiprocessor , hipDeviceAttributeSingleToDoublePrecisionPerfRatio , hipDeviceAttributeStreamPrioritiesSupported , hipDeviceAttributeSurfaceAlignment , hipDeviceAttributeTccDriver , hipDeviceAttributeTextureAlignment , hipDeviceAttributeTexturePitchAlignment , hipDeviceAttributeTotalConstantMemory , hipDeviceAttributeTotalGlobalMem , hipDeviceAttributeUnifiedAddressing , hipDeviceAttributeUnused2 , hipDeviceAttributeWarpSize , hipDeviceAttributeMemoryPoolsSupported , hipDeviceAttributeVirtualMemoryManagementSupported , hipDeviceAttributeHostRegisterSupported , hipDeviceAttributeMemoryPoolSupportedHandleTypes , hipDeviceAttributeHostNumaId , hipDeviceAttributeDmaBufSupported , hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported , hipDeviceAttributeHandleTypeFabricSupported , hipDeviceAttributeCudaCompatibleEnd = 9999 , hipDeviceAttributeAmdSpecificBegin = 10000 , hipDeviceAttributeClockInstructionRate , hipDeviceAttributeUnused3 , hipDeviceAttributeMaxSharedMemoryPerMultiprocessor , hipDeviceAttributeUnused4 , hipDeviceAttributeUnused5 , hipDeviceAttributeHdpMemFlushCntl , hipDeviceAttributeHdpRegFlushCntl , hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc , hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim , hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim , hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem , hipDeviceAttributeIsLargeBar , hipDeviceAttributeAsicRevision , hipDeviceAttributeCanUseStreamWaitValue , hipDeviceAttributeImageSupport , hipDeviceAttributePhysicalMultiProcessorCount , hipDeviceAttributeFineGrainSupport , hipDeviceAttributeWallClockRate , hipDeviceAttributeNumberOfXccs , hipDeviceAttributeMaxAvailableVgprsPerThread , hipDeviceAttributePciChipId , hipDeviceAttributeExpertSchedMode , hipDeviceAttributeMaxDynDataPrefetchRegions , hipDeviceAttributeAmdSpecificEnd = 19999 , hipDeviceAttributeVendorSpecificBegin = 20000 }

enum	hipDriverProcAddressQueryResult { HIP_GET_PROC_ADDRESS_SUCCESS = 0 , HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1 , HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2 }

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	hipDevResourceType { hipDevResourceTypeInvalid = 0 , hipDevResourceTypeSm = 1 , hipDevResourceTypeWorkqueueConfig = 1000 , hipDevResourceTypeWorkqueue = 10000 }

enum	hipDevSmResourceGroup_flags { hipDevSmResourceGroupDefault = 0 , hipDevSmResourceGroupBackfill = 0x1 }

enum	hipDevSmResourceSplitByCount_flags { hipDevSmResourceSplitIgnoreSmCoscheduling = 0x1 , hipDevSmResourceSplitMaxPotentialClusterSize = 0x2 }

enum	hipDevWorkqueueConfigScope { hipDevWorkqueueConfigScopeDeviceCtx = 0 , hipDevWorkqueueConfigScopeGreenCtxBalanced = 1 }

enum	hipDeviceP2PAttr { hipDevP2PAttrPerformanceRank = 0 , hipDevP2PAttrAccessSupported , hipDevP2PAttrNativeAtomicSupported , hipDevP2PAttrHipArrayAccessSupported }

enum	hipDriverEntryPointQueryResult { hipDriverEntryPointSuccess = 0 , hipDriverEntryPointSymbolNotFound = 1 , hipDriverEntryPointVersionNotSufficent = 2 }

enum	hipLimit_t { hipLimitStackSize = 0x0 , hipLimitPrintfFifoSize = 0x01 , hipLimitMallocHeapSize = 0x02 , hipExtLimitScratchMin = 0x1000 , hipExtLimitScratchMax = 0x1001 , hipExtLimitScratchCurrent = 0x1002 , hipLimitRange }

enum	hipStreamBatchMemOpType { hipStreamMemOpWaitValue32 = 0x1 , hipStreamMemOpWriteValue32 = 0x2 , hipStreamMemOpWaitValue64 = 0x4 , hipStreamMemOpWriteValue64 = 0x5 , hipStreamMemOpBarrier = 0x6 , hipStreamMemOpFlushRemoteWrites = 0x3 }

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	hipMemAccessFlags { hipMemAccessFlagsProtNone = 0 , hipMemAccessFlagsProtRead = 1 , hipMemAccessFlagsProtReadWrite = 3 }

enum	hipMemAllocationType { hipMemAllocationTypeInvalid = 0x0 , hipMemAllocationTypePinned = 0x1 , hipMemAllocationTypeManaged = 0x2 , hipMemAllocationTypeUncached = 0x40000000 , hipMemAllocationTypeMax = 0x7FFFFFFF }

enum	hipMemAllocationHandleType { hipMemHandleTypeNone = 0x0 , hipMemHandleTypePosixFileDescriptor , hipMemHandleTypeWin32 = 0x2 , hipMemHandleTypeWin32Kmt = 0x4 , hipMemHandleTypeFabric = 0x8 }

enum	hipFuncAttribute { hipFuncAttributeMaxDynamicSharedMemorySize = 8 , hipFuncAttributePreferredSharedMemoryCarveout = 9 , hipFuncAttributeClusterDimMustBeSet = 10 , hipFuncAttributeRequiredClusterWidth = 11 , hipFuncAttributeRequiredClusterHeight = 12 , hipFuncAttributeRequiredClusterDepth = 13 , hipFuncAttributeNonPortableClusterSizeAllowed = 14 , hipFuncAttributeClusterSchedulingPolicyPreference = 15 , 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 , hipGraphNodeTypeBatchMemOp = 14 , hipGraphNodeTypeCount }

enum	hipAccessProperty { hipAccessPropertyNormal = 0 , hipAccessPropertyStreaming = 1 , hipAccessPropertyPersisting = 2 }

enum	hipLaunchMemSyncDomain { hipLaunchMemSyncDomainDefault = 0 , hipLaunchMemSyncDomainRemote = 1 }

enum	hipSynchronizationPolicy { hipSyncPolicyAuto = 1 , hipSyncPolicySpin = 2 , hipSyncPolicyYield = 3 , hipSyncPolicyBlockingSync = 4 }

enum	hipClusterSchedulingPolicy { hipClusterSchedulingPolicyDefault = 0 , hipClusterSchedulingPolicySpread = 1 , hipClusterSchedulingPolicyLoadBalancing }

enum	hipExtDynDataPrefetchTemporal { hipExtDynDataPrefetchTemporalRegular = 0 , hipExtDynDataPrefetchTemporalHigh = 1 }
	Temporal locality hint for dynamic data prefetch. More...

enum	hipLaunchAttributeID { hipLaunchAttributeIgnore = 0 , hipLaunchAttributeAccessPolicyWindow = 1 , hipLaunchAttributeCooperative = 2 , hipLaunchAttributeSynchronizationPolicy = 3 , hipLaunchAttributeClusterDimension = 4 , hipLaunchAttributeClusterSchedulingPolicyPreference = 5 , hipLaunchAttributePriority = 8 , hipLaunchAttributeMemSyncDomainMap = 9 , hipLaunchAttributeMemSyncDomain = 10 , hipLaunchAttributeExtDynDataPrefetch = 1024 , hipLaunchAttributeMax }

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 , hipGraphMemAttrUsedMemHigh , hipGraphMemAttrReservedMemCurrent , hipGraphMemAttrReservedMemHigh }

enum	hipUserObjectFlags { hipUserObjectNoDestructorSync = 0x1 }

enum	hipUserObjectRetainFlags { hipGraphUserObjectMove = 0x1 }

enum	hipGraphInstantiateFlags { hipGraphInstantiateFlagAutoFreeOnLaunch , hipGraphInstantiateFlagUpload = 2 , hipGraphInstantiateFlagDeviceLaunch , hipGraphInstantiateFlagUseNodePriority }

enum	hipGraphDebugDotFlags { hipGraphDebugDotFlagsVerbose , hipGraphDebugDotFlagsKernelNodeParams = 1 << 2 , hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3 , hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4 , hipGraphDebugDotFlagsHostNodeParams = 1 << 5 , hipGraphDebugDotFlagsEventNodeParams , hipGraphDebugDotFlagsExtSemasSignalNodeParams , hipGraphDebugDotFlagsExtSemasWaitNodeParams , hipGraphDebugDotFlagsKernelNodeAttributes , hipGraphDebugDotFlagsHandles }

enum	hipGraphInstantiateResult { hipGraphInstantiateSuccess = 0 , hipGraphInstantiateError = 1 , hipGraphInstantiateInvalidStructure = 2 , hipGraphInstantiateNodeOperationNotSupported = 3 , hipGraphInstantiateMultipleDevicesNotSupported = 4 }

enum	hipMemAllocationGranularity_flags { hipMemAllocationGranularityMinimum = 0x0 , hipMemAllocationGranularityRecommended = 0x1 }

enum	hipMemHandleType { hipMemHandleTypeGeneric = 0x0 }

enum	hipMemOperationType { hipMemOperationTypeMap = 0x1 , hipMemOperationTypeUnmap = 0x2 }

enum	hipArraySparseSubresourceType { hipArraySparseSubresourceTypeSparseLevel = 0x0 , hipArraySparseSubresourceTypeMiptail = 0x1 }

enum	hipGraphDependencyType { hipGraphDependencyTypeDefault = 0 , hipGraphDependencyTypeProgrammatic = 1 }

enum	hipMemRangeHandleType { hipMemRangeHandleTypeDmaBufFd = 0x1 , hipMemRangeHandleTypeMax = 0x7fffffff }

enum	hipMemRangeFlags { hipMemRangeFlagDmaBufMappingTypePcie = 0x1 , hipMemRangeFlagsMax = 0x7fffffff }

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	hipGLDeviceList { hipGLDeviceListAll = 1 , hipGLDeviceListCurrentFrame = 2 , hipGLDeviceListNextFrame = 3 }

Detailed Description

Data Structure Documentation

◆ hipDeviceArch_t

struct hipDeviceArch_t

hipDeviceArch_t

Data Fields
unsigned	has3dGrid: 1	Grid and group dims are 3D (rather than 2D).
unsigned	hasDoubles: 1	Double-precision floating point.
unsigned	hasDynamicParallelism: 1	Dynamic parallelism.
unsigned	hasFloatAtomicAdd: 1	32-bit float atomic add in global and shared memory.
unsigned	hasFunnelShift: 1	Funnel two words into one with shift&mask caps.
unsigned	hasGlobalFloatAtomicExch: 1	32-bit float atomic exch for global memory.
unsigned	hasGlobalInt32Atomics: 1	32-bit integer atomics for global memory.
unsigned	hasGlobalInt64Atomics: 1	64-bit integer atomics for global memory.
unsigned	hasSharedFloatAtomicExch: 1	32-bit float atomic exch for shared memory.
unsigned	hasSharedInt32Atomics: 1	32-bit integer atomics for shared memory.
unsigned	hasSharedInt64Atomics: 1	64-bit integer atomics for shared memory.
unsigned	hasSurfaceFuncs: 1	Surface functions.
unsigned	hasSyncThreadsExt: 1	__syncthreads_count, syncthreads_and, syncthreads_or.
unsigned	hasThreadFenceSystem: 1	__threadfence_system.
unsigned	hasWarpBallot: 1	Warp ballot instructions (__ballot).
unsigned	hasWarpShuffle: 1	Warp shuffle operations. (__shfl_*).
unsigned	hasWarpVote: 1	Warp vote instructions (__any, __all).

◆ hipUUID

struct hipUUID

Data Fields
char	bytes[16]

◆ hipDeviceProp_t

struct hipDeviceProp_t

hipDeviceProp

Collaboration diagram for hipDeviceProp_t:

[legend]

Data Fields
int	accessPolicyMaxWindowSize	Max value of access policy window.
hipDeviceArch_t	arch	Architectural feature flags. New for HIP.
int	asicRevision	Revision of the GPU in this device.
int	asyncEngineCount	Number of async engines.
int	canMapHostMemory	Check whether HIP can map host memory.
int	canUseHostPointerForRegisteredMem	Device can access host registered memory with same address as the host
int	clockInstructionRate	Frequency in khz of the timer used by the device-side "clock*" instructions. New for HIP.
int	clockRate	Max clock frequency of the multiProcessors in khz.
int	clusterLaunch	Device supports cluster launch.
int	computeMode	Compute mode.
int	computePreemptionSupported	Is compute preemption supported on the device.
int	concurrentKernels	Device can possibly execute multiple kernels concurrently.
int	concurrentManagedAccess	Device can coherently access managed memory concurrently with the CPU
int	cooperativeLaunch	HIP device supports cooperative launch.
int	cooperativeMultiDeviceLaunch	HIP device supports cooperative launch on multiple devices
int	cooperativeMultiDeviceUnmatchedBlockDim	HIP device supports cooperative launch on multiple devices with unmatched block dimensions
int	cooperativeMultiDeviceUnmatchedFunc	HIP device supports cooperative launch on multiple devices with unmatched functions
int	cooperativeMultiDeviceUnmatchedGridDim	HIP device supports cooperative launch on multiple devices with unmatched grid dimensions
int	cooperativeMultiDeviceUnmatchedSharedMem	HIP device supports cooperative launch on multiple devices with unmatched shared memories
int	deferredMappingHipArraySupported	Device supports deferred mapping HIP arrays and HIP mipmapped arrays
int	deviceOverlap	Deprecated. Use asyncEngineCount instead.
int	directManagedMemAccessFromHost	Host can directly access managed memory on the device without migration
int	ECCEnabled	Device has ECC support enabled.
char	gcnArchName[256]	AMD GCN Arch Name. HIP Only.
int	globalL1CacheSupported	Indicates globals are cached in L1.
unsigned int	gpuDirectRDMAFlushWritesOptions	Bitmask to be interpreted according to hipFlushGPUDirectRDMAWritesOptions
int	gpuDirectRDMASupported	Indicates device support of RDMA APIs.
int	gpuDirectRDMAWritesOrdering	value of hipGPUDirectRDMAWritesOrdering
unsigned int *	hdpMemFlushCntl	Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.
unsigned int *	hdpRegFlushCntl	Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.
int	hipReserved[32]	Reserved for adding new entries for HIP/CUDA.
int	hostNativeAtomicSupported	Link between host and device supports native atomics.
int	hostRegisterReadOnlySupported	Device supports using the hipHostRegisterReadOnly flag with hipHostRegistger
int	hostRegisterSupported	Device supports hipHostRegister.
int	integrated	APU vs dGPU.
int	ipcEventSupported	Device supports IPC events.
int	isLargeBar	1: if it is a large PCI bar device, else 0
int	isMultiGpuBoard	1 if device is on a multi-GPU board, 0 if not.
int	kernelExecTimeoutEnabled	Run time limit for kernels executed on the device.
int	l2CacheSize	L2 cache size.
int	localL1CacheSupported	Locals are cahced in L1.
char	luid[8]	8-byte unique identifier. Only valid on windows
unsigned int	luidDeviceNodeMask	LUID node mask.
int	major	Major compute capability version. This indicates the core instruction set of the GPU architecture. For example, a value of 11 would correspond to Navi III (RDNA3). See the arch feature flags for portable ways to query feature caps.
int	managedMemory	Device supports allocating managed memory on this system.
int	maxBlocksPerMultiProcessor	Max number of blocks on CU.
int	maxGridSize[3]	Max grid dimensions (XYZ).
size_t	maxSharedMemoryPerMultiProcessor	Maximum Shared Memory Per CU. HIP Only.
int	maxSurface1D	Maximum 1D surface size.
int	maxSurface1DLayered[2]	Maximum 1D layered surface size.
int	maxSurface2D[2]	Maximum 2D surface size.
int	maxSurface2DLayered[3]	Maximum 2D layared surface size.
int	maxSurface3D[3]	Maximum 3D surface size.
int	maxSurfaceCubemap	Maximum cubemap surface size.
int	maxSurfaceCubemapLayered[2]	Maximum cubemap layered surface size.
int	maxTexture1D	Maximum number of elements in 1D images.
int	maxTexture1DLayered[2]	Maximum number of elements in 1D array images.
int	maxTexture1DLinear	Maximum size for 1D textures bound to linear memory.
int	maxTexture1DMipmap	Maximum 1D mipmap texture size.
int	maxTexture2D[2]	Maximum dimensions (width, height) of 2D images, in image elements.
int	maxTexture2DGather[2]	Maximum 2D tex dimensions if gather has to be performed.
int	maxTexture2DLayered[3]	Maximum number of elements in 2D array images.
int	maxTexture2DLinear[3]	Maximum 2D tex dimensions if tex are bound to pitched memory.
int	maxTexture2DMipmap[2]	Maximum number of elements in 2D array mipmap of images.
int	maxTexture3D[3]	Maximum dimensions (width, height, depth) of 3D images, in image elements
int	maxTexture3DAlt[3]	Maximum alternate 3D texture dims.
int	maxTextureCubemap	Maximum cubemap texture dims.
int	maxTextureCubemapLayered[2]	Maximum cubemaps layered texture dims.
int	maxThreadsDim[3]	Max number of threads in each dimension (XYZ) of a block.
int	maxThreadsPerBlock	Max work items per work group or workgroup max size.
int	maxThreadsPerMultiProcessor	Maximum resident threads per multi-processor.
int	memoryBusWidth	Global memory bus width in bits.
int	memoryClockRate	Max global memory clock frequency in khz.
int	memoryPoolsSupported	Indicates if device supports hipMallocAsync and hipMemPool APIs.
unsigned int	memoryPoolSupportedHandleTypes	Bitmask of handle types support with mempool based IPC.
size_t	memPitch	Maximum pitch in bytes allowed by memory copies pitched memory
int	minor	Minor compute capability version. This indicates a particular configuration, feature set, or variation within the group represented by the major compute capability version. For example, different models within the same major version might have varying levels of support for certain features or optimizations. See the arch feature flags for portable ways to query feature caps.
int	multiGpuBoardGroupID	Unique identifier for a group of devices on same multiboard GPU.
int	multiProcessorCount	Number of multi-processors. When the GPU works in Compute Unit (CU) mode, this value equals the number of CUs; when in Workgroup Processor (WGP) mode, this value equels half of CUs, because a single WGP contains two CUs.
char	name[256]	Device name.
int	pageableMemoryAccess	Device supports coherently accessing pageable memory without calling hipHostRegister on it
int	pageableMemoryAccessUsesHostPageTables	Device accesses pageable memory via the host's page tables
int	pciBusID	PCI Bus ID.
int	pciDeviceID	PCI Device ID.
int	pciDomainID	PCI Domain ID.
int	persistingL2CacheMaxSize	Device's max L2 persisting lines in bytes.
int	regsPerBlock	Registers per block.
int	regsPerMultiprocessor	registers available per multiprocessor
int	reserved[63]	CUDA Reserved.
size_t	reservedSharedMemPerBlock	Shared memory reserved by driver per block.
size_t	sharedMemPerBlock	Size of shared memory per block (in bytes).
size_t	sharedMemPerBlockOptin	Per device m ax shared mem per block usable by special opt in.
size_t	sharedMemPerMultiprocessor	Amount of shared memory available per multiprocessor.
int	singleToDoublePrecisionPerfRatio	Deprecated. CUDA only.
int	sparseHipArraySupported	Indicates if device supports sparse hip arrays.
int	streamPrioritiesSupported	Device supports stream priority.
size_t	surfaceAlignment	Alignment requirement for surface.
int	tccDriver	1:If device is Tesla device using TCC driver, else 0
size_t	textureAlignment	Alignment requirement for textures.
size_t	texturePitchAlignment	Pitch alignment requirement for texture references bound to.
int	timelineSemaphoreInteropSupported	Indicates external timeline semaphore support.
size_t	totalConstMem	Size of shared constant memory region on the device (in bytes).
size_t	totalGlobalMem	Size of global memory region (in bytes).
int	unifiedAddressing	Does device and host share unified address space.
int	unifiedFunctionPointers	Indicates device supports unified function pointers.
hipUUID	uuid	UUID of a device.
int	warpSize	Warp size.

◆ hipPointerAttribute_t

struct hipPointerAttribute_t

Pointer attributes

Data Fields
unsigned	allocationFlags
int	device
void *	devicePointer
void *	hostPointer
int	isManaged
enum hipMemoryType	type

◆ hipDevSmResource

struct hipDevSmResource

Data Fields
unsigned int	flags
unsigned int	minSmPartitionSize
unsigned int	smCoscheduledAlignment
unsigned int	smCount

◆ hipDevWorkqueueConfigResource

struct hipDevWorkqueueConfigResource

Data Fields
int	device
hipDevWorkqueueConfigScope	sharingScope
unsigned int	wqConcurrencyLimit

◆ hipDevWorkqueueResource

struct hipDevWorkqueueResource

Data Fields
unsigned char	reserved[HIP_RESOURCE_ABI_BYTES]

◆ hipDevResource

struct hipDevResource

Data Fields
union hipDevResource.__unnamed16__	__unnamed__
unsigned char	_internal_padding[92]
struct hipDevResource_st *	nextResource
hipDevResourceType	type

◆ hipDevSmResourceGroupParams

struct hipDevSmResourceGroupParams

Data Fields
unsigned int	coscheduledSmCount
unsigned int	flags
unsigned int	preferredCoscheduledSmCount
unsigned int	reserved[12]
unsigned int	smCount

◆ hipIpcMemHandle_t

struct hipIpcMemHandle_t

Data Fields
char	reserved[HIP_IPC_HANDLE_SIZE]

◆ hipIpcEventHandle_t

struct hipIpcEventHandle_t

Data Fields
char	reserved[HIP_IPC_HANDLE_SIZE]

◆ hipMemFabricHandle_t

struct hipMemFabricHandle_t

Data Fields
unsigned char	data[HIP_IPC_HANDLE_SIZE]

◆ hipFuncAttributes

struct hipFuncAttributes

Data Fields
int	binaryVersion
int	cacheModeCA
size_t	constSizeBytes
size_t	localSizeBytes
int	maxDynamicSharedSizeBytes
int	maxThreadsPerBlock
int	numRegs
int	preferredShmemCarveout
int	ptxVersion
size_t	sharedSizeBytes

◆ hipStreamBatchMemOpParams

union hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

hipStreamBatchMemOpParams is used to specify the parameters for batch memory operations in a HIP stream. This union supports various operations including waiting for a specific value, writing a value, and different flags for wait conditions.

The union includes fields for different types of operations defined in the enum hipStreamBatchMemOpType:

hipStreamMemOpWaitValue32: Wait for a 32-bit value.
hipStreamMemOpWriteValue32: Write a 32-bit value.
hipStreamMemOpWaitValue64: Wait for a 64-bit value.
hipStreamMemOpWriteValue64: Write a 64-bit value.

Each operation type includes an address, the value to wait for or write, flags, and an optional alias that is not relevant on AMD GPUs. Flags can be used to specify different wait conditions such as equality, bitwise AND, greater than or equal, and bitwise NOR.

Example usage:

hipStreamBatchMemOpParams myArray[2];
myArray[0].operation = hipStreamMemOpWaitValue32;
myArray[0].waitValue.address = waitAddr1;
myArray[0].waitValue.value = 0x1;
myArray[0].waitValue.flags = CU_STREAM_WAIT_VALUE_EQ;
 
myArray[1].operation = hipStreamMemOpWriteValue32;
myArray[1].writeValue.address = writeAddr1;
myArray[1].writeValue.value = 0x1;
myArray[1].writeValue.flags = 0x0;
 
result = hipStreamBatchMemOp(stream, 2, myArray, 0);

Collaboration diagram for hipStreamBatchMemOpParams:

[legend]

Data Fields
struct hipStreamMemOpFlushRemoteWritesParams_t	flushRemoteWrites	Currently not supported on AMD.
struct hipStreamMemOpMemoryBarrierParams_t	memoryBarrier	Currently not supported on AMD.
hipStreamBatchMemOpType	operation
uint64_t	pad[6]
struct hipStreamMemOpWaitValueParams_t	waitValue
struct hipStreamMemOpWriteValueParams_t	writeValue

◆ hipBatchMemOpNodeParams

struct hipBatchMemOpNodeParams

Structure representing node parameters for batch memory operations in HIP graphs.

hipBatchMemOpNodeParams is used to specify the parameters for batch memory operations in HIP graphs. This struct includes the context to use for the operations, the number of operations, and an array of hipStreamBatchMemOpParams that describe the operations.

The structure includes the following fields:

ctx: The HIP context to use for the operations.
count: The number of operations in the paramArray.
paramArray: A pointer to an array of hipStreamBatchMemOpParams.
flags: Flags to control the node.

Example usage:

hipBatchMemOpNodeParams nodeParams;
nodeParams.ctx = context;
nodeParams.count = ARRAY_SIZE;
nodeParams.paramArray = myArray;
nodeParams.flags = 0;
 
Pass nodeParams to a HIP graph APIs hipGraphAddBatchMemOpNode, hipGraphBatchMemOpNodeGetParams,
hipGraphBatchMemOpNodeSetParams, hipGraphExecBatchMemOpNodeSetParams

Collaboration diagram for hipBatchMemOpNodeParams:

[legend]

Data Fields
unsigned int	count
hipCtx_t	ctx
unsigned int	flags
hipStreamBatchMemOpParams *	paramArray

◆ hipMemAccessDesc

struct hipMemAccessDesc

Memory access descriptor structure is used to specify memory access permissions for a virtual memory region in Virtual Memory Management API. This structure changes read, and write permissions for specific memory regions.

Collaboration diagram for hipMemAccessDesc:

[legend]

Data Fields
hipMemAccessFlags	flags	Accessibility flags to set.
hipMemLocation	location	Location on which the accessibility has to change.

◆ hipMemPoolProps

struct hipMemPoolProps

Specifies the properties of allocations made from the pool.

Collaboration diagram for hipMemPoolProps:

[legend]

Data Fields
hipMemAllocationType	allocType	Allocation type. Currently must be specified as `hipMemAllocationTypePinned`.
hipMemAllocationHandleType	handleTypes	Handle types that will be supported by allocations from the pool.
hipMemLocation	location	Location where allocations should reside.
size_t	maxSize	Maximum pool size. When set to 0, defaults to a system dependent value.
unsigned char	reserved[56]	Reserved for future use, must be 0.
void *	win32SecurityAttributes	Windows-specific LPSECURITYATTRIBUTES required when `hipMemHandleTypeWin32` is specified

◆ hipMemPoolPtrExportData

struct hipMemPoolPtrExportData

Opaque data structure for exporting a pool allocation

Data Fields
unsigned char	reserved[64]

◆ hipLaunchParams

struct hipLaunchParams

struct hipLaunchParams_t

Collaboration diagram for hipLaunchParams:

[legend]

Data Fields
void **	args	Arguments.
dim3	blockDim	Block dimensions.
void *	func	Device function symbol.
dim3	gridDim	Grid dimensions.
size_t	sharedMem	Shared memory.
hipStream_t	stream	Stream identifier.

◆ hipFunctionLaunchParams

struct hipFunctionLaunchParams

struct hipFunctionLaunchParams_t

Data Fields
unsigned int	blockDimX	X dimension of each thread block.
unsigned int	blockDimY	Y dimension of each thread block.
unsigned int	blockDimZ	Z dimension of each thread block.
hipFunction_t	function	Kernel to launch.
unsigned int	gridDimX	Width(X) of grid in blocks.
unsigned int	gridDimY	Height(Y) of grid in blocks.
unsigned int	gridDimZ	Depth(Z) of grid in blocks.
hipStream_t	hStream	Stream identifier.
void **	kernelParams	Kernel parameters.
unsigned int	sharedMemBytes	Shared memory.

◆ hipExternalMemoryHandleDesc

struct hipExternalMemoryHandleDesc

Data Fields
unsigned int	flags
union hipExternalMemoryHandleDesc.handle	handle
unsigned int	reserved[16]
unsigned long long	size
hipExternalMemoryHandleType	type

◆ hipExternalMemoryBufferDesc

struct hipExternalMemoryBufferDesc

Data Fields
unsigned int	flags
unsigned long long	offset
unsigned int	reserved[16]
unsigned long long	size

◆ hipExternalMemoryMipmappedArrayDesc

struct hipExternalMemoryMipmappedArrayDesc

Collaboration diagram for hipExternalMemoryMipmappedArrayDesc:

[legend]

Data Fields
hipExtent	extent
unsigned int	flags
hipChannelFormatDesc	formatDesc
unsigned int	numLevels
unsigned long long	offset

◆ hipExternalSemaphoreHandleDesc

struct hipExternalSemaphoreHandleDesc

Data Fields
unsigned int	flags
union hipExternalSemaphoreHandleDesc.handle	handle
unsigned int	reserved[16]
hipExternalSemaphoreHandleType	type

◆ hipExternalSemaphoreSignalParams

struct hipExternalSemaphoreSignalParams

Data Fields
unsigned int	flags
struct hipExternalSemaphoreSignalParams.params	params
unsigned int	reserved[16]

◆ hipExternalSemaphoreWaitParams

struct hipExternalSemaphoreWaitParams

External semaphore wait parameters, compatible with driver type

Data Fields
unsigned int	flags
struct hipExternalSemaphoreWaitParams.params	params
unsigned int	reserved[16]

◆ hipHostNodeParams

struct hipHostNodeParams

Data Fields
hipHostFn_t	fn
void *	userData

◆ hipKernelNodeParams

struct hipKernelNodeParams

Collaboration diagram for hipKernelNodeParams:

[legend]

Data Fields
dim3	blockDim
void **	extra
void *	func
dim3	gridDim
void **	kernelParams
unsigned int	sharedMemBytes

◆ hipMemsetParams

struct hipMemsetParams

Data Fields
void *	dst
unsigned int	elementSize
size_t	height
size_t	pitch
unsigned int	value
size_t	width

◆ hipMemAllocNodeParams

struct hipMemAllocNodeParams

Collaboration diagram for hipMemAllocNodeParams:

[legend]

Data Fields
size_t	accessDescCount	The number of access descriptors. Must not be bigger than the number of GPUs
const hipMemAccessDesc *	accessDescs	The number of memory access descriptors.
size_t	bytesize	The size of the requested allocation in bytes.
void *	dptr	Returned device address of the allocation.
hipMemPoolProps	poolProps	Pool properties, which contain where the location should reside

◆ hipAccessPolicyWindow

struct hipAccessPolicyWindow

Data Fields
void *	base_ptr	Starting address of the access policy window.
hipAccessProperty	hitProp	hipAccessProperty set for hit
float	hitRatio	hitRatio specifies percentage of lines assigned hitProp
hipAccessProperty	missProp	hipAccessProperty set for miss
size_t	num_bytes	Size in bytes of the window policy.

◆ hipLaunchMemSyncDomainMap

struct hipLaunchMemSyncDomainMap

Memory Synchronization Domain map

Data Fields
unsigned char	default_	The default domain ID to use for designated kernels
unsigned char	remote	The remote domain ID to use for designated kernels

◆ hipExtDynDataPrefetchRegion

struct hipExtDynDataPrefetchRegion

Describes one 2D memory region to prefetch into L2 cache.

address must be aligned to the device's L2 cache line size. width is measured in bytes and must be a multiple of the cache line size. height is the number of rows to prefetch. stride is the byte stride between the start of consecutive rows.

Data Fields
void *	address	Base address (must be cache-line aligned)
size_t	height	Number of rows to prefetch.
size_t	stride	Stride between row starts in bytes.
size_t	width	Width of each row in bytes (must be a multiple of cache line size)

◆ hipExtDynDataPrefetchConfig

struct hipExtDynDataPrefetchConfig

Configuration for dynamic data prefetch.

Pointed to by a launch attribute via hipLaunchAttributeExtDynDataPrefetch. numRegions must not exceed the device limit queried via hipDeviceAttributeMaxDynDataPrefetchRegions (use hipDeviceGetAttribute).

Cooperative prefetch is always enabled internally; the user only controls the temporal policy.

Collaboration diagram for hipExtDynDataPrefetchConfig:

[legend]

Data Fields
unsigned int	numRegions	Number of valid regions (1-max)
hipExtDynDataPrefetchRegion	regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS]	Prefetch regions.
hipExtDynDataPrefetchTemporal	temporal	Cache retention policy for prefetched data.

◆ hipLaunchAttributeValue

union hipLaunchAttributeValue

Launch Attribute Value

Collaboration diagram for hipLaunchAttributeValue:

[legend]

Data Fields
hipAccessPolicyWindow	accessPolicyWindow	Value of launch attribute hipLaunchAttributeAccessPolicyWindow.
struct hipLaunchAttributeValue.clusterDim	clusterDim	Specifies the desired cluster dimensions for a kernel launch. This opaque type is used as the value for the launch attribute hipLaunchAttributeClusterDimension. It defines the dimensions of the compute cluster in terms of blocks, where each field must evenly divide the corresponding grid dimension: `x:` Number of blocks along the X-axis. `y:` Number of blocks along the Y-axis. `z:` Number of blocks along the Z-axis.
hipClusterSchedulingPolicy	clusterSchedulingPolicyPreference	Value of launch attribute :: hipLaunchAttributeClusterSchedulingPolicyPreference determines the preferred strategy for distributing blocks within a compute cluster
int	cooperative	Value of launch attribute hipLaunchAttributeCooperative. Indicates whether the kernel is cooperative.
const hipExtDynDataPrefetchConfig *	dynDataPrefetch	Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.
hipLaunchMemSyncDomain	memSyncDomain	Value of launch attribute hipLaunchAttributeMemSyncDomain.
hipLaunchMemSyncDomainMap	memSyncDomainMap	Value of launch attribute hipLaunchAttributeMemSyncDomainMap.
char	pad[64]	64 byte padding
int	priority	Value of launch attribute :: hipLaunchAttributePriority. Execution priority of kernel
hipSynchronizationPolicy	syncPolicy	Value of launch attribute :: hipLaunchAttributeSynchronizationPolicy. Used to work queued up in stream

◆ hipGraphInstantiateParams

struct hipGraphInstantiateParams

Graph Instantiation parameters

Data Fields
hipGraphNode_t	errNode_out	The node which caused instantiation to fail, if any
unsigned long long	flags	Instantiation flags
hipGraphInstantiateResult	result_out	Whether instantiation was successful. If it failed, the reason why
hipStream_t	uploadStream	Upload stream

◆ hipMemAllocationProp

struct hipMemAllocationProp

Memory allocation properties

Collaboration diagram for hipMemAllocationProp:

[legend]

Data Fields
union hipMemAllocationProp.__unnamed35__	__unnamed__
struct hipMemAllocationProp.allocFlags	allocFlags
hipMemLocation	location	Memory location.
hipMemAllocationType	type	Memory allocation type.
void *	win32HandleMetaData	Metadata for Win32 handles.

◆ hipExternalSemaphoreSignalNodeParams

struct hipExternalSemaphoreSignalNodeParams

External semaphore signal node parameters

Collaboration diagram for hipExternalSemaphoreSignalNodeParams:

[legend]

Data Fields
hipExternalSemaphore_t *	extSemArray	< Array containing external semaphore handles. Array containing parameters of external signal semaphore.
unsigned int	numExtSems
const hipExternalSemaphoreSignalParams *	paramsArray	Total number of handles and parameters contained in extSemArray and paramsArray.

◆ hipExternalSemaphoreWaitNodeParams

struct hipExternalSemaphoreWaitNodeParams

External semaphore wait node parameters

Collaboration diagram for hipExternalSemaphoreWaitNodeParams:

[legend]

Data Fields
hipExternalSemaphore_t *	extSemArray	< Array containing external semaphore handles. Array containing parameters of external wait semaphore.
unsigned int	numExtSems
const hipExternalSemaphoreWaitParams *	paramsArray	Total number of handles and parameters contained in extSemArray and paramsArray.

◆ hipArrayMapInfo

struct hipArrayMapInfo

Map info for arrays

Data Fields
unsigned int	deviceBitMask	Device ordinal bit mask.
unsigned int	flags	flags for future use, must be zero now.
union hipArrayMapInfo.memHandle	memHandle
hipMemHandleType	memHandleType	Memory handle type.
hipMemOperationType	memOperationType	Memory operation type.
unsigned long long	offset	Offset within the memory.
unsigned int	reserved[2]	Reserved for future use, must be zero now.
union hipArrayMapInfo.resource	resource
hipResourceType	resourceType	Resource type.
union hipArrayMapInfo.subresource	subresource
hipArraySparseSubresourceType	subresourceType	Sparse subresource type.

◆ hipMemcpyNodeParams

struct hipMemcpyNodeParams

Memcpy node params

Collaboration diagram for hipMemcpyNodeParams:

[legend]

Data Fields
hipMemcpy3DParms	copyParams	Params set for the memory copy.
int	flags	Must be zero.
int	reserved[3]	Must be zero.

◆ hipChildGraphNodeParams

struct hipChildGraphNodeParams

Child graph node params

Data Fields
hipGraph_t	graph	Either the child graph to clone into the node, or a handle to the graph possesed by the node used during query

◆ hipEventWaitNodeParams

struct hipEventWaitNodeParams

Event record node params

Data Fields
hipEvent_t	event	Event to wait on.

◆ hipEventRecordNodeParams

struct hipEventRecordNodeParams

Event record node params

Data Fields
hipEvent_t	event	The event to be recorded when node executes.

◆ hipMemFreeNodeParams

struct hipMemFreeNodeParams

Memory free node params

Data Fields
void *	dptr	the pointer to be freed

◆ hipGraphNodeParams

struct hipGraphNodeParams

Params for different graph nodes

Data Fields
union hipGraphNodeParams.__unnamed43__	__unnamed__
int	reserved0[3]
long long	reserved2
hipGraphNodeType	type

◆ hipGraphEdgeData

struct hipGraphEdgeData

Data Fields
unsigned char	from_port	This indicates when the dependency is triggered from the upstream node on the edge. The meaning is specfic to the node type. A value of 0 in all cases means full completion of the upstream node, with memory visibility to the downstream node or portion thereof (indicated by to_port). Only kernel nodes define non-zero ports. A kernel node can use the following output port types: hipGraphKernelNodePortDefault, hipGraphKernelNodePortProgrammatic, or hipGraphKernelNodePortLaunchCompletion.
unsigned char	reserved[5]	These bytes are unused and must be zeroed.
unsigned char	to_port	Currently no node types define non-zero ports. This field must be set to zero.
unsigned char	type	This should be populated with a value from hipGraphDependencyType.

◆ hipLaunchAttribute

struct hipLaunchAttribute

Used to specify custom attributes for launching kernels

Data Fields
union hipLaunchAttribute.__unnamed45__	__unnamed__
hipLaunchAttributeID	id	Identifier of the launch attribute.
char	pad[8 - sizeof(hipLaunchAttributeID)]	Padding to align the structure to 8 bytes.

◆ hipLaunchConfig_t

struct hipLaunchConfig_t

HIP extensible launch configuration

Collaboration diagram for hipLaunchConfig_t:

[legend]

Data Fields
hipLaunchAttribute *	attrs	Attributes list.
dim3	blockDim	Block dimensions.
size_t	dynamicSmemBytes	Dynamic shared-memory size per thread block.
dim3	gridDim	Grid dimensions.
unsigned int	numAttrs	Number of attributes.
hipStream_t	stream	Stream identifier.

◆ HIP_LAUNCH_CONFIG

struct HIP_LAUNCH_CONFIG

HIP driver extensible launch configuration

Collaboration diagram for HIP_LAUNCH_CONFIG:

[legend]

Data Fields
hipLaunchAttribute *	attrs	Attribute list.
unsigned int	blockDimX	Thread block dimension in X.
unsigned int	blockDimY	Thread block dimension in Y.
unsigned int	blockDimZ	Thread block dimension in Z.
unsigned int	gridDimX	Grid width in blocks.
unsigned int	gridDimY	Grid height in blocks.
unsigned int	gridDimZ	Grid depth in blocks.
hipStream_t	hStream	HIP stream identifier.
unsigned int	numAttrs	Number of attributes.
unsigned int	sharedMemBytes	Dynamic shared-memory size in bytes per block.

◆ hipArrayMemoryRequirements

struct hipArrayMemoryRequirements

Struct representing array memory requirements.

Data Fields
size_t	alignment
size_t	size

◆ hipDevResource.unnamed16

union hipDevResource.__unnamed16__

Data Fields
unsigned char	_oversize[HIP_RESOURCE_ABI_BYTES]
hipDevSmResource	sm
hipDevWorkqueueResource	wq
hipDevWorkqueueConfigResource	wqConfig

◆ hipExternalMemoryHandleDesc.handle

union hipExternalMemoryHandleDesc.handle

Data Fields
int	fd
const void *	nvSciBufObject
struct hipExternalMemoryHandleDesc.handle.win32	win32

◆ hipExternalMemoryHandleDesc.handle.win32

struct hipExternalMemoryHandleDesc.handle.win32

Data Fields
void *	handle
const void *	name

◆ hipExternalSemaphoreHandleDesc.handle

union hipExternalSemaphoreHandleDesc.handle

Data Fields
int	fd
const void *	NvSciSyncObj
struct hipExternalSemaphoreHandleDesc.handle.win32	win32

◆ hipExternalSemaphoreHandleDesc.handle.win32

struct hipExternalSemaphoreHandleDesc.handle.win32

Data Fields
void *	handle
const void *	name

◆ hipExternalSemaphoreSignalParams.params

struct hipExternalSemaphoreSignalParams.params

Data Fields
struct hipExternalSemaphoreSignalParams.params.fence	fence
struct hipExternalSemaphoreSignalParams.params.keyedMutex	keyedMutex
union hipExternalSemaphoreSignalParams.params.nvSciSync	nvSciSync
unsigned int	reserved[12]

◆ hipExternalSemaphoreSignalParams.params.fence

struct hipExternalSemaphoreSignalParams.params.fence

Data Fields
unsigned long long	value

◆ hipExternalSemaphoreSignalParams.params.nvSciSync

union hipExternalSemaphoreSignalParams.params.nvSciSync

Data Fields
void *	fence
unsigned long long	reserved

◆ hipExternalSemaphoreSignalParams.params.keyedMutex

struct hipExternalSemaphoreSignalParams.params.keyedMutex

Data Fields
unsigned long long	key

◆ hipExternalSemaphoreWaitParams.params

struct hipExternalSemaphoreWaitParams.params

Data Fields
struct hipExternalSemaphoreWaitParams.params.fence	fence
struct hipExternalSemaphoreWaitParams.params.keyedMutex	keyedMutex
union hipExternalSemaphoreWaitParams.params.nvSciSync	nvSciSync
unsigned int	reserved[10]

◆ hipExternalSemaphoreWaitParams.params.fence

struct hipExternalSemaphoreWaitParams.params.fence

Data Fields
unsigned long long	value

◆ hipExternalSemaphoreWaitParams.params.nvSciSync

union hipExternalSemaphoreWaitParams.params.nvSciSync

Data Fields
void *	fence
unsigned long long	reserved

◆ hipExternalSemaphoreWaitParams.params.keyedMutex

struct hipExternalSemaphoreWaitParams.params.keyedMutex

Data Fields
unsigned long long	key
unsigned int	timeoutMs

◆ hipLaunchAttributeValue.clusterDim

struct hipLaunchAttributeValue.clusterDim

Specifies the desired cluster dimensions for a kernel launch.

This opaque type is used as the value for the launch attribute hipLaunchAttributeClusterDimension. It defines the dimensions of the compute cluster in terms of blocks, where each field must evenly divide the corresponding grid dimension:

x: Number of blocks along the X-axis.
y: Number of blocks along the Y-axis.
z: Number of blocks along the Z-axis.

Data Fields
unsigned int	x
unsigned int	y
unsigned int	z

◆ hipMemAllocationProp.unnamed35

union hipMemAllocationProp.__unnamed35__

Data Fields
hipMemAllocationHandleType	requestedHandleType	Requested handle type.
hipMemAllocationHandleType	requestedHandleTypes	Requested handle types.

◆ hipMemAllocationProp.allocFlags

struct hipMemAllocationProp.allocFlags

Data Fields
unsigned char	compressionType	Compression type.
unsigned char	gpuDirectRDMACapable	RDMA capable.
unsigned short	usage	Usage.

◆ hipArrayMapInfo.resource

union hipArrayMapInfo.resource

Data Fields
hipArray_t	array
hipMipmappedArray	mipmap

◆ hipArrayMapInfo.subresource

union hipArrayMapInfo.subresource

Data Fields
struct hipArrayMapInfo.subresource.miptail	miptail
struct hipArrayMapInfo.subresource.sparseLevel	sparseLevel

◆ hipArrayMapInfo.subresource.sparseLevel

struct hipArrayMapInfo.subresource.sparseLevel

Data Fields
unsigned int	extentDepth	Depth in elements.
unsigned int	extentHeight	Height in elements.
unsigned int	extentWidth	Width in elements.
unsigned int	layer	For layered arrays must be a valid layer index. Otherwise, must be zero.
unsigned int	level	For mipmapped arrays must be a valid mipmap level. For arrays must be zero.
unsigned int	offsetX	X offset in elements.
unsigned int	offsetY	Y offset in elements.
unsigned int	offsetZ	Z offset in elements.

◆ hipArrayMapInfo.subresource.miptail

struct hipArrayMapInfo.subresource.miptail

Data Fields
unsigned int	layer	For layered arrays must be a valid layer index. Otherwise, must be zero.
unsigned long long	offset	Offset within mip tail.
unsigned long long	size	Extent in bytes.

◆ hipArrayMapInfo.memHandle

union hipArrayMapInfo.memHandle

Data Fields
hipMemGenericAllocationHandle_t	memHandle

◆ hipGraphNodeParams.unnamed43

union hipGraphNodeParams.__unnamed43__

Data Fields
hipMemAllocNodeParams	alloc
hipEventRecordNodeParams	eventRecord
hipEventWaitNodeParams	eventWait
hipExternalSemaphoreSignalNodeParams	extSemSignal
hipExternalSemaphoreWaitNodeParams	extSemWait
hipMemFreeNodeParams	free
hipChildGraphNodeParams	graph
hipHostNodeParams	host
hipKernelNodeParams	kernel
hipMemcpyNodeParams	memcpy
hipMemsetParams	memset
long long	reserved1[29]

◆ hipLaunchAttribute.unnamed45

union hipLaunchAttribute.__unnamed45__

Data Fields
hipLaunchAttributeValue	val	Value associated with the launch attribute.
hipLaunchAttributeValue	value	Value associated with the launch attribute.

Macro Definition Documentation

◆ __dparm

#define __dparm ( x ) = x

◆ __HIP_NODISCARD

#define __HIP_NODISCARD

◆ GENERIC_GRID_LAUNCH

#define GENERIC_GRID_LAUNCH 1

◆ HIP_DEPRECATED

#define HIP_DEPRECATED ( msg ) __attribute__((deprecated(msg)))

◆ HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Value:

  "This API is marked as deprecated and might not be supported in future releases. For more "      \
  "details please refer "                                                                          \
  "https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md"

◆ HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

Compile-time upper bound for the number of prefetch regions in hipExtDynDataPrefetchConfig. The actual device limit is queried at runtime via hipDeviceAttributeMaxDynDataPrefetchRegions.

◆ HIP_GET_PROC_ADDRESS_DEFAULT

#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

Default flag. Equivalent to HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM if compiled with -fgpu-default-stream=per-thread flag or HIP_API_PER_THREAD_DEFAULT_STREAM macro is defined.

◆ HIP_GET_PROC_ADDRESS_LEGACY_STREAM

#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

Search for all symbols except the corresponding per-thread versions.

◆ HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM

#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

Search for all symbols including the per-thread versions. If a per-thread version cannot be found, returns the legacy version.

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

◆ HIP_RESOURCE_ABI_BYTES

#define HIP_RESOURCE_ABI_BYTES 40

◆ 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

◆ hipChooseDevice

#define hipChooseDevice hipChooseDeviceR0600

◆ hipCooperativeLaunchMultiDeviceNoPostSync

#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

◆ hipCooperativeLaunchMultiDeviceNoPreSync

#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

◆ hipCpuDeviceId

#define hipCpuDeviceId ((int)-1)

◆ hipDeviceLmemResizeToMax

#define hipDeviceLmemResizeToMax 0x10

◆ hipDeviceMallocContiguous

#define hipDeviceMallocContiguous 0x4

Memory allocated will be contiguous.

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

◆ hipDrvLaunchAttribute

#define hipDrvLaunchAttribute hipLaunchAttribute

◆ hipDrvLaunchAttributeCooperative

#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

hip Drv attributes

◆ hipDrvLaunchAttributeID

#define hipDrvLaunchAttributeID hipLaunchAttributeID

◆ hipDrvLaunchAttributeValue

#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

◆ hipEnableDefault

#define hipEnableDefault 0x0

Default flag. Equivalent to hipEnablePerThreadDefaultStream if compiled with -fgpu-default-stream=per-thread flag or HIP_API_PER_THREAD_DEFAULT_STREAM macro is defined.

◆ hipEnableLegacyStream

#define hipEnableLegacyStream 0x1

Search for all symbols except the corresponding per-thread versions.

◆ hipEnablePerThreadDefaultStream

#define hipEnablePerThreadDefaultStream 0x2

Search for all symbols including the per-thread versions. If a per-thread version cannot be found, returns the legacy version.

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

◆ hipEventRecordDefault

#define hipEventRecordDefault 0x00

Default flag.

◆ hipEventRecordExternal

#define hipEventRecordExternal 0x01

Event is captured in the graph as an external event node when performing stream capture.

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

◆ hipEventWaitDefault

#define hipEventWaitDefault 0x00

Default flag.

◆ hipEventWaitExternal

#define hipEventWaitExternal 0x01

Wait is captured in the graph as an external event node when performing stream capture.

◆ hipExtAnyOrderLaunch

#define hipExtAnyOrderLaunch 0x01

AnyOrderLaunch of kernels.

◆ hipExternalMemoryDedicated

#define hipExternalMemoryDedicated 0x1

◆ hipExtHostRegisterCoarseGrained

#define hipExtHostRegisterCoarseGrained 0x8

Coarse Grained host memory lock.

◆ hipExtHostRegisterUncached

#define hipExtHostRegisterUncached 0x80000000

Map host memory onto extended fine grained access host memory pool when enabled. It is applicable on AMD devices, except for Navi4X, in Linux only.

◆ hipExtStreamWriteValueDecrement

#define hipExtStreamWriteValueDecrement 0x1001

◆ hipExtStreamWriteValueIncrement

#define hipExtStreamWriteValueIncrement 0x1000

◆ hipGetDeviceProperties

#define hipGetDeviceProperties hipGetDevicePropertiesR0600

◆ hipGraphKernelNodePortDefault

#define hipGraphKernelNodePortDefault 0

This port activates when the kernel has finished executing.

◆ hipGraphKernelNodePortLaunchCompletion

#define hipGraphKernelNodePortLaunchCompletion 2

This port activates when all blocks of the kernel have begun execution.

◆ hipGraphKernelNodePortProgrammatic

#define hipGraphKernelNodePortProgrammatic 1

This port activates when all blocks of the kernel have performed hipTriggerProgrammaticLaunchCompletion() or have terminated. It must be used with edge type hipGraphDependencyTypeProgrammatic.

◆ hipHostAllocDefault

#define hipHostAllocDefault 0x0

Default pinned memory allocation on the host.

◆ hipHostAllocMapped

#define hipHostAllocMapped 0x2

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

◆ hipHostAllocPortable

#define hipHostAllocPortable 0x1

Memory is considered allocated by all contexts.

◆ hipHostAllocUncached

#define hipHostAllocUncached hipHostMallocUncached

◆ hipHostAllocWriteCombined

#define hipHostAllocWriteCombined 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 transfer from host to device via mapped pinned memory.

Note: This flag is only for CUDA source compatibility but not functional within HIP runtime, because the allocation path is currently not supported on the AMD platform.

◆ hipHostMallocCoherent

#define hipHostMallocCoherent 0x40000000

Allocate coherent memory. Overrides HIP_HOST_COHERENT for specific allocation.

◆ hipHostMallocDefault

#define hipHostMallocDefault 0x0

Default pinned memory allocation on the host.

Note: This is the same definition as hipHostAllocPortable.

◆ hipHostMallocMapped

#define hipHostMallocMapped 0x2

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

Note: This is the same hipHostMallocMapped.

◆ hipHostMallocNonCoherent

#define hipHostMallocNonCoherent 0x80000000

Allocate non-coherent memory. Overrides HIP_HOST_COHERENT 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.

Note: This is the same definition as hipHostAllocPortable.

◆ hipHostMallocUncached

#define hipHostMallocUncached 0x10000000

Host memory will be forcedly allocated on extended fine grained system memory pool which is with MTYPE_UC.

Note: This allocation flag is applicable on AMD devices, except for Navi4X, in Linux only.

◆ 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 transfer from host to device via mapped pinned memory.

Note: This flag is the same definition as hipHostAllocWriteCombined which is equivalent to cudaHostAllocWriteCombined. It is only for CUDA source compatibility but not functional within HIP runtime, because the allocation path is currently not supported on the AMD platform.

◆ hipHostRegisterDefault

#define hipHostRegisterDefault 0x0

Memory is Mapped and Portable.

◆ hipHostRegisterIoMemory

#define hipHostRegisterIoMemory 0x4

The passed memory pointer is treated as pointing to some memory-mapped I/O space, e.g. belonging to a third-party PCIe device, and it will be marked as non cache-coherent and contiguous.

◆ 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

◆ hipKernelNodeAttributeAccessPolicyWindow

#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

◆ hipKernelNodeAttributeCooperative

#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

◆ hipKernelNodeAttributePriority

#define hipKernelNodeAttributePriority hipLaunchAttributePriority

◆ hipKernelNodeAttrID

#define hipKernelNodeAttrID hipLaunchAttributeID

Kernel node attributeID

◆ hipKernelNodeAttrValue

#define hipKernelNodeAttrValue hipLaunchAttributeValue

Kernel node attribute value

◆ 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

◆ HIPRTC_JIT_CACHE_MODE

#define HIPRTC_JIT_CACHE_MODE hipJitOptionCacheMode

CUDA Only Set cache mode.

◆ HIPRTC_JIT_ERROR_LOG_BUFFER

#define HIPRTC_JIT_ERROR_LOG_BUFFER hipJitOptionErrorLogBuffer

CUDA Only Pointer to the buffer/*#end#*‍/ with logged error(s)

◆ HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES

#define HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES hipJitOptionErrorLogBufferSizeBytes

CUDA Only Size of the buffer in/*#end#*‍/ bytes for logged error(s)

◆ HIPRTC_JIT_FALLBACK_STRATEGY

#define HIPRTC_JIT_FALLBACK_STRATEGY hipJitOptionFallbackStrategy

CUDA Only Fallback strategy.

◆ HIPRTC_JIT_FAST_COMPILE

#define HIPRTC_JIT_FAST_COMPILE hipJitOptionFastCompile

CUDA Only Set fast compile.

◆ HIPRTC_JIT_FMA

#define HIPRTC_JIT_FMA hipJitOptionFma

Deprecated:: CUDA Only Enable/*#end#*‍/ floating-point multiplies and adds/subtracts operations

◆ HIPRTC_JIT_FTZ

#define HIPRTC_JIT_FTZ hipJitOptionFtz

Deprecated:: CUDA Only Set/*#end#*‍/ single-precision denormals.

◆ HIPRTC_JIT_GENERATE_DEBUG_INFO

#define HIPRTC_JIT_GENERATE_DEBUG_INFO hipJitOptionGenerateDebugInfo

CUDA Only Generate debug information/*#end#*‍/.

◆ HIPRTC_JIT_GENERATE_LINE_INFO

#define HIPRTC_JIT_GENERATE_LINE_INFO hipJitOptionGenerateLineInfo

CUDA Only Generate line number information/*#end#*‍/.

◆ HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS

#define HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS hipJitOptionGlobalSymbolAddresses

CUDA Only Array of host addresses to be/*#end#*‍/ relocated to the device

◆ HIPRTC_JIT_GLOBAL_SYMBOL_COUNT

#define HIPRTC_JIT_GLOBAL_SYMBOL_COUNT hipJitOptionGlobalSymbolCount

CUDA Only Number of symbol count./*#end#*‍/.

◆ HIPRTC_JIT_GLOBAL_SYMBOL_NAMES

#define HIPRTC_JIT_GLOBAL_SYMBOL_NAMES hipJitOptionGlobalSymbolNames

CUDA Only Array of device symbol names to be/*#end#*‍/ relocated to the host

◆ HIPRTC_JIT_INFO_LOG_BUFFER

#define HIPRTC_JIT_INFO_LOG_BUFFER hipJitOptionInfoLogBuffer

CUDA Only Pointer to the buffer with/*#end#*‍/ logged information

◆ HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES

#define HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES hipJitOptionInfoLogBufferSizeBytes

CUDA Only Size of the buffer/*#end#*‍/ in bytes for logged info

◆ HIPRTC_JIT_INPUT_CUBIN

#define HIPRTC_JIT_INPUT_CUBIN hipJitInputCubin

Cuda only Input Cubin.

◆ HIPRTC_JIT_INPUT_FATBINARY

#define HIPRTC_JIT_INPUT_FATBINARY hipJitInputFatBinary

Cuda Only Input FAT Binary.

◆ HIPRTC_JIT_INPUT_LIBRARY

#define HIPRTC_JIT_INPUT_LIBRARY hipJitInputLibrary

Cuda Only Archive of Host Objects with embedded device code/*#end#*‍/.

◆ HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE

#define HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE hipJitInputLLVMArchivesOfBundledBitcode

HIP Only LLVM/*#end#*‍/ Archives of Bundled Bitcode

◆ HIPRTC_JIT_INPUT_LLVM_BITCODE

#define HIPRTC_JIT_INPUT_LLVM_BITCODE hipJitInputLLVMBitcode

HIP Only LLVM Bitcode or IR assembly/*#end#*‍/.

◆ HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE

#define HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE hipJitInputLLVMBundledBitcode

HIP Only LLVM Clang Bundled Code/*#end#*‍/.

◆ HIPRTC_JIT_INPUT_NVVM

#define HIPRTC_JIT_INPUT_NVVM hipJitInputNvvm

Deprecated:: CUDA only High Level intermediate code for LTO/*#end#*‍/

◆ HIPRTC_JIT_INPUT_OBJECT

#define HIPRTC_JIT_INPUT_OBJECT hipJitInputObject

Cuda Only Host Object with embedded device code/*#end#*‍/.

◆ HIPRTC_JIT_INPUT_PTX

#define HIPRTC_JIT_INPUT_PTX hipJitInputPtx

Cuda only Input PTX.

◆ HIPRTC_JIT_INPUT_SPIRV

#define HIPRTC_JIT_INPUT_SPIRV hipJitInputSpirv

HIP Only SPIRV Code Object.

◆ HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT

#define HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT hipJitOptionIRtoISAOptCountExt

HIP Only Count of linker options/*#end#*‍/ to be passed on to

◆ HIPRTC_JIT_IR_TO_ISA_OPT_EXT

#define HIPRTC_JIT_IR_TO_ISA_OPT_EXT hipJitOptionIRtoISAOptExt

HIP Only Linker options to be/*#end#*‍/ passed on to compiler

◆ HIPRTC_JIT_LOG_VERBOSE

#define HIPRTC_JIT_LOG_VERBOSE hipJitOptionLogVerbose

CUDA Only Generate log verbose.

◆ HIPRTC_JIT_LTO

#define HIPRTC_JIT_LTO hipJitOptionLto

Deprecated:: CUDA Only Enable link-time/*#end#*‍/ optimization for device code

◆ HIPRTC_JIT_MAX_REGISTERS

#define HIPRTC_JIT_MAX_REGISTERS hipJitOptionMaxRegisters

CUDA Only Maximum registers may be used in a/*#end#*‍/ thread, passed to compiler

◆ HIPRTC_JIT_MAX_THREADS_PER_BLOCK

#define HIPRTC_JIT_MAX_THREADS_PER_BLOCK hipJitOptionMaxThreadsPerBlock

CUDA only Maximum number of/*#end#*‍/ threads in a thread block

◆ HIPRTC_JIT_MIN_CTA_PER_SM

#define HIPRTC_JIT_MIN_CTA_PER_SM hipJitOptionMinCTAPerSM

CUDA Only Hints to JIT compiler/*#end#*‍/ the minimum number of CTAs frin kernel's grid to be mapped to SM

◆ HIPRTC_JIT_NEW_SM3X_OPT

#define HIPRTC_JIT_NEW_SM3X_OPT hipJitOptionSm3xOpt

Deprecated:: CUDA Only New SM3X option.

◆ HIPRTC_JIT_NUM_INPUT_TYPES

#define HIPRTC_JIT_NUM_INPUT_TYPES hipJitNumInputTypes

Count of Input Types.

◆ HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES

#define HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES hipJitNumLegacyInputTypes

Count of Legacy Input Types/*#end#*‍/.

◆ HIPRTC_JIT_NUM_OPTIONS

#define HIPRTC_JIT_NUM_OPTIONS hipJitOptionNumOptions

Number of options.

◆ HIPRTC_JIT_OPTIMIZATION_LEVEL

#define HIPRTC_JIT_OPTIMIZATION_LEVEL hipJitOptionOptimizationLevel

Value of optimization level for/*#end#*‍/ generated codes, acceptable options -O0, -O1, -O2, -O3

◆ HIPRTC_JIT_OVERRIDE_DIRECT_VALUES

#define HIPRTC_JIT_OVERRIDE_DIRECT_VALUES hipJitOptionOverrideDirectiveValues

CUDA only Override Directive/*#end#*‍/ Values

◆ HIPRTC_JIT_POSITION_INDEPENDENT_CODE

#define HIPRTC_JIT_POSITION_INDEPENDENT_CODE hipJitOptionPositionIndependentCode

CUDA Only Generates/*#end#*‍/ Position Independent code

◆ HIPRTC_JIT_PREC_DIV

#define HIPRTC_JIT_PREC_DIV hipJitOptionPrecDiv

Deprecated:: CUDA Only Set/*#end#*‍/ single-precision floating-point division and reciprocals

◆ HIPRTC_JIT_PREC_SQRT

#define HIPRTC_JIT_PREC_SQRT hipJitOptionPrecSqrt

Deprecated:: CUDA Only Set/*#end#*‍/ single-precision floating-point square root

◆ HIPRTC_JIT_TARGET

#define HIPRTC_JIT_TARGET hipJitOptionTarget

CUDA Only JIT target.

◆ HIPRTC_JIT_TARGET_FROM_HIPCONTEXT

#define HIPRTC_JIT_TARGET_FROM_HIPCONTEXT hipJitOptionTargetFromContext

CUDA Only The target context,/*#end#*‍/ which is the default

◆ HIPRTC_JIT_THREADS_PER_BLOCK

#define HIPRTC_JIT_THREADS_PER_BLOCK hipJitOptionThreadsPerBlock

CUDA Only Number of thread per block/*#end#*‍/.

◆ HIPRTC_JIT_WALL_TIME

#define HIPRTC_JIT_WALL_TIME hipJitOptionWallTime

CUDA Only Value for total wall clock time.

◆ hiprtcJIT_option

#define hiprtcJIT_option hipJitOption

hiprtc JIT option

◆ hiprtcJITInputType

#define hiprtcJITInputType hipJitInputType

hiprtc JIT input type

◆ hipStreamAttributeAccessPolicyWindow

#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

◆ hipStreamAttributeMemSyncDomain

#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

◆ hipStreamAttributeMemSyncDomainMap

#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

◆ hipStreamAttributePriority

#define hipStreamAttributePriority hipLaunchAttributePriority

◆ hipStreamAttributeSynchronizationPolicy

#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

◆ hipStreamAttrID

#define hipStreamAttrID hipLaunchAttributeID

Stream attributes

◆ hipStreamAttrValue

#define hipStreamAttrValue hipLaunchAttributeValue

◆ hipStreamDefault

#define hipStreamDefault 0x00

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

◆ hipStreamLegacy

#define hipStreamLegacy ((hipStream_t)1)

◆ 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

◆ hipStreamWriteValueDefault

#define hipStreamWriteValueDefault 0x0

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

◆ hipDevResourceDesc_t

typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t

◆ hipError_t

enum __HIP_NODISCARD hipError_t

HIP error type

◆ hipEvent_t

typedef struct ihipEvent_t* hipEvent_t

◆ hipExecutionCtx_t

typedef struct ihipExecutionCtx_t* hipExecutionCtx_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)

◆ hipKernel_t

typedef struct ihipKernel_t* hipKernel_t

◆ hipLibrary_t

typedef struct ihipLibrary_t* hipLibrary_t

◆ hipLinkState_t

typedef struct ihipLinkState_t* hipLinkState_t

◆ 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

Specifies performance hint with hipAccessPolicyWindow

Enumerator
hipAccessPropertyNormal	Normal cache persistence.
hipAccessPropertyStreaming	Streaming access is less likely to persist from cache.
hipAccessPropertyPersisting	Persisting access is more likely to persist in cache.

◆ hipArraySparseSubresourceType

enum hipArraySparseSubresourceType

Subresource types for sparse arrays

Enumerator
hipArraySparseSubresourceTypeSparseLevel	Sparse level.
hipArraySparseSubresourceTypeMiptail	Miptail.

◆ hipClusterSchedulingPolicy

enum hipClusterSchedulingPolicy

Enumerator
hipClusterSchedulingPolicyDefault	the default scheduling policy
hipClusterSchedulingPolicySpread	distribute blocks evenly across cluster's CUs
hipClusterSchedulingPolicyLoadBalancing	Dynamically balance block assignment to optimize resource usage.

◆ 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
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 multi-processors. When the GPU works in Compute Unit (CU) mode, this value equals the number of CUs; when in Workgroup Processor (WGP) mode, this value equels half of CUs, because a single WGP contains two CUs.
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. Returns pcie slot id.
hipDeviceAttributePciDomainId	PCI Domain Id.
hipDeviceAttributePciDomainID	PCI Domain ID, for backward compatibility.
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
hipDeviceAttributeHostRegisterSupported	Can device support host memory registration via hipHostRegister
hipDeviceAttributeMemoryPoolSupportedHandleTypes	Supported handle mask for HIP Stream Ordered Memory Allocator
hipDeviceAttributeHostNumaId	NUMA ID of the cpu node closest to the device, or -1 when NUMA isn't supported
hipDeviceAttributeDmaBufSupported	Device supports DMABuf buffer sharing.
hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported	GPU Direct RDMA with HIP VMM is supported (requires DMA-Buf and HIP virtual memory management)
hipDeviceAttributeHandleTypeFabricSupported	Device supports exporting memory to a fabric handle.
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.
hipDeviceAttributeNumberOfXccs	Number of XCC(s) in the device’s current compute partition(XCP). An XCC is AMD’s fundamental GPU compute tile. Devices like MI300X include multiple XCCs per package. Value varies by boot‑time partition mode(compute or memory). Partition modes can be set using amd‑smi.
hipDeviceAttributeMaxAvailableVgprsPerThread	Max number of available (directly or indirectly addressable) VGPRs per thread in DWORDs.
hipDeviceAttributePciChipId	GPU Manufacturer device id.
hipDeviceAttributeExpertSchedMode	'1' if Device supports expert scheduling mode, '0' otherwise.
hipDeviceAttributeMaxDynDataPrefetchRegions	Maximum number of dynamic data prefetch regions per kernel launch (0 if unsupported).
hipDeviceAttributeAmdSpecificEnd
hipDeviceAttributeVendorSpecificBegin

◆ hipDeviceP2PAttr

enum hipDeviceP2PAttr

Enumerator
hipDevP2PAttrPerformanceRank
hipDevP2PAttrAccessSupported
hipDevP2PAttrNativeAtomicSupported
hipDevP2PAttrHipArrayAccessSupported

◆ hipDevResourceType

enum hipDevResourceType

Enumerator
hipDevResourceTypeInvalid
hipDevResourceTypeSm
hipDevResourceTypeWorkqueueConfig
hipDevResourceTypeWorkqueue

◆ hipDevSmResourceGroup_flags

enum hipDevSmResourceGroup_flags

Enumerator
hipDevSmResourceGroupDefault
hipDevSmResourceGroupBackfill

◆ hipDevSmResourceSplitByCount_flags

enum hipDevSmResourceSplitByCount_flags

Enumerator
hipDevSmResourceSplitIgnoreSmCoscheduling
hipDevSmResourceSplitMaxPotentialClusterSize

◆ hipDevWorkqueueConfigScope

enum hipDevWorkqueueConfigScope

Enumerator
hipDevWorkqueueConfigScopeDeviceCtx
hipDevWorkqueueConfigScopeGreenCtxBalanced

◆ hipDriverEntryPointQueryResult

enum hipDriverEntryPointQueryResult

Enumerator
hipDriverEntryPointSuccess
hipDriverEntryPointSymbolNotFound
hipDriverEntryPointVersionNotSufficent

◆ hipDriverProcAddressQueryResult

enum hipDriverProcAddressQueryResult

Enumerator
HIP_GET_PROC_ADDRESS_SUCCESS
HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND
HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

◆ hipExtDynDataPrefetchTemporal

enum hipExtDynDataPrefetchTemporal

Temporal locality hint for dynamic data prefetch.

Enumerator
hipExtDynDataPrefetchTemporalRegular	Regular temporal locality.
hipExtDynDataPrefetchTemporalHigh	High temporal locality (prefer caching)

◆ 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	The maximum number of bytes requested for dynamically allocated shared memory.
hipFuncAttributePreferredSharedMemoryCarveout	Sets the percentage of total shared memory allocated as the shared memory carveout.
hipFuncAttributeClusterDimMustBeSet	The kernel must launch with a valid cluster size specified.
hipFuncAttributeRequiredClusterWidth	The required cluster width in blocks.
hipFuncAttributeRequiredClusterHeight	The required cluster height in blocks.
hipFuncAttributeRequiredClusterDepth	The required cluster depth in blocks.
hipFuncAttributeNonPortableClusterSizeAllowed	Is the function allowed to launch with non-portable cluster size.
hipFuncAttributeClusterSchedulingPolicyPreference	The block scheduling policy of a function.
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	Hip devices used by current OpenGL context in current frame
hipGLDeviceListNextFrame	Hip devices used by current OpenGL context in next frame.

◆ 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

◆ hipGraphDependencyType

enum hipGraphDependencyType

Enumerator
hipGraphDependencyTypeDefault
hipGraphDependencyTypeProgrammatic

◆ 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, read only.
hipGraphicsRegisterFlagsWriteDiscard	HIP will only write and will not read from this registered resource, write only.
hipGraphicsRegisterFlagsSurfaceLoadStore	HIP will bind this resource to a surface, read and write.
hipGraphicsRegisterFlagsTextureGather	HIP will perform texture gather operations on this registered resource, read and write or read only.

◆ hipGraphInstantiateFlags

enum hipGraphInstantiateFlags

Enumerator
hipGraphInstantiateFlagAutoFreeOnLaunch	Automatically free memory allocated in a graph before relaunching.
hipGraphInstantiateFlagUpload	Automatically upload the graph after instantiation.
hipGraphInstantiateFlagDeviceLaunch	Instantiate the graph to be launched from the device.
hipGraphInstantiateFlagUseNodePriority	Run the graph using the per-node priority attributes rather than the priority of the stream it is launched into.

◆ hipGraphInstantiateResult

enum hipGraphInstantiateResult

hipGraphInstantiateWithParams results

Enumerator
hipGraphInstantiateSuccess	Instantiation Success
hipGraphInstantiateError	Instantiation failed for an unexpected reason which is described in the return value of the function
hipGraphInstantiateInvalidStructure	Instantiation failed due to invalid structure, such as cycles
hipGraphInstantiateNodeOperationNotSupported	Instantiation for device launch failed because the graph contained an unsupported operation
hipGraphInstantiateMultipleDevicesNotSupported	Instantiation for device launch failed due to the nodes belonging to different contexts

◆ 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.
hipGraphNodeTypeBatchMemOp	BatchMemOp node.
hipGraphNodeTypeCount

◆ hipLaunchAttributeID

enum hipLaunchAttributeID

Launch Attribute ID

Enumerator
hipLaunchAttributeIgnore	Ignored entry.
hipLaunchAttributeAccessPolicyWindow	Valid for Streams, graph nodes, launches.
hipLaunchAttributeCooperative	Valid for graph nodes, launches.
hipLaunchAttributeSynchronizationPolicy	Valid for streams.
hipLaunchAttributeClusterDimension	Valid for graph nodes, launches.
hipLaunchAttributeClusterSchedulingPolicyPreference	Valid for graph nodes, launches.
hipLaunchAttributePriority	Valid for graph node, streams, launches.
hipLaunchAttributeMemSyncDomainMap	Valid for streams, graph nodes, launches.
hipLaunchAttributeMemSyncDomain	Valid for streams, graph nodes, launches.
hipLaunchAttributeExtDynDataPrefetch	Valid for launches. Prefetch data into L2 before kernel execution.
hipLaunchAttributeMax

◆ hipLaunchMemSyncDomain

enum hipLaunchMemSyncDomain

Memory Synchronization Domain

Enumerator
hipLaunchMemSyncDomainDefault	Launch kernels in the default domain
hipLaunchMemSyncDomainRemote	Launch kernels in the remote domain

◆ 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
hipExtLimitScratchMin	Minimum allowed value in bytes for scratch limit on this device. Valid only on Rocm device. This is read only.
hipExtLimitScratchMax	Maximum allowed value in bytes for scratch limit on this device. Valid only on Rocm device. This is read only.
hipExtLimitScratchCurrent	Current scratch limit threshold in bytes on this device. Must be between hipExtLimitScratchMin and hipExtLimitScratchMaxValid values. Valid only on Rocm device. This can be modified.
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)
hipMemHandleTypeFabric	Allows a fabric handle to be used for exporting.

◆ 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
hipMemAllocationTypeManaged
hipMemAllocationTypeUncached
hipMemAllocationTypeMax

◆ hipMemHandleType

enum hipMemHandleType

Memory handle type

Enumerator
hipMemHandleTypeGeneric	Generic handle type.

◆ 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	The last location to where the range was prefetched
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

◆ hipMemRangeFlags

enum hipMemRangeFlags

Mem Range Flags used in hipMemGetHandleForAddressRange.

Enumerator
hipMemRangeFlagDmaBufMappingTypePcie
hipMemRangeFlagsMax

◆ hipMemRangeHandleType

enum hipMemRangeHandleType

Requested handle type for address range.

Enumerator
hipMemRangeHandleTypeDmaBufFd
hipMemRangeHandleTypeMax

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

◆ hipStreamBatchMemOpType

enum hipStreamBatchMemOpType

Operations for hipStreamBatchMemOp

Enumerator
hipStreamMemOpWaitValue32
hipStreamMemOpWriteValue32
hipStreamMemOpWaitValue64
hipStreamMemOpWriteValue64
hipStreamMemOpBarrier	Currently not supported.
hipStreamMemOpFlushRemoteWrites	Currently not supported.

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

◆ hipSynchronizationPolicy

enum hipSynchronizationPolicy

Stream Synchronization Policy. Can be set with hipStreamSetAttribute

Enumerator
hipSyncPolicyAuto	Default Synchronization Policy. Host thread waits actively
hipSyncPolicySpin	Host thread spins in tight loop waiting for completition
hipSyncPolicyYield	Host spins but yields to other threads, reducing CPU usage
hipSyncPolicyBlockingSync	Host thread blocks (sleeps) until the stream completes

◆ hipUserObjectFlags

enum hipUserObjectFlags

Enumerator
hipUserObjectNoDestructorSync	Destructor execution is not synchronized.

◆ hipUserObjectRetainFlags

enum hipUserObjectRetainFlags

Enumerator
hipGraphUserObjectMove	Add new reference or retain.

Global enum and defines

Global enum and defines#

Namespaces

Data Structures

Macros

Typedefs

Enumerations

Detailed Description

Data Structure Documentation

◆ hipDeviceArch_t

◆ hipUUID

◆ hipDeviceProp_t

◆ hipPointerAttribute_t

◆ hipDevSmResource

◆ hipDevWorkqueueConfigResource

◆ hipDevWorkqueueResource

◆ hipDevResource

◆ hipDevSmResourceGroupParams

◆ hipIpcMemHandle_t

◆ hipIpcEventHandle_t

◆ hipMemFabricHandle_t

◆ hipFuncAttributes

◆ hipStreamBatchMemOpParams

◆ hipBatchMemOpNodeParams

◆ hipMemAccessDesc

◆ hipMemPoolProps

◆ hipMemPoolPtrExportData

◆ hipLaunchParams

◆ hipFunctionLaunchParams

◆ hipExternalMemoryHandleDesc

◆ hipExternalMemoryBufferDesc

◆ hipExternalMemoryMipmappedArrayDesc

◆ hipExternalSemaphoreHandleDesc

◆ hipExternalSemaphoreSignalParams

◆ hipExternalSemaphoreWaitParams

◆ hipHostNodeParams

◆ hipKernelNodeParams

◆ hipMemsetParams

◆ hipMemAllocNodeParams

◆ hipAccessPolicyWindow

◆ hipLaunchMemSyncDomainMap

◆ hipExtDynDataPrefetchRegion

◆ hipExtDynDataPrefetchConfig

◆ hipLaunchAttributeValue

◆ hipGraphInstantiateParams

◆ hipMemAllocationProp

◆ hipExternalSemaphoreSignalNodeParams

◆ hipExternalSemaphoreWaitNodeParams

◆ hipArrayMapInfo

◆ hipMemcpyNodeParams

◆ hipChildGraphNodeParams

◆ hipEventWaitNodeParams

◆ hipEventRecordNodeParams

◆ hipMemFreeNodeParams

◆ hipGraphNodeParams

◆ hipGraphEdgeData

◆ hipLaunchAttribute

◆ hipLaunchConfig_t

◆ HIP_LAUNCH_CONFIG

◆ hipArrayMemoryRequirements

◆ hipDevResource.__unnamed16__

◆ hipExternalMemoryHandleDesc.handle

◆ hipExternalMemoryHandleDesc.handle.win32

◆ hipExternalSemaphoreHandleDesc.handle

◆ hipExternalSemaphoreHandleDesc.handle.win32

◆ hipExternalSemaphoreSignalParams.params

◆ hipExternalSemaphoreSignalParams.params.fence

◆ hipExternalSemaphoreSignalParams.params.nvSciSync

◆ hipExternalSemaphoreSignalParams.params.keyedMutex

◆ hipExternalSemaphoreWaitParams.params

◆ hipExternalSemaphoreWaitParams.params.fence

◆ hipExternalSemaphoreWaitParams.params.nvSciSync

◆ hipExternalSemaphoreWaitParams.params.keyedMutex

◆ hipLaunchAttributeValue.clusterDim

◆ hipMemAllocationProp.__unnamed35__

◆ hipMemAllocationProp.allocFlags

◆ hipArrayMapInfo.resource

◆ hipArrayMapInfo.subresource

◆ hipArrayMapInfo.subresource.sparseLevel

◆ hipArrayMapInfo.subresource.miptail

◆ hipDevResource.unnamed16

◆ hipMemAllocationProp.unnamed35

◆ hipGraphNodeParams.unnamed43

◆ hipLaunchAttribute.unnamed45