Classes
struct	hipMemLocation

struct	hipMemAccessDesc

struct	hipMemPoolProps

struct	hipMemPoolPtrExportData

struct	dim3

struct	hipLaunchParams_t

struct	hipFunctionLaunchParams_t

struct	hipExternalMemoryHandleDesc_st

struct	hipExternalMemoryBufferDesc_st

struct	hipExternalSemaphoreHandleDesc_st

struct	hipExternalSemaphoreSignalParams_st

struct	hipExternalSemaphoreWaitParams_st

struct	hipHostNodeParams

struct	hipKernelNodeParams

struct	hipMemsetParams

struct	hipMemAllocNodeParams

struct	hipAccessPolicyWindow

union	hipKernelNodeAttrValue

struct	hipMemAllocationProp

struct	hipArrayMapInfo

Macros
#define	__HIP_NODISCARD

#define	hipStreamDefault 0x00

#define	hipStreamNonBlocking 0x01

#define	hipEventDefault 0x0

#define	hipEventBlockingSync 0x1

#define	hipEventDisableTiming 0x2

#define	hipEventInterprocess 0x4

#define	hipEventReleaseToDevice 0x40000000

#define	hipEventReleaseToSystem 0x80000000

#define	hipHostMallocDefault 0x0

#define	hipHostMallocPortable 0x1

#define	hipHostMallocMapped 0x2

#define	hipHostMallocWriteCombined 0x4

#define	hipHostMallocNumaUser 0x20000000

#define	hipHostMallocCoherent 0x40000000

#define	hipHostMallocNonCoherent 0x80000000

#define	hipMemAttachGlobal 0x01

#define	hipMemAttachHost 0x02

#define	hipMemAttachSingle 0x04

#define	hipDeviceMallocDefault 0x0

#define	hipDeviceMallocFinegrained 0x1

#define	hipMallocSignalMemory 0x2

#define	hipDeviceMallocUncached 0x3

#define	hipHostRegisterDefault 0x0

#define	hipHostRegisterPortable 0x1

#define	hipHostRegisterMapped 0x2

#define	hipHostRegisterIoMemory 0x4

#define	hipExtHostRegisterCoarseGrained 0x8

#define	hipDeviceScheduleAuto 0x0

#define	hipDeviceScheduleSpin 0x1

#define	hipDeviceScheduleYield 0x2

#define	hipDeviceScheduleBlockingSync 0x4

#define	hipDeviceScheduleMask 0x7

#define	hipDeviceMapHost 0x8

#define	hipDeviceLmemResizeToMax 0x10

#define	hipArrayDefault 0x00

#define	hipArrayLayered 0x01

#define	hipArraySurfaceLoadStore 0x02

#define	hipArrayCubemap 0x04

#define	hipArrayTextureGather 0x08

#define	hipOccupancyDefault 0x00

#define	hipOccupancyDisableCachingOverride 0x01

#define	hipCooperativeLaunchMultiDeviceNoPreSync 0x01

#define	hipCooperativeLaunchMultiDeviceNoPostSync 0x02

#define	hipCpuDeviceId ((int)-1)

#define	hipInvalidDeviceId ((int)-2)

#define	hipExtAnyOrderLaunch 0x01

#define	hipStreamWaitValueGte 0x0

#define	hipStreamWaitValueEq 0x1

#define	hipStreamWaitValueAnd 0x2

#define	hipStreamWaitValueNor 0x3

#define	hipStreamPerThread ((hipStream_t)2)

#define	hipExternalMemoryDedicated 0x1

Typedefs
typedef enum __HIP_NODISCARD hipError_t	hipError_t

typedef enum hipDeviceAttribute_t	hipDeviceAttribute_t

typedef enum hipMemoryAdvise	hipMemoryAdvise

typedef enum hipMemRangeCoherencyMode	hipMemRangeCoherencyMode

typedef enum hipMemRangeAttribute	hipMemRangeAttribute

typedef enum hipMemPoolAttr	hipMemPoolAttr

typedef enum hipMemLocationType	hipMemLocationType

typedef struct hipMemLocation	hipMemLocation

typedef enum hipMemAccessFlags	hipMemAccessFlags

typedef struct hipMemAccessDesc	hipMemAccessDesc

typedef enum hipMemAllocationType	hipMemAllocationType

typedef enum hipMemAllocationHandleType	hipMemAllocationHandleType

typedef struct hipMemPoolProps	hipMemPoolProps

typedef struct hipMemPoolPtrExportData	hipMemPoolPtrExportData

typedef enum hipJitOption	hipJitOption

typedef enum hipFuncAttribute	hipFuncAttribute

typedef enum hipFuncCache_t	hipFuncCache_t

typedef enum hipSharedMemConfig	hipSharedMemConfig

typedef struct dim3	dim3

typedef struct hipLaunchParams_t	hipLaunchParams

typedef struct hipFunctionLaunchParams_t	hipFunctionLaunchParams

typedef enum hipExternalMemoryHandleType_enum	hipExternalMemoryHandleType

typedef struct hipExternalMemoryHandleDesc_st	hipExternalMemoryHandleDesc

typedef struct hipExternalMemoryBufferDesc_st	hipExternalMemoryBufferDesc

typedef void *	hipExternalMemory_t

typedef enum hipExternalSemaphoreHandleType_enum	hipExternalSemaphoreHandleType

typedef struct hipExternalSemaphoreHandleDesc_st	hipExternalSemaphoreHandleDesc

typedef void *	hipExternalSemaphore_t

typedef struct hipExternalSemaphoreSignalParams_st	hipExternalSemaphoreSignalParams

typedef struct hipExternalSemaphoreWaitParams_st	hipExternalSemaphoreWaitParams

typedef enum hipGLDeviceList	hipGLDeviceList

typedef enum hipGraphicsRegisterFlags	hipGraphicsRegisterFlags

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

typedef void(*	hipHostFn_t) (void *userData)

typedef struct hipHostNodeParams	hipHostNodeParams

typedef struct hipKernelNodeParams	hipKernelNodeParams

typedef struct hipMemsetParams	hipMemsetParams

typedef struct hipMemAllocNodeParams	hipMemAllocNodeParams

typedef enum hipKernelNodeAttrID	hipKernelNodeAttrID

typedef enum hipAccessProperty	hipAccessProperty

typedef struct hipAccessPolicyWindow	hipAccessPolicyWindow

typedef union hipKernelNodeAttrValue	hipKernelNodeAttrValue

typedef enum hipGraphExecUpdateResult	hipGraphExecUpdateResult

typedef enum hipStreamCaptureMode	hipStreamCaptureMode

typedef enum hipStreamCaptureStatus	hipStreamCaptureStatus

typedef enum hipStreamUpdateCaptureDependenciesFlags	hipStreamUpdateCaptureDependenciesFlags

typedef enum hipGraphMemAttributeType	hipGraphMemAttributeType

typedef enum hipUserObjectFlags	hipUserObjectFlags

typedef enum hipUserObjectRetainFlags	hipUserObjectRetainFlags

typedef enum hipGraphInstantiateFlags	hipGraphInstantiateFlags

typedef struct hipMemAllocationProp	hipMemAllocationProp

typedef struct ihipMemGenericAllocationHandle *	hipMemGenericAllocationHandle_t

typedef enum hipMemAllocationGranularity_flags	hipMemAllocationGranularity_flags

typedef enum hipMemHandleType	hipMemHandleType

typedef enum hipMemOperationType	hipMemOperationType

typedef enum hipArraySparseSubresourceType	hipArraySparseSubresourceType

typedef struct hipArrayMapInfo	hipArrayMapInfo

Enumerations
enum	hipDeviceAttribute_t { hipDeviceAttributeCudaCompatibleBegin = 0, hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin, hipDeviceAttributeAccessPolicyMaxWindowSize, hipDeviceAttributeAsyncEngineCount, hipDeviceAttributeCanMapHostMemory, hipDeviceAttributeCanUseHostPointerForRegisteredMem, hipDeviceAttributeClockRate, hipDeviceAttributeComputeMode, hipDeviceAttributeComputePreemptionSupported, hipDeviceAttributeConcurrentKernels, hipDeviceAttributeConcurrentManagedAccess, hipDeviceAttributeCooperativeLaunch, hipDeviceAttributeCooperativeMultiDeviceLaunch, hipDeviceAttributeDeviceOverlap, hipDeviceAttributeDirectManagedMemAccessFromHost, hipDeviceAttributeGlobalL1CacheSupported, hipDeviceAttributeHostNativeAtomicSupported, hipDeviceAttributeIntegrated, hipDeviceAttributeIsMultiGpuBoard, hipDeviceAttributeKernelExecTimeout, hipDeviceAttributeL2CacheSize, hipDeviceAttributeLocalL1CacheSupported, hipDeviceAttributeLuid, hipDeviceAttributeLuidDeviceNodeMask, hipDeviceAttributeComputeCapabilityMajor, hipDeviceAttributeManagedMemory, hipDeviceAttributeMaxBlocksPerMultiProcessor, hipDeviceAttributeMaxBlockDimX, hipDeviceAttributeMaxBlockDimY, hipDeviceAttributeMaxBlockDimZ, hipDeviceAttributeMaxGridDimX, hipDeviceAttributeMaxGridDimY, hipDeviceAttributeMaxGridDimZ, hipDeviceAttributeMaxSurface1D, hipDeviceAttributeMaxSurface1DLayered, hipDeviceAttributeMaxSurface2D, hipDeviceAttributeMaxSurface2DLayered, hipDeviceAttributeMaxSurface3D, hipDeviceAttributeMaxSurfaceCubemap, hipDeviceAttributeMaxSurfaceCubemapLayered, hipDeviceAttributeMaxTexture1DWidth, hipDeviceAttributeMaxTexture1DLayered, hipDeviceAttributeMaxTexture1DLinear, hipDeviceAttributeMaxTexture1DMipmap, hipDeviceAttributeMaxTexture2DWidth, hipDeviceAttributeMaxTexture2DHeight, hipDeviceAttributeMaxTexture2DGather, hipDeviceAttributeMaxTexture2DLayered, hipDeviceAttributeMaxTexture2DLinear, hipDeviceAttributeMaxTexture2DMipmap, hipDeviceAttributeMaxTexture3DWidth, hipDeviceAttributeMaxTexture3DHeight, hipDeviceAttributeMaxTexture3DDepth, hipDeviceAttributeMaxTexture3DAlt, hipDeviceAttributeMaxTextureCubemap, hipDeviceAttributeMaxTextureCubemapLayered, hipDeviceAttributeMaxThreadsDim, hipDeviceAttributeMaxThreadsPerBlock, hipDeviceAttributeMaxThreadsPerMultiProcessor, hipDeviceAttributeMaxPitch, hipDeviceAttributeMemoryBusWidth, hipDeviceAttributeMemoryClockRate, hipDeviceAttributeComputeCapabilityMinor, hipDeviceAttributeMultiGpuBoardGroupID, hipDeviceAttributeMultiprocessorCount, hipDeviceAttributeName, hipDeviceAttributePageableMemoryAccess, hipDeviceAttributePageableMemoryAccessUsesHostPageTables, hipDeviceAttributePciBusId, hipDeviceAttributePciDeviceId, hipDeviceAttributePciDomainID, hipDeviceAttributePersistingL2CacheMaxSize, hipDeviceAttributeMaxRegistersPerBlock, hipDeviceAttributeMaxRegistersPerMultiprocessor, hipDeviceAttributeReservedSharedMemPerBlock, hipDeviceAttributeMaxSharedMemoryPerBlock, hipDeviceAttributeSharedMemPerBlockOptin, hipDeviceAttributeSharedMemPerMultiprocessor, hipDeviceAttributeSingleToDoublePrecisionPerfRatio, hipDeviceAttributeStreamPrioritiesSupported, hipDeviceAttributeSurfaceAlignment, hipDeviceAttributeTccDriver, hipDeviceAttributeTextureAlignment, hipDeviceAttributeTexturePitchAlignment, hipDeviceAttributeTotalConstantMemory, hipDeviceAttributeTotalGlobalMem, hipDeviceAttributeUnifiedAddressing, hipDeviceAttributeUuid, hipDeviceAttributeWarpSize, hipDeviceAttributeMemoryPoolsSupported, hipDeviceAttributeVirtualMemoryManagementSupported, hipDeviceAttributeCudaCompatibleEnd = 9999, hipDeviceAttributeAmdSpecificBegin = 10000, hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin, hipDeviceAttributeArch, hipDeviceAttributeMaxSharedMemoryPerMultiprocessor, hipDeviceAttributeGcnArch, hipDeviceAttributeGcnArchName, hipDeviceAttributeHdpMemFlushCntl, hipDeviceAttributeHdpRegFlushCntl, hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc, hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim, hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim, hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem, hipDeviceAttributeIsLargeBar, hipDeviceAttributeAsicRevision, hipDeviceAttributeCanUseStreamWaitValue, hipDeviceAttributeImageSupport, hipDeviceAttributePhysicalMultiProcessorCount, hipDeviceAttributeFineGrainSupport, hipDeviceAttributeWallClockRate, hipDeviceAttributeAmdSpecificEnd = 19999, hipDeviceAttributeVendorSpecificBegin = 20000 }

enum	hipComputeMode { hipComputeModeDefault = 0, hipComputeModeExclusive = 1, hipComputeModeProhibited = 2, hipComputeModeExclusiveProcess = 3 }

enum	hipMemoryAdvise { hipMemAdviseSetReadMostly = 1, hipMemAdviseUnsetReadMostly = 2, hipMemAdviseSetPreferredLocation = 3, hipMemAdviseUnsetPreferredLocation = 4, hipMemAdviseSetAccessedBy = 5, hipMemAdviseUnsetAccessedBy = 6, hipMemAdviseSetCoarseGrain = 100, hipMemAdviseUnsetCoarseGrain = 101 }

enum	hipMemRangeCoherencyMode { hipMemRangeCoherencyModeFineGrain = 0, hipMemRangeCoherencyModeCoarseGrain = 1, hipMemRangeCoherencyModeIndeterminate = 2 }

enum	hipMemRangeAttribute { hipMemRangeAttributeReadMostly = 1, hipMemRangeAttributePreferredLocation = 2, hipMemRangeAttributeAccessedBy = 3, hipMemRangeAttributeLastPrefetchLocation = 4, hipMemRangeAttributeCoherencyMode = 100 }

enum	hipMemPoolAttr { hipMemPoolReuseFollowEventDependencies = 0x1, hipMemPoolReuseAllowOpportunistic = 0x2, hipMemPoolReuseAllowInternalDependencies = 0x3, hipMemPoolAttrReleaseThreshold = 0x4, hipMemPoolAttrReservedMemCurrent = 0x5, hipMemPoolAttrReservedMemHigh = 0x6, hipMemPoolAttrUsedMemCurrent = 0x7, hipMemPoolAttrUsedMemHigh = 0x8 }

enum	hipMemLocationType { hipMemLocationTypeInvalid = 0, hipMemLocationTypeDevice = 1 }

enum	hipMemAccessFlags { hipMemAccessFlagsProtNone = 0, hipMemAccessFlagsProtRead = 1, hipMemAccessFlagsProtReadWrite = 3 }

enum	hipMemAllocationType { hipMemAllocationTypeInvalid = 0x0, hipMemAllocationTypePinned = 0x1, hipMemAllocationTypeMax = 0x7FFFFFFF }

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

enum	hipJitOption { hipJitOptionMaxRegisters = 0, hipJitOptionThreadsPerBlock, hipJitOptionWallTime, hipJitOptionInfoLogBuffer, hipJitOptionInfoLogBufferSizeBytes, hipJitOptionErrorLogBuffer, hipJitOptionErrorLogBufferSizeBytes, hipJitOptionOptimizationLevel, hipJitOptionTargetFromContext, hipJitOptionTarget, hipJitOptionFallbackStrategy, hipJitOptionGenerateDebugInfo, hipJitOptionLogVerbose, hipJitOptionGenerateLineInfo, hipJitOptionCacheMode, hipJitOptionSm3xOpt, hipJitOptionFastCompile, hipJitOptionNumOptions }

enum	hipFuncAttribute { hipFuncAttributeMaxDynamicSharedMemorySize = 8, hipFuncAttributePreferredSharedMemoryCarveout = 9, hipFuncAttributeMax }

enum	hipFuncCache_t { hipFuncCachePreferNone, hipFuncCachePreferShared, hipFuncCachePreferL1, hipFuncCachePreferEqual }

enum	hipSharedMemConfig { hipSharedMemBankSizeDefault, hipSharedMemBankSizeFourByte, hipSharedMemBankSizeEightByte }

enum	hipExternalMemoryHandleType_enum { hipExternalMemoryHandleTypeOpaqueFd = 1, hipExternalMemoryHandleTypeOpaqueWin32 = 2, hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3, hipExternalMemoryHandleTypeD3D12Heap = 4, hipExternalMemoryHandleTypeD3D12Resource = 5, hipExternalMemoryHandleTypeD3D11Resource = 6, hipExternalMemoryHandleTypeD3D11ResourceKmt = 7 }

enum	hipExternalSemaphoreHandleType_enum { hipExternalSemaphoreHandleTypeOpaqueFd = 1, hipExternalSemaphoreHandleTypeOpaqueWin32 = 2, hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3, hipExternalSemaphoreHandleTypeD3D12Fence = 4 }

enum	hipGLDeviceList { hipGLDeviceListAll = 1, hipGLDeviceListCurrentFrame = 2, hipGLDeviceListNextFrame = 3 }

enum	hipGraphicsRegisterFlags { hipGraphicsRegisterFlagsNone = 0, hipGraphicsRegisterFlagsReadOnly = 1, hipGraphicsRegisterFlagsWriteDiscard, hipGraphicsRegisterFlagsSurfaceLoadStore = 4, hipGraphicsRegisterFlagsTextureGather }

enum	hipGraphNodeType { hipGraphNodeTypeKernel = 0, hipGraphNodeTypeMemcpy = 1, hipGraphNodeTypeMemset = 2, hipGraphNodeTypeHost = 3, hipGraphNodeTypeGraph = 4, hipGraphNodeTypeEmpty = 5, hipGraphNodeTypeWaitEvent = 6, hipGraphNodeTypeEventRecord = 7, hipGraphNodeTypeExtSemaphoreSignal = 8, hipGraphNodeTypeExtSemaphoreWait = 9, hipGraphNodeTypeMemAlloc = 10, hipGraphNodeTypeMemFree = 11, hipGraphNodeTypeMemcpyFromSymbol = 12, hipGraphNodeTypeMemcpyToSymbol = 13, hipGraphNodeTypeCount }

enum	hipKernelNodeAttrID { hipKernelNodeAttributeAccessPolicyWindow = 1, hipKernelNodeAttributeCooperative = 2 }

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

enum	hipGraphExecUpdateResult { hipGraphExecUpdateSuccess = 0x0, hipGraphExecUpdateError = 0x1, hipGraphExecUpdateErrorTopologyChanged = 0x2, hipGraphExecUpdateErrorNodeTypeChanged = 0x3, hipGraphExecUpdateErrorFunctionChanged, hipGraphExecUpdateErrorParametersChanged, hipGraphExecUpdateErrorNotSupported, hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7 }

enum	hipStreamCaptureMode { hipStreamCaptureModeGlobal = 0, hipStreamCaptureModeThreadLocal, hipStreamCaptureModeRelaxed }

enum	hipStreamCaptureStatus { hipStreamCaptureStatusNone = 0, hipStreamCaptureStatusActive, hipStreamCaptureStatusInvalidated }

enum	hipStreamUpdateCaptureDependenciesFlags { hipStreamAddCaptureDependencies = 0, hipStreamSetCaptureDependencies }

enum	hipGraphMemAttributeType { hipGraphMemAttrUsedMemCurrent = 0, hipGraphMemAttrUsedMemHigh, hipGraphMemAttrReservedMemCurrent, hipGraphMemAttrReservedMemHigh }

enum	hipUserObjectFlags { hipUserObjectNoDestructorSync = 0x1 }

enum	hipUserObjectRetainFlags { hipGraphUserObjectMove = 0x1 }

enum	hipGraphInstantiateFlags { hipGraphInstantiateFlagAutoFreeOnLaunch }

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

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

enum	hipMemHandleType { hipMemHandleTypeGeneric = 0x0 }

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

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

Detailed Description

Macro Definition Documentation

#define hipArrayDefault 0x00

Default HIP array allocation flag.

#define hipDeviceMallocFinegrained 0x1

Memory is allocated in fine grained region of device.

#define hipDeviceMallocUncached 0x3

Memory allocated will be uncached.

#define hipDeviceScheduleAuto 0x0

Automatically select between Spin and Yield.

#define hipDeviceScheduleSpin 0x1

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

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

#define hipEventBlockingSync 0x1

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

#define hipEventDefault 0x0

Default flags.

#define hipEventDisableTiming 0x2

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

#define hipEventInterprocess 0x4

Event can support IPC. hipEventDisableTiming also must be set.

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

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

#define hipExtAnyOrderLaunch 0x01

AnyOrderLaunch of kernels.

#define hipExtHostRegisterCoarseGrained 0x8

Coarse Grained host memory lock.

#define hipHostMallocCoherent 0x40000000

Allocate coherent memory. Overrides HIP_COHERENT_HOST_ALLOC for specific allocation.

#define hipHostMallocDefault 0x0

Default pinned memory allocation on the host.

#define hipHostMallocMapped 0x2

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

#define hipHostMallocNonCoherent 0x80000000

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

#define hipHostMallocNumaUser 0x20000000

Host memory allocation will follow numa policy set by user.

#define hipHostMallocPortable 0x1

Memory is considered allocated by all contexts.

#define hipHostMallocWriteCombined 0x4

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

#define hipHostRegisterDefault 0x0

Memory is Mapped and Portable.

#define hipHostRegisterIoMemory 0x4

Not supported.

#define hipHostRegisterMapped 0x2

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

#define hipHostRegisterPortable 0x1

Memory is considered registered by all contexts.

#define hipMallocSignalMemory 0x2

Memory represents a HSA signal.

#define hipMemAttachGlobal 0x01

Memory can be accessed by any stream on any device

#define hipMemAttachHost 0x02

Memory cannot be accessed by any stream on any device.

#define hipMemAttachSingle 0x04

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

#define hipStreamDefault 0x00

Default stream creation flags. These are used with hipStreamCreate().

#define hipStreamNonBlocking 0x01

Stream does not implicitly synchronize with null stream.

#define hipStreamPerThread ((hipStream_t)2)

Implicit stream per application thread.

Typedef Documentation

typedef struct dim3 dim3

Struct for data in 3D

typedef struct hipArrayMapInfo hipArrayMapInfo

Map info for arrays

typedef struct hipExternalSemaphoreWaitParams_st hipExternalSemaphoreWaitParams

External semaphore wait parameters, compatible with driver type

typedef enum hipFuncAttribute hipFuncAttribute

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

typedef enum hipFuncCache_t hipFuncCache_t

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

typedef struct ihipGraph* hipGraph_t

An opaque value that represents a hip graph

typedef struct hipGraphExec* hipGraphExec_t

An opaque value that represents a hip graph Exec

typedef struct hipGraphNode* hipGraphNode_t

An opaque value that represents a hip graph node

typedef struct hipMemAccessDesc hipMemAccessDesc

Memory access descriptor

typedef struct hipMemAllocationProp hipMemAllocationProp

Memory allocation properties

typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t

Generic handle for memory allocation

typedef struct hipMemLocation hipMemLocation

Specifies a memory location.

To specify a gpu, set type = hipMemLocationTypeDevice and set id = the gpu's device ID

typedef struct hipMemPoolProps hipMemPoolProps

Specifies the properties of allocations made from the pool.

typedef struct hipMemPoolPtrExportData hipMemPoolPtrExportData

Opaque data structure for exporting a pool allocation

typedef enum hipSharedMemConfig hipSharedMemConfig

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

typedef struct hipUserObject* hipUserObject_t

An opaque value that represents a user obj

Enumeration Type Documentation

enum hipArraySparseSubresourceType

Enumerator
hipArraySparseSubresourceTypeSparseLevel	Sparse level.
hipArraySparseSubresourceTypeMiptail	Miptail.

enum hipDeviceAttribute_t

Enumerator
hipDeviceAttributeEccEnabled	Whether ECC support is enabled.
hipDeviceAttributeAccessPolicyMaxWindowSize	Cuda only. The maximum size of the window policy in bytes.
hipDeviceAttributeAsyncEngineCount	Cuda only. Asynchronous engines number.
hipDeviceAttributeCanMapHostMemory	Whether host memory can be mapped into device address space.
hipDeviceAttributeCanUseHostPointerForRegisteredMem	Cuda only. Device can access host registered memory at the same virtual address as the CPU
hipDeviceAttributeClockRate	Peak clock frequency in kilohertz.
hipDeviceAttributeComputeMode	Compute mode that device is currently in.
hipDeviceAttributeComputePreemptionSupported	Cuda only. Device supports Compute Preemption.
hipDeviceAttributeConcurrentKernels	Device can possibly execute multiple kernels concurrently.
hipDeviceAttributeConcurrentManagedAccess	Device can coherently access managed memory concurrently with the CPU.
hipDeviceAttributeCooperativeLaunch	Support cooperative launch.
hipDeviceAttributeCooperativeMultiDeviceLaunch	Support cooperative launch on multiple devices.
hipDeviceAttributeDeviceOverlap	Cuda only. Device can concurrently copy memory and execute a kernel. Deprecated. Use instead asyncEngineCount.
hipDeviceAttributeDirectManagedMemAccessFromHost	Host can directly access managed memory on the device without migration
hipDeviceAttributeGlobalL1CacheSupported	Cuda only. Device supports caching globals in L1.
hipDeviceAttributeHostNativeAtomicSupported	Cuda only. Link between the device and the host supports native atomic operations.
hipDeviceAttributeIntegrated	Device is integrated GPU.
hipDeviceAttributeIsMultiGpuBoard	Multiple GPU devices.
hipDeviceAttributeKernelExecTimeout	Run time limit for kernels executed on the device.
hipDeviceAttributeL2CacheSize	Size of L2 cache in bytes. 0 if the device doesn't have L2 cache.
hipDeviceAttributeLocalL1CacheSupported	caching locals in L1 is supported
hipDeviceAttributeLuid	Cuda only. 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms.
hipDeviceAttributeLuidDeviceNodeMask	Cuda only. Luid device node mask. Undefined on TCC and non-Windows platforms.
hipDeviceAttributeComputeCapabilityMajor	Major compute capability version number.
hipDeviceAttributeManagedMemory	Device supports allocating managed memory on this system.
hipDeviceAttributeMaxBlocksPerMultiProcessor	Cuda only. Max block size per multiprocessor.
hipDeviceAttributeMaxBlockDimX	Max block size in width.
hipDeviceAttributeMaxBlockDimY	Max block size in height.
hipDeviceAttributeMaxBlockDimZ	Max block size in depth.
hipDeviceAttributeMaxGridDimX	Max grid size in width.
hipDeviceAttributeMaxGridDimY	Max grid size in height.
hipDeviceAttributeMaxGridDimZ	Max grid size in depth.
hipDeviceAttributeMaxSurface1D	Maximum size of 1D surface.
hipDeviceAttributeMaxSurface1DLayered	Cuda only. Maximum dimensions of 1D layered surface.
hipDeviceAttributeMaxSurface2D	Maximum dimension (width, height) of 2D surface.
hipDeviceAttributeMaxSurface2DLayered	Cuda only. Maximum dimensions of 2D layered surface.
hipDeviceAttributeMaxSurface3D	Maximum dimension (width, height, depth) of 3D surface.
hipDeviceAttributeMaxSurfaceCubemap	Cuda only. Maximum dimensions of Cubemap surface.
hipDeviceAttributeMaxSurfaceCubemapLayered	Cuda only. Maximum dimension of Cubemap layered surface.
hipDeviceAttributeMaxTexture1DWidth	Maximum size of 1D texture.
hipDeviceAttributeMaxTexture1DLayered	Cuda only. Maximum dimensions of 1D layered texture.
hipDeviceAttributeMaxTexture1DLinear	Maximum number of elements allocatable in a 1D linear texture. Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda.
hipDeviceAttributeMaxTexture1DMipmap	Cuda only. Maximum size of 1D mipmapped texture.
hipDeviceAttributeMaxTexture2DWidth	Maximum dimension width of 2D texture.
hipDeviceAttributeMaxTexture2DHeight	Maximum dimension hight of 2D texture.
hipDeviceAttributeMaxTexture2DGather	Cuda only. Maximum dimensions of 2D texture if gather operations performed.
hipDeviceAttributeMaxTexture2DLayered	Cuda only. Maximum dimensions of 2D layered texture.
hipDeviceAttributeMaxTexture2DLinear	Cuda only. Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.
hipDeviceAttributeMaxTexture2DMipmap	Cuda only. Maximum dimensions of 2D mipmapped texture.
hipDeviceAttributeMaxTexture3DWidth	Maximum dimension width of 3D texture.
hipDeviceAttributeMaxTexture3DHeight	Maximum dimension height of 3D texture.
hipDeviceAttributeMaxTexture3DDepth	Maximum dimension depth of 3D texture.
hipDeviceAttributeMaxTexture3DAlt	Cuda only. Maximum dimensions of alternate 3D texture.
hipDeviceAttributeMaxTextureCubemap	Cuda only. Maximum dimensions of Cubemap texture.
hipDeviceAttributeMaxTextureCubemapLayered	Cuda only. Maximum dimensions of Cubemap layered texture.
hipDeviceAttributeMaxThreadsDim	Maximum dimension of a block.
hipDeviceAttributeMaxThreadsPerBlock	Maximum number of threads per block.
hipDeviceAttributeMaxThreadsPerMultiProcessor	Maximum resident threads per multiprocessor.
hipDeviceAttributeMaxPitch	Maximum pitch in bytes allowed by memory copies.
hipDeviceAttributeMemoryBusWidth	Global memory bus width in bits.
hipDeviceAttributeMemoryClockRate	Peak memory clock frequency in kilohertz.
hipDeviceAttributeComputeCapabilityMinor	Minor compute capability version number.
hipDeviceAttributeMultiGpuBoardGroupID	Cuda only. Unique ID of device group on the same multi-GPU board.
hipDeviceAttributeMultiprocessorCount	Number of multiprocessors on the device.
hipDeviceAttributeName	Device name.
hipDeviceAttributePageableMemoryAccess	Device supports coherently accessing pageable memory without calling hipHostRegister on it
hipDeviceAttributePageableMemoryAccessUsesHostPageTables	Device accesses pageable memory via the host's page tables.
hipDeviceAttributePciBusId	PCI Bus ID.
hipDeviceAttributePciDeviceId	PCI Device ID.
hipDeviceAttributePciDomainID	PCI Domain ID.
hipDeviceAttributePersistingL2CacheMaxSize	Cuda11 only. Maximum l2 persisting lines capacity in bytes.
hipDeviceAttributeMaxRegistersPerBlock	32-bit registers available to a thread block. This number is shared by all thread blocks simultaneously resident on a multiprocessor.
hipDeviceAttributeMaxRegistersPerMultiprocessor	32-bit registers available per block.
hipDeviceAttributeReservedSharedMemPerBlock	Cuda11 only. Shared memory reserved by CUDA driver per block.
hipDeviceAttributeMaxSharedMemoryPerBlock	Maximum shared memory available per block in bytes.
hipDeviceAttributeSharedMemPerBlockOptin	Cuda only. Maximum shared memory per block usable by special opt in.
hipDeviceAttributeSharedMemPerMultiprocessor	Cuda only. Shared memory available per multiprocessor.
hipDeviceAttributeSingleToDoublePrecisionPerfRatio	Cuda only. Performance ratio of single precision to double precision.
hipDeviceAttributeStreamPrioritiesSupported	Cuda only. Whether to support stream priorities.
hipDeviceAttributeSurfaceAlignment	Cuda only. Alignment requirement for surfaces.
hipDeviceAttributeTccDriver	Cuda only. Whether device is a Tesla device using TCC driver.
hipDeviceAttributeTextureAlignment	Alignment requirement for textures.
hipDeviceAttributeTexturePitchAlignment	Pitch alignment requirement for 2D texture references bound to pitched memory;.
hipDeviceAttributeTotalConstantMemory	Constant memory size in bytes.
hipDeviceAttributeTotalGlobalMem	Global memory available on devicice.
hipDeviceAttributeUnifiedAddressing	Cuda only. An unified address space shared with the host.
hipDeviceAttributeUuid	Cuda only. Unique ID in 16 byte.
hipDeviceAttributeWarpSize	Warp size in threads.
hipDeviceAttributeMemoryPoolsSupported	Device supports HIP Stream Ordered Memory Allocator.
hipDeviceAttributeVirtualMemoryManagementSupported	Device supports HIP virtual memory management.
hipDeviceAttributeClockInstructionRate	Frequency in khz of the timer used by the device-side "clock*".
hipDeviceAttributeArch	Device architecture.
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor	Maximum Shared Memory PerMultiprocessor.
hipDeviceAttributeGcnArch	Device gcn architecture.
hipDeviceAttributeGcnArchName	Device gcnArch name in 256 bytes.
hipDeviceAttributeHdpMemFlushCntl	Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.
hipDeviceAttributeHdpRegFlushCntl	Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.
hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc	Supports cooperative launch on multiple devices with unmatched functions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim	Supports cooperative launch on multiple devices with unmatched grid dimensions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim	Supports cooperative launch on multiple devices with unmatched block dimensions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem	Supports cooperative launch on multiple devices with unmatched shared memories
hipDeviceAttributeIsLargeBar	Whether it is LargeBar.
hipDeviceAttributeAsicRevision	Revision of the GPU in this device.
hipDeviceAttributeCanUseStreamWaitValue	'1' if Device supports hipStreamWaitValue32() and hipStreamWaitValue64(), '0' otherwise.
hipDeviceAttributeImageSupport	'1' if Device supports image, '0' otherwise.
hipDeviceAttributePhysicalMultiProcessorCount	All available physical compute units for the device
hipDeviceAttributeFineGrainSupport	'1' if Device supports fine grain, '0' otherwise
hipDeviceAttributeWallClockRate	Constant frequency of wall clock in kilohertz.

enum hipFuncAttribute

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

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

enum hipGLDeviceList

Enumerator

hipGLDeviceListAll

All hip devices used by current OpenGL context.

hipGLDeviceListCurrentFrame

frame

Hip devices used by current OpenGL context in current

hipGLDeviceListNextFrame

frame.

Hip devices used by current OpenGL context in next

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

enum hipGraphExecUpdateResult

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.

enum hipGraphicsRegisterFlags

Enumerator
hipGraphicsRegisterFlagsReadOnly	HIP will not write to this registered resource.
hipGraphicsRegisterFlagsWriteDiscard	HIP will only write and will not read from this registered resource.
hipGraphicsRegisterFlagsSurfaceLoadStore	HIP will bind this resource to a surface.
hipGraphicsRegisterFlagsTextureGather	HIP will perform texture gather operations on this registered resource.

enum hipGraphInstantiateFlags

Enumerator
hipGraphInstantiateFlagAutoFreeOnLaunch	Automatically free memory allocated in a graph before relaunching.

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.

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

enum hipMemAccessFlags

Enumerator
hipMemAccessFlagsProtNone	Default, make the address range not accessible.
hipMemAccessFlagsProtRead	Set the address range read accessible.
hipMemAccessFlagsProtReadWrite	Set the address range read-write accessible.

enum hipMemAllocationGranularity_flags

Enumerator
hipMemAllocationGranularityMinimum	Minimum granularity.
hipMemAllocationGranularityRecommended	Recommended granularity for performance.

enum hipMemAllocationHandleType

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)

enum hipMemAllocationType

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

enum hipMemHandleType

Enumerator
hipMemHandleTypeGeneric	Generic handle type.

enum hipMemLocationType

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

enum hipMemOperationType

Enumerator
hipMemOperationTypeMap	Map operation.
hipMemOperationTypeUnmap	Unmap operation.

enum hipMemoryAdvise

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.

enum hipMemPoolAttr

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.

enum hipMemRangeAttribute

Enumerator
hipMemRangeAttributeReadMostly	Whether the range will mostly be read and only occassionally be written to
hipMemRangeAttributePreferredLocation	The preferred location of the range.
hipMemRangeAttributeAccessedBy	Memory range has hipMemAdviseSetAccessedBy set for the specified device
hipMemRangeAttributeLastPrefetchLocation	prefetched The last location to where the range was
hipMemRangeAttributeCoherencyMode	Returns coherency mode hipMemRangeCoherencyMode for the range

enum hipMemRangeCoherencyMode

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

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.

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

enum hipStreamUpdateCaptureDependenciesFlags

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

enum hipUserObjectFlags

Enumerator
hipUserObjectNoDestructorSync	Destructor execution is not synchronized.

enum hipUserObjectRetainFlags

Enumerator
hipGraphUserObjectMove	Add new reference or retain.

Classes

Macros

Typedefs

Enumerations

Detailed Description

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation