doxygen/html/hip__runtime__api_8h_source.html

/*

Copyright (c) 2015 - 2022 Advanced Micro Devices, Inc. All rights reserved.


Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:


The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.


THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

*/


#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H


#include <string.h>  // for getDeviceProp

#include <hip/hip_version.h>

#include <hip/hip_common.h>


enum {

    HIP_SUCCESS = 0,

    HIP_ERROR_INVALID_VALUE,

    HIP_ERROR_NOT_INITIALIZED,

    HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

};


typedef struct {

    // 32-bit Atomics

    unsigned hasGlobalInt32Atomics : 1;

    unsigned hasGlobalFloatAtomicExch : 1;

    unsigned hasSharedInt32Atomics : 1;

    unsigned hasSharedFloatAtomicExch : 1;

    unsigned hasFloatAtomicAdd : 1;


    // 64-bit Atomics

    unsigned hasGlobalInt64Atomics : 1;

    unsigned hasSharedInt64Atomics : 1;


    // Doubles

    unsigned hasDoubles : 1;


    // Warp cross-lane operations

    unsigned hasWarpVote : 1;

    unsigned hasWarpBallot : 1;

    unsigned hasWarpShuffle : 1;

    unsigned hasFunnelShift : 1;


    // Sync

    unsigned hasThreadFenceSystem : 1;

    unsigned hasSyncThreadsExt : 1;


    // Misc

    unsigned hasSurfaceFuncs : 1;

    unsigned has3dGrid : 1;

    unsigned hasDynamicParallelism : 1;

} hipDeviceArch_t;

typedef struct  {…};


typedef struct hipUUID_t {

    char bytes[16];

} hipUUID;

typedef struct hipUUID_t {…};


//---

// Common headers for both NVCC and HCC paths:


typedef struct hipDeviceProp_t {

    char name[256];

    size_t totalGlobalMem;

    size_t sharedMemPerBlock;

    int regsPerBlock;

    int warpSize;

    int maxThreadsPerBlock;

    int maxThreadsDim[3];

    int maxGridSize[3];

    int clockRate;

    int memoryClockRate;

    int memoryBusWidth;

    size_t totalConstMem;

    int major;

    int minor;

    int multiProcessorCount;

    int l2CacheSize;

    int maxThreadsPerMultiProcessor;

    int computeMode;

    int clockInstructionRate;

    hipDeviceArch_t arch;

    int concurrentKernels;

    int pciDomainID;

    int pciBusID;

    int pciDeviceID;

    size_t maxSharedMemoryPerMultiProcessor;

    int isMultiGpuBoard;

    int canMapHostMemory;

    int gcnArch;

    char gcnArchName[256];

    int integrated;

    int cooperativeLaunch;

    int cooperativeMultiDeviceLaunch;

    int maxTexture1DLinear;

    int maxTexture1D;

    int maxTexture2D[2];

    int maxTexture3D[3];

    unsigned int* hdpMemFlushCntl;

    unsigned int* hdpRegFlushCntl;

    size_t memPitch;

    size_t textureAlignment;

    size_t texturePitchAlignment;

    int kernelExecTimeoutEnabled;

    int ECCEnabled;

    int tccDriver;

    int cooperativeMultiDeviceUnmatchedFunc;

    int cooperativeMultiDeviceUnmatchedGridDim;

    int cooperativeMultiDeviceUnmatchedBlockDim;

    int cooperativeMultiDeviceUnmatchedSharedMem;

    int isLargeBar;

    int asicRevision;

    int managedMemory;

    int directManagedMemAccessFromHost;

    int concurrentManagedAccess;

    int pageableMemoryAccess;

    int pageableMemoryAccessUsesHostPageTables;

} hipDeviceProp_t;

typedef struct hipDeviceProp_t {…};


typedef enum hipMemoryType {

    hipMemoryTypeHost,

    hipMemoryTypeDevice,

    hipMemoryTypeArray,

    hipMemoryTypeUnified,

    hipMemoryTypeManaged

} hipMemoryType;

typedef enum hipMemoryType {…};


typedef struct hipPointerAttribute_t {

    enum hipMemoryType memoryType;

    int device;

    void* devicePointer;

    void* hostPointer;

    int isManaged;

    unsigned allocationFlags; /* flags specified when memory was allocated*/

    /* peers? */

} hipPointerAttribute_t;

typedef struct hipPointerAttribute_t {…};


// hack to get these to show up in Doxygen:

// Ignoring error-code return values from hip APIs is discouraged. On C++17,

// we can make that yield a warning

#if __cplusplus >= 201703L

#define __HIP_NODISCARD [[nodiscard]]

#else

#define __HIP_NODISCARD

#endif


/*

 * @brief hipError_t

 * @enum

 * @ingroup Enumerations

 */

// Developer note - when updating these, update the hipErrorName and hipErrorString functions in

// NVCC and HCC paths Also update the hipCUDAErrorTohipError function in NVCC path.


typedef enum __HIP_NODISCARD hipError_t {

    hipSuccess = 0,

    hipErrorInvalidValue = 1,

    hipErrorOutOfMemory = 2,

    // Deprecated

    hipErrorMemoryAllocation = 2,

    hipErrorNotInitialized = 3,

    // Deprecated

    hipErrorInitializationError = 3,

    hipErrorDeinitialized = 4,

    hipErrorProfilerDisabled = 5,

    hipErrorProfilerNotInitialized = 6,

    hipErrorProfilerAlreadyStarted = 7,

    hipErrorProfilerAlreadyStopped = 8,

    hipErrorInvalidConfiguration = 9,

    hipErrorInvalidPitchValue = 12,

    hipErrorInvalidSymbol = 13,

    hipErrorInvalidDevicePointer = 17,

    hipErrorInvalidMemcpyDirection = 21,

    hipErrorInsufficientDriver = 35,

    hipErrorMissingConfiguration = 52,

    hipErrorPriorLaunchFailure = 53,

    hipErrorInvalidDeviceFunction = 98,

    hipErrorNoDevice = 100,

    hipErrorInvalidDevice = 101,

    hipErrorInvalidImage = 200,

    hipErrorInvalidContext = 201,

    hipErrorContextAlreadyCurrent = 202,

    hipErrorMapFailed = 205,

    // Deprecated

    hipErrorMapBufferObjectFailed = 205,

    hipErrorUnmapFailed = 206,

    hipErrorArrayIsMapped = 207,

    hipErrorAlreadyMapped = 208,

    hipErrorNoBinaryForGpu = 209,

    hipErrorAlreadyAcquired = 210,

    hipErrorNotMapped = 211,

    hipErrorNotMappedAsArray = 212,

    hipErrorNotMappedAsPointer = 213,

    hipErrorECCNotCorrectable = 214,

    hipErrorUnsupportedLimit = 215,

    hipErrorContextAlreadyInUse = 216,

    hipErrorPeerAccessUnsupported = 217,

    hipErrorInvalidKernelFile = 218,

    hipErrorInvalidGraphicsContext = 219,

    hipErrorInvalidSource = 300,

    hipErrorFileNotFound = 301,

    hipErrorSharedObjectSymbolNotFound = 302,

    hipErrorSharedObjectInitFailed = 303,

    hipErrorOperatingSystem = 304,

    hipErrorInvalidHandle = 400,

    // Deprecated

    hipErrorInvalidResourceHandle = 400,

    hipErrorIllegalState = 401,

    hipErrorNotFound = 500,

    hipErrorNotReady = 600,

    hipErrorIllegalAddress = 700,

    hipErrorLaunchOutOfResources = 701,

    hipErrorLaunchTimeOut = 702,

    hipErrorPeerAccessAlreadyEnabled =

        704,

    hipErrorPeerAccessNotEnabled =

        705,

    hipErrorSetOnActiveProcess = 708,

    hipErrorContextIsDestroyed = 709,

    hipErrorAssert = 710,

    hipErrorHostMemoryAlreadyRegistered =

        712,

    hipErrorHostMemoryNotRegistered =

        713,

    hipErrorLaunchFailure =

        719,

    hipErrorCooperativeLaunchTooLarge =

        720,

    hipErrorNotSupported = 801,

    hipErrorStreamCaptureUnsupported = 900,

    hipErrorStreamCaptureInvalidated = 901,

    hipErrorStreamCaptureMerge = 902,

    hipErrorStreamCaptureUnmatched = 903,

    hipErrorStreamCaptureUnjoined = 904,

    hipErrorStreamCaptureIsolation = 905,

    hipErrorStreamCaptureImplicit = 906,

    hipErrorCapturedEvent = 907,

    hipErrorStreamCaptureWrongThread = 908,

    hipErrorGraphExecUpdateFailure = 910,

    hipErrorUnknown = 999,  //< Unknown error.

    // HSA Runtime Error Codes start here.

    hipErrorRuntimeMemory = 1052,

    hipErrorRuntimeOther = 1053,

    hipErrorTbd

} hipError_t;

typedef enum __HIP_NODISCARD hipError_t {…};


#undef __HIP_NODISCARD


/*

 * @brief hipDeviceAttribute_t

 * @enum

 * @ingroup Enumerations

 */


typedef 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,

    // Extended attributes for vendors

} hipDeviceAttribute_t;

typedef enum hipDeviceAttribute_t {…};


enum hipComputeMode {

    hipComputeModeDefault = 0,

    hipComputeModeExclusive = 1,

    hipComputeModeProhibited = 2,

    hipComputeModeExclusiveProcess = 3

};

enum hipComputeMode {…};


#if (defined(__HIP_PLATFORM_HCC__) || defined(__HIP_PLATFORM_AMD__)) && !(defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_PLATFORM_NVIDIA__))


#include <stdint.h>

#include <stddef.h>

#ifndef GENERIC_GRID_LAUNCH

#define GENERIC_GRID_LAUNCH 1

#endif

#include <hip/amd_detail/host_defines.h>

#include <hip/driver_types.h>

#include <hip/texture_types.h>

#include <hip/surface_types.h>

#if defined(_MSC_VER)

#define DEPRECATED(msg) __declspec(deprecated(msg))

#else // !defined(_MSC_VER)

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

#endif // !defined(_MSC_VER)

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

#define HIP_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)

#define HIP_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)

#define HIP_LAUNCH_PARAM_END ((void*)0x03)

#ifdef __cplusplus

  #define __dparm(x) \

          = x

#else

  #define __dparm(x)

#endif

#ifdef __GNUC__

#pragma GCC visibility push (default)

#endif

#ifdef __cplusplus

namespace hip_impl {

hipError_t hip_init();

}  // namespace hip_impl

#endif

// Structure definitions:

#ifdef __cplusplus

extern "C" {

#endif

//---

// API-visible structures

typedef struct ihipCtx_t* hipCtx_t;

// Note many APIs also use integer deviceIds as an alternative to the device pointer:

typedef int hipDevice_t;


typedef enum hipDeviceP2PAttr {

  hipDevP2PAttrPerformanceRank = 0,

  hipDevP2PAttrAccessSupported,

  hipDevP2PAttrNativeAtomicSupported,

  hipDevP2PAttrHipArrayAccessSupported

} hipDeviceP2PAttr;

typedef enum hipDeviceP2PAttr {…};

typedef struct ihipStream_t* hipStream_t;

#define hipIpcMemLazyEnablePeerAccess 0

#define HIP_IPC_HANDLE_SIZE 64


typedef struct hipIpcMemHandle_st {

    char reserved[HIP_IPC_HANDLE_SIZE];

} hipIpcMemHandle_t;

typedef struct hipIpcMemHandle_st {…};


typedef struct hipIpcEventHandle_st {

    char reserved[HIP_IPC_HANDLE_SIZE];

} hipIpcEventHandle_t;

typedef struct hipIpcEventHandle_st {…};

typedef struct ihipModule_t* hipModule_t;

typedef struct ihipModuleSymbol_t* hipFunction_t;

typedef struct ihipMemPoolHandle_t* hipMemPool_t;


typedef struct hipFuncAttributes {

    int binaryVersion;

    int cacheModeCA;

    size_t constSizeBytes;

    size_t localSizeBytes;

    int maxDynamicSharedSizeBytes;

    int maxThreadsPerBlock;

    int numRegs;

    int preferredShmemCarveout;

    int ptxVersion;

    size_t sharedSizeBytes;

} hipFuncAttributes;

typedef struct hipFuncAttributes {…};

typedef struct ihipEvent_t* hipEvent_t;


enum hipLimit_t {

    hipLimitStackSize = 0x0,        // limit device stack size

    hipLimitPrintfFifoSize = 0x01,  // limit printf fifo size

    hipLimitMallocHeapSize = 0x02,  // limit heap size

    hipLimitRange                   // supported limit range

};

enum hipLimit_t {…};

//Flags that can be used with hipStreamCreateWithFlags.

#define hipStreamDefault  0x00


#define hipStreamNonBlocking 0x01


//Flags that can be used with hipEventCreateWithFlags.

#define hipEventDefault 0x0


#define hipEventBlockingSync 0x1


#define hipEventDisableTiming  0x2


#define hipEventInterprocess 0x4


#define hipEventReleaseToDevice  0x40000000


#define hipEventReleaseToSystem  0x80000000


//Flags that can be used with hipHostMalloc.

#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


//Flags that can be used with hipHostRegister.

#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 hipCooperativeLaunchMultiDeviceNoPreSync 0x01

#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

#define hipCpuDeviceId ((int)-1)

#define hipInvalidDeviceId ((int)-2)

//Flags that can be used with hipExtLaunch Set of APIs.

#define hipExtAnyOrderLaunch 0x01

// Flags to be used with hipStreamWaitValue32 and hipStreamWaitValue64.

#define hipStreamWaitValueGte 0x0

#define hipStreamWaitValueEq 0x1

#define hipStreamWaitValueAnd 0x2

#define hipStreamWaitValueNor 0x3

// Stream per thread

#define hipStreamPerThread ((hipStream_t)2)

/*

 * @brief HIP Memory Advise values

 * @enum

 * @ingroup Enumerations

 */


typedef enum hipMemoryAdvise {

    hipMemAdviseSetReadMostly = 1,

    hipMemAdviseUnsetReadMostly = 2,

    hipMemAdviseSetPreferredLocation = 3,

    hipMemAdviseUnsetPreferredLocation = 4,

    hipMemAdviseSetAccessedBy = 5,

    hipMemAdviseUnsetAccessedBy = 6,

    hipMemAdviseSetCoarseGrain = 100,

    hipMemAdviseUnsetCoarseGrain = 101

} hipMemoryAdvise;

typedef enum hipMemoryAdvise {…};

/*

 * @brief HIP Coherency Mode

 * @enum

 * @ingroup Enumerations

 */


typedef enum hipMemRangeCoherencyMode {

    hipMemRangeCoherencyModeFineGrain = 0,

    hipMemRangeCoherencyModeCoarseGrain = 1,

    hipMemRangeCoherencyModeIndeterminate = 2

} hipMemRangeCoherencyMode;

typedef enum hipMemRangeCoherencyMode {…};

/*

 * @brief HIP range attributes

 * @enum

 * @ingroup Enumerations

 */


typedef enum hipMemRangeAttribute {

    hipMemRangeAttributeReadMostly = 1,

    hipMemRangeAttributePreferredLocation = 2,

    hipMemRangeAttributeAccessedBy = 3,

    hipMemRangeAttributeLastPrefetchLocation = 4,

    hipMemRangeAttributeCoherencyMode = 100,

} hipMemRangeAttribute;

typedef enum hipMemRangeAttribute {…};


typedef enum hipMemPoolAttr

{

    hipMemPoolReuseFollowEventDependencies   = 0x1,

    hipMemPoolReuseAllowOpportunistic        = 0x2,

    hipMemPoolReuseAllowInternalDependencies = 0x3,

    hipMemPoolAttrReleaseThreshold           = 0x4,

    hipMemPoolAttrReservedMemCurrent         = 0x5,

    hipMemPoolAttrReservedMemHigh            = 0x6,

    hipMemPoolAttrUsedMemCurrent             = 0x7,

    hipMemPoolAttrUsedMemHigh                = 0x8

} hipMemPoolAttr;

typedef enum hipMemPoolAttr {…};


 typedef enum hipMemLocationType {

    hipMemLocationTypeInvalid = 0,

    hipMemLocationTypeDevice = 1

} hipMemLocationType;

 typedef enum hipMemLocationType {…};


typedef struct hipMemLocation {

    hipMemLocationType type;

    int id;

} hipMemLocation;

typedef struct hipMemLocation {…};


typedef enum hipMemAccessFlags {

    hipMemAccessFlagsProtNone      = 0,

    hipMemAccessFlagsProtRead      = 1,

    hipMemAccessFlagsProtReadWrite = 3

} hipMemAccessFlags;

typedef enum hipMemAccessFlags {…};


typedef struct hipMemAccessDesc {

    hipMemLocation      location;

    hipMemAccessFlags   flags;

} hipMemAccessDesc;

typedef struct hipMemAccessDesc {…};


typedef enum hipMemAllocationType {

    hipMemAllocationTypeInvalid = 0x0,

    hipMemAllocationTypePinned  = 0x1,

    hipMemAllocationTypeMax     = 0x7FFFFFFF

} hipMemAllocationType;

typedef enum hipMemAllocationType {…};


typedef enum hipMemAllocationHandleType {

    hipMemHandleTypeNone                    = 0x0,

    hipMemHandleTypePosixFileDescriptor     = 0x1,

    hipMemHandleTypeWin32                   = 0x2,

    hipMemHandleTypeWin32Kmt                = 0x4

} hipMemAllocationHandleType;

typedef enum hipMemAllocationHandleType {…};


typedef struct hipMemPoolProps {

    hipMemAllocationType       allocType;

    hipMemAllocationHandleType handleTypes;

    hipMemLocation             location;

    void*                       win32SecurityAttributes;

    unsigned char               reserved[64];

} hipMemPoolProps;

typedef struct hipMemPoolProps {…};


typedef struct hipMemPoolPtrExportData {

    unsigned char reserved[64];

} hipMemPoolPtrExportData;

typedef struct hipMemPoolPtrExportData {…};


/*

 * @brief hipJitOption

 * @enum

 * @ingroup Enumerations

 */


typedef enum hipJitOption {

    hipJitOptionMaxRegisters = 0,

    hipJitOptionThreadsPerBlock,

    hipJitOptionWallTime,

    hipJitOptionInfoLogBuffer,

    hipJitOptionInfoLogBufferSizeBytes,

    hipJitOptionErrorLogBuffer,

    hipJitOptionErrorLogBufferSizeBytes,

    hipJitOptionOptimizationLevel,

    hipJitOptionTargetFromContext,

    hipJitOptionTarget,

    hipJitOptionFallbackStrategy,

    hipJitOptionGenerateDebugInfo,

    hipJitOptionLogVerbose,

    hipJitOptionGenerateLineInfo,

    hipJitOptionCacheMode,

    hipJitOptionSm3xOpt,

    hipJitOptionFastCompile,

    hipJitOptionNumOptions

} hipJitOption;

typedef enum hipJitOption {…};


typedef enum hipFuncAttribute {

    hipFuncAttributeMaxDynamicSharedMemorySize = 8,

    hipFuncAttributePreferredSharedMemoryCarveout = 9,

    hipFuncAttributeMax

} hipFuncAttribute;

typedef enum hipFuncAttribute {…};


typedef enum hipFuncCache_t {

    hipFuncCachePreferNone,

    hipFuncCachePreferShared,

    hipFuncCachePreferL1,

    hipFuncCachePreferEqual,

} hipFuncCache_t;

typedef enum hipFuncCache_t {…};


typedef enum hipSharedMemConfig {

    hipSharedMemBankSizeDefault,

    hipSharedMemBankSizeFourByte,

    hipSharedMemBankSizeEightByte

} hipSharedMemConfig;

typedef enum hipSharedMemConfig {…};


typedef struct dim3 {

    uint32_t x;

    uint32_t y;

    uint32_t z;

#ifdef __cplusplus

    constexpr __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1) : x(_x), y(_y), z(_z){};

#endif

} dim3;

typedef struct dim3 {…};


typedef struct hipLaunchParams_t {

    void* func;

    dim3 gridDim;

    dim3 blockDim;

    void **args;

    size_t sharedMem;

    hipStream_t stream;

} hipLaunchParams;

typedef struct hipLaunchParams_t {…};


typedef enum hipExternalMemoryHandleType_enum {

  hipExternalMemoryHandleTypeOpaqueFd = 1,

  hipExternalMemoryHandleTypeOpaqueWin32 = 2,

  hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

  hipExternalMemoryHandleTypeD3D12Heap = 4,

  hipExternalMemoryHandleTypeD3D12Resource = 5,

  hipExternalMemoryHandleTypeD3D11Resource = 6,

  hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

} hipExternalMemoryHandleType;

typedef enum hipExternalMemoryHandleType_enum {…};


typedef struct hipExternalMemoryHandleDesc_st {

  hipExternalMemoryHandleType type;

  union {

    int fd;

    struct {

      void *handle;

      const void *name;

    } win32;

  } handle;

  unsigned long long size;

  unsigned int flags;

} hipExternalMemoryHandleDesc;

typedef struct hipExternalMemoryHandleDesc_st {…};


typedef struct hipExternalMemoryBufferDesc_st {

  unsigned long long offset;

  unsigned long long size;

  unsigned int flags;

} hipExternalMemoryBufferDesc;

typedef struct hipExternalMemoryBufferDesc_st {…};

typedef void* hipExternalMemory_t;


typedef enum hipExternalSemaphoreHandleType_enum {

  hipExternalSemaphoreHandleTypeOpaqueFd = 1,

  hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

  hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

  hipExternalSemaphoreHandleTypeD3D12Fence = 4

} hipExternalSemaphoreHandleType;

typedef enum hipExternalSemaphoreHandleType_enum {…};


typedef struct hipExternalSemaphoreHandleDesc_st {

  hipExternalSemaphoreHandleType type;

  union {

    int fd;

    struct {

      void* handle;

      const void* name;

    } win32;

  } handle;

  unsigned int flags;

} hipExternalSemaphoreHandleDesc;

typedef struct hipExternalSemaphoreHandleDesc_st {…};

typedef void* hipExternalSemaphore_t;


typedef struct hipExternalSemaphoreSignalParams_st {

  struct {

    struct {

      unsigned long long value;

    } fence;

    struct {

      unsigned long long key;

    } keyedMutex;

    unsigned int reserved[12];

  } params;

  unsigned int flags;

  unsigned int reserved[16];

} hipExternalSemaphoreSignalParams;

typedef struct hipExternalSemaphoreSignalParams_st {…};


typedef struct hipExternalSemaphoreWaitParams_st {

  struct {

    struct {

      unsigned long long value;

    } fence;

    struct {

      unsigned long long key;

      unsigned int timeoutMs;

    } keyedMutex;

    unsigned int reserved[10];

  } params;

  unsigned int flags;

  unsigned int reserved[16];

} hipExternalSemaphoreWaitParams;

typedef struct hipExternalSemaphoreWaitParams_st {…};


#if __HIP_HAS_GET_PCH

    void __hipGetPCH(const char** pch, unsigned int*size);

#endif


/*

    * @brief HIP Devices used by current OpenGL Context.

    * @enum

    * @ingroup Enumerations

    */


typedef enum hipGLDeviceList {

    hipGLDeviceListAll = 1,

    hipGLDeviceListCurrentFrame = 2,

    hipGLDeviceListNextFrame = 3

} hipGLDeviceList;

typedef enum hipGLDeviceList {…};


/*

    * @brief HIP Access falgs for Interop resources.

    * @enum

    * @ingroup Enumerations

    */


typedef enum hipGraphicsRegisterFlags {

    hipGraphicsRegisterFlagsNone = 0,

    hipGraphicsRegisterFlagsReadOnly = 1,

    hipGraphicsRegisterFlagsWriteDiscard =

        2,

    hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

    hipGraphicsRegisterFlagsTextureGather =

        8

} hipGraphicsRegisterFlags;

typedef enum 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 {

  hipGraphNodeTypeKernel = 0,

  hipGraphNodeTypeMemcpy = 1,

  hipGraphNodeTypeMemset = 2,

  hipGraphNodeTypeHost = 3,

  hipGraphNodeTypeGraph = 4,

  hipGraphNodeTypeEmpty = 5,

  hipGraphNodeTypeWaitEvent = 6,

  hipGraphNodeTypeEventRecord = 7,

  hipGraphNodeTypeExtSemaphoreSignal = 8,

  hipGraphNodeTypeExtSemaphoreWait = 9,

  hipGraphNodeTypeMemcpyFromSymbol = 10,

  hipGraphNodeTypeMemcpyToSymbol = 11,

  hipGraphNodeTypeCount

} hipGraphNodeType;

typedef enum hipGraphNodeType {…};


typedef void (*hipHostFn_t)(void* userData);


typedef struct hipHostNodeParams {

  hipHostFn_t fn;

  void* userData;

} hipHostNodeParams;

typedef struct hipHostNodeParams {…};


typedef struct hipKernelNodeParams {

  dim3 blockDim;

  void** extra;

  void* func;

  dim3 gridDim;

  void** kernelParams;

  unsigned int sharedMemBytes;

} hipKernelNodeParams;

typedef struct hipKernelNodeParams {…};


typedef struct hipMemsetParams {

  void* dst;

  unsigned int elementSize;

  size_t height;

  size_t pitch;

  unsigned int value;

  size_t width;

} hipMemsetParams;

typedef struct hipMemsetParams {…};


typedef enum hipKernelNodeAttrID {

    hipKernelNodeAttributeAccessPolicyWindow = 1,

    hipKernelNodeAttributeCooperative = 2,

} hipKernelNodeAttrID;

typedef enum hipKernelNodeAttrID {…};


typedef enum hipAccessProperty {

    hipAccessPropertyNormal = 0,

    hipAccessPropertyStreaming  = 1,

    hipAccessPropertyPersisting = 2,

} hipAccessProperty;

typedef enum hipAccessProperty {…};


typedef struct hipAccessPolicyWindow {

    void* base_ptr;

    hipAccessProperty hitProp;

    float hitRatio;

    hipAccessProperty missProp;

    size_t num_bytes;

} hipAccessPolicyWindow;

typedef struct hipAccessPolicyWindow {…};


typedef union hipKernelNodeAttrValue {

    hipAccessPolicyWindow accessPolicyWindow;

    int cooperative;

} hipKernelNodeAttrValue;

typedef union hipKernelNodeAttrValue {…};


typedef enum hipGraphExecUpdateResult {

  hipGraphExecUpdateSuccess = 0x0,

  hipGraphExecUpdateError = 0x1,

  hipGraphExecUpdateErrorTopologyChanged = 0x2,

  hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

  hipGraphExecUpdateErrorFunctionChanged =

      0x4,

  hipGraphExecUpdateErrorParametersChanged =

      0x5,

  hipGraphExecUpdateErrorNotSupported =

      0x6,

  hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

} hipGraphExecUpdateResult;

typedef enum hipGraphExecUpdateResult {…};


typedef enum hipStreamCaptureMode {

  hipStreamCaptureModeGlobal = 0,

  hipStreamCaptureModeThreadLocal,

  hipStreamCaptureModeRelaxed

} hipStreamCaptureMode;

typedef enum hipStreamCaptureMode {…};


typedef enum hipStreamCaptureStatus {

  hipStreamCaptureStatusNone = 0,

  hipStreamCaptureStatusActive,

  hipStreamCaptureStatusInvalidated

} hipStreamCaptureStatus;

typedef enum hipStreamCaptureStatus {…};


typedef enum hipStreamUpdateCaptureDependenciesFlags {

  hipStreamAddCaptureDependencies = 0,

  hipStreamSetCaptureDependencies,

} hipStreamUpdateCaptureDependenciesFlags;

typedef enum hipStreamUpdateCaptureDependenciesFlags {…};


typedef enum hipGraphMemAttributeType {

  hipGraphMemAttrUsedMemCurrent = 0,

  hipGraphMemAttrUsedMemHigh,

  hipGraphMemAttrReservedMemCurrent,

  hipGraphMemAttrReservedMemHigh,

}hipGraphMemAttributeType;

typedef enum hipGraphMemAttributeType {…};


typedef enum hipUserObjectFlags {

  hipUserObjectNoDestructorSync = 0x1,

} hipUserObjectFlags;

typedef enum hipUserObjectFlags {…};


typedef enum hipUserObjectRetainFlags {

  hipGraphUserObjectMove = 0x1,

} hipUserObjectRetainFlags;

typedef enum hipUserObjectRetainFlags {…};


typedef enum hipGraphInstantiateFlags {

  hipGraphInstantiateFlagAutoFreeOnLaunch =

      1,

} hipGraphInstantiateFlags;

typedef enum hipGraphInstantiateFlags {…};


typedef struct hipMemAllocationProp {

    hipMemAllocationType type;

    hipMemAllocationHandleType requestedHandleType;

    hipMemLocation location;

    void* win32HandleMetaData;

    struct {

        unsigned char compressionType;

        unsigned char gpuDirectRDMACapable;

        unsigned short usage;

    } allocFlags;

} hipMemAllocationProp;

typedef struct hipMemAllocationProp {…};


typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;


typedef enum hipMemAllocationGranularity_flags {

    hipMemAllocationGranularityMinimum     = 0x0,

    hipMemAllocationGranularityRecommended = 0x1

} hipMemAllocationGranularity_flags;

typedef enum hipMemAllocationGranularity_flags {…};


typedef enum hipMemHandleType {

    hipMemHandleTypeGeneric = 0x0

} hipMemHandleType;

typedef enum hipMemHandleType {…};


typedef enum hipMemOperationType {

    hipMemOperationTypeMap   = 0x1,

    hipMemOperationTypeUnmap = 0x2

} hipMemOperationType;

typedef enum hipMemOperationType {…};


typedef enum hipArraySparseSubresourceType {

    hipArraySparseSubresourceTypeSparseLevel = 0x0,

    hipArraySparseSubresourceTypeMiptail     = 0x1

} hipArraySparseSubresourceType;

typedef enum hipArraySparseSubresourceType {…};


typedef struct hipArrayMapInfo {

     hipResourceType resourceType;

     union {

         hipMipmappedArray mipmap;

         hipArray_t array;

     } resource;

     hipArraySparseSubresourceType subresourceType;

     union {

         struct {

             unsigned int level;

             unsigned int layer;

             unsigned int offsetX;

             unsigned int offsetY;

             unsigned int offsetZ;

             unsigned int extentWidth;

             unsigned int extentHeight;

             unsigned int extentDepth;

         } sparseLevel;

         struct {

             unsigned int layer;

             unsigned long long offset;

             unsigned long long size;

         } miptail;

     } subresource;

     hipMemOperationType memOperationType;

     hipMemHandleType memHandleType;

     union {

         hipMemGenericAllocationHandle_t memHandle;

     } memHandle;

     unsigned long long offset;

     unsigned int deviceBitMask;

     unsigned int flags;

     unsigned int reserved[2];

} hipArrayMapInfo;

typedef struct hipArrayMapInfo {…};

// Doxygen end group GlobalDefs

//-------------------------------------------------------------------------------------------------

// The handle allows the async commands to use the stream even if the parent hipStream_t goes

// out-of-scope.

// typedef class ihipStream_t * hipStream_t;

/*

 * Opaque structure allows the true event (pointed at by the handle) to remain "live" even if the

 * surrounding hipEvent_t goes out-of-scope. This is handy for cases where the hipEvent_t goes

 * out-of-scope but the true event is being written by some async queue or device */

// typedef struct hipEvent_t {

//    struct ihipEvent_t *_handle;

//} hipEvent_t;

// TODO-ctx - more description on error codes.

hipError_t hipInit(unsigned int flags);

hipError_t hipDriverGetVersion(int* driverVersion);

hipError_t hipRuntimeGetVersion(int* runtimeVersion);

hipError_t hipDeviceGet(hipDevice_t* device, int ordinal);


hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device);

hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device);

hipError_t hipDeviceGetUuid(hipUUID* uuid, hipDevice_t device);

hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

                                    int srcDevice, int dstDevice);

hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device);

hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId);

hipError_t hipDeviceTotalMem(size_t* bytes, hipDevice_t device);

// doxygen end initialization

hipError_t hipDeviceSynchronize(void);

hipError_t hipDeviceReset(void);

hipError_t hipSetDevice(int deviceId);

hipError_t hipGetDevice(int* deviceId);

hipError_t hipGetDeviceCount(int* count);

hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int deviceId);

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t* mem_pool, int device);

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

hipError_t hipDeviceGetMemPool(hipMemPool_t* mem_pool, int device);

hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId);

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit);

hipError_t hipDeviceSetLimit ( enum hipLimit_t limit, size_t value );

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

hipError_t hipGetDeviceFlags(unsigned int* flags);

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

hipError_t hipSetDeviceFlags(unsigned flags);

hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop);

hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype, uint32_t* hopcount);

// TODO: implement IPC apis

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr);

hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);

hipError_t hipIpcCloseMemHandle(void* devPtr);


hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t* handle, hipEvent_t event);


hipError_t hipIpcOpenEventHandle(hipEvent_t* event, hipIpcEventHandle_t handle);


// end doxygen Device

hipError_t hipFuncSetAttribute(const void* func, hipFuncAttribute attr, int value);

hipError_t hipFuncSetCacheConfig(const void* func, hipFuncCache_t config);

hipError_t hipFuncSetSharedMemConfig(const void* func, hipSharedMemConfig config);

//doxygen end execution

hipError_t hipGetLastError(void);

hipError_t hipPeekAtLastError(void);

const char* hipGetErrorName(hipError_t hip_error);

const char* hipGetErrorString(hipError_t hipError);

hipError_t hipDrvGetErrorName(hipError_t hipError, const char** errorString);

hipError_t hipDrvGetErrorString(hipError_t hipError, const char** errorString);

// end doxygen Error

hipError_t hipStreamCreate(hipStream_t* stream);

hipError_t hipStreamCreateWithFlags(hipStream_t* stream, unsigned int flags);

hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority);

hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority);

hipError_t hipStreamDestroy(hipStream_t stream);

hipError_t hipStreamQuery(hipStream_t stream);

hipError_t hipStreamSynchronize(hipStream_t stream);

hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags);

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags);

hipError_t hipStreamGetPriority(hipStream_t stream, int* priority);

hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize, const uint32_t* cuMask);

hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t* cuMask);

typedef void (*hipStreamCallback_t)(hipStream_t stream, hipError_t status, void* userData);

hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void* userData,

                                unsigned int flags);

// end doxygen Stream

hipError_t hipStreamWaitValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags,

                                uint32_t mask __dparm(0xFFFFFFFF));

hipError_t hipStreamWaitValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags,

                                uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

hipError_t hipStreamWriteValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags);

hipError_t hipStreamWriteValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags);

// end doxygen Stream Memory Operations

hipError_t hipEventCreateWithFlags(hipEvent_t* event, unsigned flags);

hipError_t hipEventCreate(hipEvent_t* event);

#ifdef __cplusplus

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream = NULL);

#else

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

#endif

hipError_t hipEventDestroy(hipEvent_t event);

hipError_t hipEventSynchronize(hipEvent_t event);

hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop);

hipError_t hipEventQuery(hipEvent_t event);

// end doxygen Events

hipError_t hipPointerGetAttributes(hipPointerAttribute_t* attributes, const void* ptr);

hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

                                  hipDeviceptr_t ptr);

hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute* attributes,

                                      void** data, hipDeviceptr_t ptr);

hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

                                      const hipExternalSemaphoreHandleDesc* semHandleDesc);

hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

                                            const hipExternalSemaphoreSignalParams* paramsArray,

                                            unsigned int numExtSems, hipStream_t stream);

hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

                                              const hipExternalSemaphoreWaitParams* paramsArray,

                                              unsigned int numExtSems, hipStream_t stream);

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);


hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out, const hipExternalMemoryHandleDesc* memHandleDesc);

hipError_t hipExternalMemoryGetMappedBuffer(void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc);

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

hipError_t hipMalloc(void** ptr, size_t size);

hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags);

DEPRECATED("use hipHostMalloc instead")

hipError_t hipMallocHost(void** ptr, size_t size);

DEPRECATED("use hipHostMalloc instead")

hipError_t hipMemAllocHost(void** ptr, size_t size);

hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags);

hipError_t hipMallocManaged(void** dev_ptr,

                            size_t size,

                            unsigned int flags __dparm(hipMemAttachGlobal));

hipError_t hipMemPrefetchAsync(const void* dev_ptr,

                               size_t count,

                               int device,

                               hipStream_t stream __dparm(0));

hipError_t hipMemAdvise(const void* dev_ptr,

                        size_t count,

                        hipMemoryAdvise advice,

                        int device);

hipError_t hipMemRangeGetAttribute(void* data,

                                   size_t data_size,

                                   hipMemRangeAttribute attribute,

                                   const void* dev_ptr,

                                   size_t count);

hipError_t hipMemRangeGetAttributes(void** data,

                                    size_t* data_sizes,

                                    hipMemRangeAttribute* attributes,

                                    size_t num_attributes,

                                    const void* dev_ptr,

                                    size_t count);

hipError_t hipStreamAttachMemAsync(hipStream_t stream,

                                   void* dev_ptr,

                                   size_t length __dparm(0),

                                   unsigned int flags __dparm(hipMemAttachSingle));

// end doxygen Managed Memory

hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipStream_t stream);

hipError_t hipFreeAsync(void* dev_ptr, hipStream_t stream);

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value);

hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value);

hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc* desc_list, size_t count);

hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool, hipMemLocation* location);

hipError_t hipMemPoolCreate(hipMemPool_t* mem_pool, const hipMemPoolProps* pool_props);

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

hipError_t hipMallocFromPoolAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream);

hipError_t hipMemPoolExportToShareableHandle(

    void*                      shared_handle,

    hipMemPool_t               mem_pool,

    hipMemAllocationHandleType handle_type,

    unsigned int               flags);

hipError_t hipMemPoolImportFromShareableHandle(

    hipMemPool_t*              mem_pool,

    void*                      shared_handle,

    hipMemAllocationHandleType handle_type,

    unsigned int               flags);

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData* export_data, void* dev_ptr);

hipError_t hipMemPoolImportPointer(

    void**                   dev_ptr,

    hipMemPool_t             mem_pool,

    hipMemPoolPtrExportData* export_data);

// Doxygen end of ordered memory allocator

DEPRECATED("use hipHostMalloc instead")

hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags);

hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags);

hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr);

hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags);

hipError_t hipHostUnregister(void* hostPtr);

hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height);

hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes);

hipError_t hipFree(void* ptr);

DEPRECATED("use hipHostFree instead")

hipError_t hipFreeHost(void* ptr);

hipError_t hipHostFree(void* ptr);

hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);

// TODO: Add description

hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes,

                               hipMemcpyKind kind, hipStream_t stream);

hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void* src, size_t sizeBytes);

hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes);

hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes);

hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void* src, size_t sizeBytes, hipStream_t stream);

hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream);

hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,

                              hipStream_t stream);


hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,

    hipModule_t hmod, const char* name);


hipError_t hipGetSymbolAddress(void** devPtr, const void* symbol);


hipError_t hipGetSymbolSize(size_t* size, const void* symbol);


hipError_t hipMemcpyToSymbol(const void* symbol, const void* src,

                             size_t sizeBytes, size_t offset __dparm(0),

                             hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));


hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src,

                                  size_t sizeBytes, size_t offset,

                                  hipMemcpyKind kind, hipStream_t stream __dparm(0));


hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol,

                               size_t sizeBytes, size_t offset __dparm(0),

                               hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));


hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol,

                                    size_t sizeBytes, size_t offset,

                                    hipMemcpyKind kind,

                                    hipStream_t stream __dparm(0));

hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,

                          hipStream_t stream __dparm(0));

hipError_t hipMemset(void* dst, int value, size_t sizeBytes);

hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count);

hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0));

hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count);

hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0));

hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count);

hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0));

hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count,

                             hipStream_t stream __dparm(0));

hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height);

hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,hipStream_t stream __dparm(0));

hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int  value, hipExtent extent );

hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int  value, hipExtent extent ,hipStream_t stream __dparm(0));

hipError_t hipMemGetInfo(size_t* free, size_t* total);

hipError_t hipMemPtrGetInfo(void* ptr, size_t* size);

hipError_t hipMallocArray(hipArray** array, const hipChannelFormatDesc* desc, size_t width,

                          size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault));

hipError_t hipArrayCreate(hipArray** pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray);

hipError_t hipArrayDestroy(hipArray* array);

hipError_t hipArray3DCreate(hipArray** array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);

hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent);

hipError_t hipFreeArray(hipArray* array);

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

hipError_t hipMalloc3DArray(hipArray** array, const struct hipChannelFormatDesc* desc,

                            struct hipExtent extent, unsigned int flags);

hipError_t hipMallocMipmappedArray(

    hipMipmappedArray_t *mipmappedArray,

    const struct hipChannelFormatDesc* desc,

    struct hipExtent extent,

    unsigned int numLevels,

    unsigned int flags __dparm(0));

hipError_t hipGetMipmappedArrayLevel(

    hipArray_t *levelArray,

    hipMipmappedArray_const_t mipmappedArray,

    unsigned int level);

hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,

                       size_t height, hipMemcpyKind kind);

hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D* pCopy, hipStream_t stream __dparm(0));

hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,

                            size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));

hipError_t hipMemcpy2DToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

                              size_t spitch, size_t width, size_t height, hipMemcpyKind kind);

hipError_t hipMemcpy2DToArrayAsync(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

                                   size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

                                   hipStream_t stream __dparm(0));

DEPRECATED(DEPRECATED_MSG)

hipError_t hipMemcpyToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

                            size_t count, hipMemcpyKind kind);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,

                              size_t count, hipMemcpyKind kind);

hipError_t hipMemcpy2DFromArray( void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind);

hipError_t hipMemcpy2DFromArrayAsync( void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));

hipError_t hipMemcpyAtoH(void* dst, hipArray* srcArray, size_t srcOffset, size_t count);

hipError_t hipMemcpyHtoA(hipArray* dstArray, size_t dstOffset, const void* srcHost, size_t count);

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms* p, hipStream_t stream __dparm(0));

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D* pCopy, hipStream_t stream);

// doxygen end Memory

hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId);

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags);

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr);

#ifndef USE_PEER_NON_UNIFIED

#define USE_PEER_NON_UNIFIED 1

#endif

#if USE_PEER_NON_UNIFIED == 1

hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId,

                         size_t sizeBytes);

hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice,

                              size_t sizeBytes, hipStream_t stream __dparm(0));

#endif

// doxygen end PeerToPeer

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxDestroy(hipCtx_t ctx);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxPushCurrent(hipCtx_t ctx);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxSetCurrent(hipCtx_t ctx);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetDevice(hipDevice_t* device);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int* apiVersion);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxSynchronize(void);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxGetFlags(unsigned int* flags);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

// doxygen end Context deprecated

hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active);

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev);

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags);

// doxygen end Context Management

hipError_t hipModuleLoad(hipModule_t* module, const char* fname);

hipError_t hipModuleUnload(hipModule_t module);

hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname);

hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func);

hipError_t hipFuncGetAttribute(int* value, hipFunction_attribute attrib, hipFunction_t hfunc);

hipError_t hipModuleGetTexRef(textureReference** texRef, hipModule_t hmod, const char* name);

hipError_t hipModuleLoadData(hipModule_t* module, const void* image);

hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions,

                               hipJitOption* options, void** optionValues);

hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY,

                                 unsigned int gridDimZ, unsigned int blockDimX,

                                 unsigned int blockDimY, unsigned int blockDimZ,

                                 unsigned int sharedMemBytes, hipStream_t stream,

                                 void** kernelParams, void** extra);

hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX,

                                      void** kernelParams, unsigned int sharedMemBytes,

                                      hipStream_t stream);

hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

                                                 int  numDevices, unsigned int  flags);

hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

                                              int  numDevices, unsigned int  flags);

// doxygen end Module

//TODO - Match CUoccupancyB2DSize

hipError_t hipModuleOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

                                             hipFunction_t f, size_t dynSharedMemPerBlk,

                                             int blockSizeLimit);

//TODO - Match CUoccupancyB2DSize

hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,

                                             hipFunction_t f, size_t dynSharedMemPerBlk,

                                             int blockSizeLimit, unsigned int  flags);

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

   int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk);

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

   int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

   int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk);

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

   int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags __dparm(hipOccupancyDefault));

hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

                                             const void* f, size_t dynSharedMemPerBlk,

                                             int blockSizeLimit);

// doxygen end Occupancy

// TODO - expand descriptions:

DEPRECATED("use roctracer/rocTX instead")

hipError_t hipProfilerStart();

DEPRECATED("use roctracer/rocTX instead")

hipError_t hipProfilerStop();

// doxygen end profiler

hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0));

hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);

hipError_t hipLaunchByPtr(const void* func);

hipError_t __hipPushCallConfiguration(dim3 gridDim,

                                      dim3 blockDim,

                                      size_t sharedMem __dparm(0),

                                      hipStream_t stream __dparm(0));

hipError_t __hipPopCallConfiguration(dim3 *gridDim,

                                     dim3 *blockDim,

                                     size_t *sharedMem,

                                     hipStream_t *stream);

hipError_t hipLaunchKernel(const void* function_address,

                           dim3 numBlocks,

                           dim3 dimBlocks,

                           void** args,

                           size_t sharedMemBytes __dparm(0),

                           hipStream_t stream __dparm(0));


hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void* userData);


hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

//TODO: Move this to hip_ext.h

hipError_t hipExtLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks,

                              void** args, size_t sharedMemBytes, hipStream_t stream,

                              hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

// doxygen end Clang launch

hipError_t hipBindTextureToMipmappedArray(

    const textureReference* tex,

    hipMipmappedArray_const_t mipmappedArray,

    const hipChannelFormatDesc* desc);


hipError_t hipCreateTextureObject(

    hipTextureObject_t* pTexObject,

    const hipResourceDesc* pResDesc,

    const hipTextureDesc* pTexDesc,

    const struct hipResourceViewDesc* pResViewDesc);


hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);


hipError_t hipGetChannelDesc(

    hipChannelFormatDesc* desc,

    hipArray_const_t array);


hipError_t hipGetTextureObjectResourceDesc(

    hipResourceDesc* pResDesc,

    hipTextureObject_t textureObject);


hipError_t hipGetTextureObjectResourceViewDesc(

    struct hipResourceViewDesc* pResViewDesc,

    hipTextureObject_t textureObject);


hipError_t hipGetTextureObjectTextureDesc(

    hipTextureDesc* pTexDesc,

    hipTextureObject_t textureObject);


hipError_t hipTexObjectCreate(

    hipTextureObject_t* pTexObject,

    const HIP_RESOURCE_DESC* pResDesc,

    const HIP_TEXTURE_DESC* pTexDesc,

    const HIP_RESOURCE_VIEW_DESC* pResViewDesc);


hipError_t hipTexObjectDestroy(

    hipTextureObject_t texObject);


hipError_t hipTexObjectGetResourceDesc(

    HIP_RESOURCE_DESC* pResDesc,

    hipTextureObject_t texObject);


hipError_t hipTexObjectGetResourceViewDesc(

    HIP_RESOURCE_VIEW_DESC* pResViewDesc,

    hipTextureObject_t texObject);


hipError_t hipTexObjectGetTextureDesc(

    HIP_TEXTURE_DESC* pTexDesc,

    hipTextureObject_t texObject);


DEPRECATED(DEPRECATED_MSG)

 hipError_t hipGetTextureReference(

    const textureReference** texref,

    const void* symbol);


DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetAddressMode(

    textureReference* texRef,

    int dim,

    enum hipTextureAddressMode am);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetArray(

    textureReference* tex,

    hipArray_const_t array,

    unsigned int flags);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetFilterMode(

    textureReference* texRef,

    enum hipTextureFilterMode fm);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetFlags(

    textureReference* texRef,

    unsigned int Flags);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetFormat(

    textureReference* texRef,

    hipArray_Format fmt,

    int NumPackedComponents);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipBindTexture(

    size_t* offset,

    const textureReference* tex,

    const void* devPtr,

    const hipChannelFormatDesc* desc,

    size_t size __dparm(UINT_MAX));

DEPRECATED(DEPRECATED_MSG)

hipError_t hipBindTexture2D(

    size_t* offset,

    const textureReference* tex,

    const void* devPtr,

    const hipChannelFormatDesc* desc,

    size_t width,

    size_t height,

    size_t pitch);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipBindTextureToArray(

    const textureReference* tex,

    hipArray_const_t array,

    const hipChannelFormatDesc* desc);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipGetTextureAlignmentOffset(

    size_t* offset,

    const textureReference* texref);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipUnbindTexture(const textureReference* tex);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetAddress(

    hipDeviceptr_t* dev_ptr,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetAddressMode(

    enum hipTextureAddressMode* pam,

    const textureReference* texRef,

    int dim);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetFilterMode(

    enum hipTextureFilterMode* pfm,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetFlags(

    unsigned int* pFlags,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetFormat(

    hipArray_Format* pFormat,

    int* pNumChannels,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetMaxAnisotropy(

    int* pmaxAnsio,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetMipmapFilterMode(

    enum hipTextureFilterMode* pfm,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetMipmapLevelBias(

    float* pbias,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetMipmapLevelClamp(

    float* pminMipmapLevelClamp,

    float* pmaxMipmapLevelClamp,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefGetMipMappedArray(

    hipMipmappedArray_t* pArray,

    const textureReference* texRef);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetAddress(

    size_t* ByteOffset,

    textureReference* texRef,

    hipDeviceptr_t dptr,

    size_t bytes);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetAddress2D(

    textureReference* texRef,

    const HIP_ARRAY_DESCRIPTOR* desc,

    hipDeviceptr_t dptr,

    size_t Pitch);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetMaxAnisotropy(

    textureReference* texRef,

    unsigned int maxAniso);

    DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetBorderColor(

    textureReference* texRef,

    float* pBorderColor);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetMipmapFilterMode(

    textureReference* texRef,

    enum hipTextureFilterMode fm);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetMipmapLevelBias(

    textureReference* texRef,

    float bias);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetMipmapLevelClamp(

    textureReference* texRef,

    float minMipMapLevelClamp,

    float maxMipMapLevelClamp);

DEPRECATED(DEPRECATED_MSG)

hipError_t hipTexRefSetMipmappedArray(

    textureReference* texRef,

    struct hipMipmappedArray* mipmappedArray,

    unsigned int Flags);


// doxygen end deprecated texture management

// The following are not supported.

hipError_t hipMipmappedArrayCreate(

    hipMipmappedArray_t* pHandle,

    HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

    unsigned int numMipmapLevels);

hipError_t hipMipmappedArrayDestroy(

    hipMipmappedArray_t hMipmappedArray);

hipError_t hipMipmappedArrayGetLevel(

    hipArray_t* pLevelArray,

    hipMipmappedArray_t hMipMappedArray,

    unsigned int level);

// doxygen end unsuppported texture management

// doxygen end Texture management

// This group is for HIPrtc


// doxygen end Runtime

const char* hipApiName(uint32_t id);

const char* hipKernelNameRef(const hipFunction_t f);

const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream);

int hipGetStreamDeviceId(hipStream_t stream);


// doxygen end Callback

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);


hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t* pGraph);


hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

                                   unsigned long long* pId);


hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

                                      unsigned long long* id_out __dparm(0),

                                      hipGraph_t* graph_out __dparm(0),

                                      const hipGraphNode_t** dependencies_out __dparm(0),

                                      size_t* numDependencies_out __dparm(0));


hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus);


hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

                                              size_t numDependencies,

                                              unsigned int flags __dparm(0));


hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);


hipError_t hipGraphCreate(hipGraph_t* pGraph, unsigned int flags);


hipError_t hipGraphDestroy(hipGraph_t graph);


hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t* from,

                                   const hipGraphNode_t* to, size_t numDependencies);


hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t* from,

                                      const hipGraphNode_t* to, size_t numDependencies);


hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t* from, hipGraphNode_t* to,

                            size_t* numEdges);


hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes);


hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

                                size_t* pNumRootNodes);


hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

                                       size_t* pNumDependencies);


hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

                                         size_t* pNumDependentNodes);


hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType* pType);


hipError_t hipGraphDestroyNode(hipGraphNode_t node);


hipError_t hipGraphClone(hipGraph_t* pGraphClone, hipGraph_t originalGraph);


hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

                                   hipGraph_t clonedGraph);


hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

                               hipGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize);


hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

                                        unsigned long long flags);


hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);


hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);


hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);


// Check whether an executable graph can be updated with a graph and perform the update if possible.

hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

                              hipGraphNode_t* hErrorNode_out,

                              hipGraphExecUpdateResult* updateResult_out);


hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                 const hipGraphNode_t* pDependencies, size_t numDependencies,

                                 const hipKernelNodeParams* pNodeParams);


hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams* pNodeParams);


hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams* pNodeParams);


hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                           const hipKernelNodeParams* pNodeParams);


hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                 const hipGraphNode_t* pDependencies, size_t numDependencies,

                                 const hipMemcpy3DParms* pCopyParams);

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms* pNodeParams);


hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms* pNodeParams);


hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

                                          const hipKernelNodeAttrValue* value);

hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

                                          hipKernelNodeAttrValue* value);

hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                           hipMemcpy3DParms* pNodeParams);


hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                   const hipGraphNode_t* pDependencies, size_t numDependencies,

                                   void* dst, const void* src, size_t count, hipMemcpyKind kind);


hipError_t hipGraphMemcpyNodeSetParams1D(hipGraphNode_t node, void* dst, const void* src,

                                         size_t count, hipMemcpyKind kind);


hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                             void* dst, const void* src, size_t count,

                                             hipMemcpyKind kind);


hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                           const hipGraphNode_t* pDependencies,

                                           size_t numDependencies, void* dst, const void* symbol,

                                           size_t count, size_t offset, hipMemcpyKind kind);


hipError_t hipGraphMemcpyNodeSetParamsFromSymbol(hipGraphNode_t node, void* dst, const void* symbol,

                                                 size_t count, size_t offset, hipMemcpyKind kind);


hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                                     void* dst, const void* symbol, size_t count,

                                                     size_t offset, hipMemcpyKind kind);


hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                         const hipGraphNode_t* pDependencies,

                                         size_t numDependencies, const void* symbol,

                                         const void* src, size_t count, size_t offset,

                                         hipMemcpyKind kind);


hipError_t hipGraphMemcpyNodeSetParamsToSymbol(hipGraphNode_t node, const void* symbol,

                                               const void* src, size_t count, size_t offset,

                                               hipMemcpyKind kind);


hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                                   const void* symbol, const void* src,

                                                   size_t count, size_t offset, hipMemcpyKind kind);


hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                 const hipGraphNode_t* pDependencies, size_t numDependencies,

                                 const hipMemsetParams* pMemsetParams);


hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams* pNodeParams);


hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams* pNodeParams);


hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                           const hipMemsetParams* pNodeParams);


hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                               const hipGraphNode_t* pDependencies, size_t numDependencies,

                               const hipHostNodeParams* pNodeParams);


hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams* pNodeParams);


hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams* pNodeParams);


hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                         const hipHostNodeParams* pNodeParams);


hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                     const hipGraphNode_t* pDependencies, size_t numDependencies,

                                     hipGraph_t childGraph);


hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t* pGraph);


hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

                                               hipGraph_t childGraph);


hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                const hipGraphNode_t* pDependencies, size_t numDependencies);


hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                      const hipGraphNode_t* pDependencies, size_t numDependencies,

                                      hipEvent_t event);


hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out);


hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);


hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

                                               hipEvent_t event);


hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

                                    const hipGraphNode_t* pDependencies, size_t numDependencies,

                                    hipEvent_t event);


hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out);


hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);


hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

                                             hipEvent_t event);


hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value);


hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value);


hipError_t hipDeviceGraphMemTrim(int device);


hipError_t hipUserObjectCreate(hipUserObject_t* object_out, void* ptr, hipHostFn_t destroy, unsigned int initialRefcount, unsigned int flags);


hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count __dparm(1));


hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count __dparm(1));


hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count __dparm(1), unsigned int flags __dparm(0));


hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count);

// doxygen end graph API

hipError_t hipMemAddressFree(void* devPtr, size_t size);


hipError_t hipMemAddressReserve(void** ptr, size_t size, size_t alignment, void* addr, unsigned long long flags);


hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size, const hipMemAllocationProp* prop, unsigned long long flags);


hipError_t hipMemExportToShareableHandle(void* shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags);


hipError_t hipMemGetAccess(unsigned long long* flags, const hipMemLocation* location, void* ptr);


hipError_t hipMemGetAllocationGranularity(size_t* granularity, const hipMemAllocationProp* prop, hipMemAllocationGranularity_flags option);


hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop, hipMemGenericAllocationHandle_t handle);


hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t* handle, void* osHandle, hipMemAllocationHandleType shHandleType);


hipError_t hipMemMap(void* ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags);


hipError_t hipMemMapArrayAsync(hipArrayMapInfo* mapInfoList, unsigned int  count, hipStream_t stream);


hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);


hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t* handle, void* addr);


hipError_t hipMemSetAccess(void* ptr, size_t size, const hipMemAccessDesc* desc, size_t count);


hipError_t hipMemUnmap(void* ptr, size_t size);


// doxygen end virtual memory management API

typedef unsigned int GLuint;

typedef unsigned int GLenum;


// Queries devices associated with GL Context.

hipError_t hipGLGetDevices(unsigned int* pHipDeviceCount, int* pHipDevices,

                           unsigned int hipDeviceCount, hipGLDeviceList deviceList);

// Registers a GL Buffer for interop and returns corresponding graphics resource.

hipError_t hipGraphicsGLRegisterBuffer(hipGraphicsResource** resource, GLuint buffer,

                                       unsigned int flags);

// Register a GL Image for interop and returns the corresponding graphic resource

hipError_t hipGraphicsGLRegisterImage(hipGraphicsResource** resource, GLuint image,

                                      GLenum target, unsigned int flags);

// Maps a graphics resource for hip access.

hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

                                   hipStream_t stream  __dparm(0) );

// Get an array through which to access a subresource of a mapped graphics resource.

hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

                                                unsigned int arrayIndex, unsigned int mipLevel);

// Gets device accessible address of a graphics resource.

hipError_t hipGraphicsResourceGetMappedPointer(void** devPtr, size_t* size,

                                               hipGraphicsResource_t resource);

// Unmaps a graphics resource for hip access.

hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

                                     hipStream_t stream  __dparm(0));

// Unregisters a graphics resource.

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

// doxygen end GL Interop

#ifdef __cplusplus

} /* extern "c" */

#endif

#ifdef __cplusplus

#if defined(__clang__) && defined(__HIP__)

template <typename T>

static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

    T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {

    return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);

}

template <typename T>

static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,

    T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0, unsigned int  flags = 0 ) {

    return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);

}

#endif // defined(__clang__) && defined(__HIP__)

template <typename T>

hipError_t hipGetSymbolAddress(void** devPtr, const T &symbol) {

  return ::hipGetSymbolAddress(devPtr, (const void *)&symbol);

}

template <typename T>

hipError_t hipGetSymbolSize(size_t* size, const T &symbol) {

  return ::hipGetSymbolSize(size, (const void *)&symbol);

}

template <typename T>

hipError_t hipMemcpyToSymbol(const T& symbol, const void* src, size_t sizeBytes,

                             size_t offset __dparm(0),

                             hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

  return ::hipMemcpyToSymbol((const void*)&symbol, src, sizeBytes, offset, kind);

}

template <typename T>

hipError_t hipMemcpyToSymbolAsync(const T& symbol, const void* src, size_t sizeBytes, size_t offset,

                                  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {

  return ::hipMemcpyToSymbolAsync((const void*)&symbol, src, sizeBytes, offset, kind, stream);

}

template <typename T>

hipError_t hipMemcpyFromSymbol(void* dst, const T &symbol,

                               size_t sizeBytes, size_t offset __dparm(0),

                               hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

  return ::hipMemcpyFromSymbol(dst, (const void*)&symbol, sizeBytes, offset, kind);

}

template <typename T>

hipError_t hipMemcpyFromSymbolAsync(void* dst, const T& symbol, size_t sizeBytes, size_t offset,

                                    hipMemcpyKind kind, hipStream_t stream __dparm(0)) {

  return ::hipMemcpyFromSymbolAsync(dst, (const void*)&symbol, sizeBytes, offset, kind, stream);

}

template <class T>

inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

    int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk) {

    return hipOccupancyMaxActiveBlocksPerMultiprocessor(

        numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk);

}

template <class T>

inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

    int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) {

    return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

        numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk, flags);

}

template <typename F>

inline hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

                                                    F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize,(hipFunction_t)kernel, dynSharedMemPerBlk, blockSizeLimit);

}

template <class T>

inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim,

                                             void** kernelParams, unsigned int sharedMemBytes, hipStream_t stream) {

    return hipLaunchCooperativeKernel(reinterpret_cast<const void*>(f), gridDim,

                                      blockDim, kernelParams, sharedMemBytes, stream);

}

template <class T>

inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

                                                        unsigned int  numDevices, unsigned int  flags = 0) {

    return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

}

template <class T>

inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

                                                     unsigned int  numDevices, unsigned int  flags = 0) {

    return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

}

hipError_t hipCreateSurfaceObject(hipSurfaceObject_t* pSurfObject, const hipResourceDesc* pResDesc);

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

template <class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex,

                                        const void* devPtr, size_t size = UINT_MAX) {

    return hipBindTexture(offset, &tex, devPtr, &tex.channelDesc, size);

}

template <class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t

    hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex, const void* devPtr,

                   const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) {

    return hipBindTexture(offset, &tex, devPtr, &desc, size);

}

template<class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipBindTexture2D(

    size_t *offset,

    const struct texture<T, dim, readMode> &tex,

    const void *devPtr,

    size_t width,

    size_t height,

    size_t pitch)

{

    return hipBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch);

}

template<class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipBindTexture2D(

  size_t *offset,

  const struct texture<T, dim, readMode> &tex,

  const void *devPtr,

  const struct hipChannelFormatDesc &desc,

  size_t width,

  size_t height,

  size_t pitch)

{

  return hipBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch);

}

template<class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipBindTextureToArray(

    const struct texture<T, dim, readMode> &tex,

    hipArray_const_t array)

{

    struct hipChannelFormatDesc desc;

    hipError_t err = hipGetChannelDesc(&desc, array);

    return (err == hipSuccess) ? hipBindTextureToArray(&tex, array, &desc) : err;

}

template<class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipBindTextureToArray(

    const struct texture<T, dim, readMode> &tex,

    hipArray_const_t array,

    const struct hipChannelFormatDesc &desc)

{

    return hipBindTextureToArray(&tex, array, &desc);

}

template<class T, int dim, enum hipTextureReadMode readMode>

static inline hipError_t hipBindTextureToMipmappedArray(

    const struct texture<T, dim, readMode> &tex,

    hipMipmappedArray_const_t mipmappedArray)

{

    struct hipChannelFormatDesc desc;

    hipArray_t levelArray;

    hipError_t err = hipGetMipmappedArrayLevel(&levelArray, mipmappedArray, 0);

    if (err != hipSuccess) {

        return err;

    }

    err = hipGetChannelDesc(&desc, levelArray);

    return (err == hipSuccess) ? hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc) : err;

}

template<class T, int dim, enum hipTextureReadMode readMode>

static inline hipError_t hipBindTextureToMipmappedArray(

    const struct texture<T, dim, readMode> &tex,

    hipMipmappedArray_const_t mipmappedArray,

    const struct hipChannelFormatDesc &desc)

{

    return hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc);

}

template<class T, int dim, enum hipTextureReadMode readMode>

DEPRECATED(DEPRECATED_MSG)

static inline hipError_t hipUnbindTexture(

    const struct texture<T, dim, readMode> &tex)

{

    return hipUnbindTexture(&tex);

}

static inline hipError_t hipMallocAsync(

  void**        dev_ptr,

  size_t        size,

  hipMemPool_t  mem_pool,

  hipStream_t   stream) {

  return hipMallocFromPoolAsync(dev_ptr, size, mem_pool, stream);

}


template<class T>

static inline hipError_t hipMallocAsync(

  T**           dev_ptr,

  size_t        size,

  hipMemPool_t  mem_pool,

  hipStream_t   stream) {

  return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);

}


template<class T>

static inline hipError_t hipMallocAsync(

  T**           dev_ptr,

  size_t        size,

  hipStream_t   stream) {

  return hipMallocAsync(reinterpret_cast<void**>(dev_ptr), size, stream);

}


template<class T>

static inline hipError_t hipMallocFromPoolAsync(

  T**           dev_ptr,

  size_t        size,

  hipMemPool_t  mem_pool,

  hipStream_t   stream) {

  return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);

}

#endif // __cplusplus


#ifdef __GNUC__

#pragma GCC visibility pop

#endif

// doxygen end HIP API

#elif !(defined(__HIP_PLATFORM_HCC__) || defined(__HIP_PLATFORM_AMD__)) && (defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_PLATFORM_NVIDIA__))

#include "hip/nvidia_detail/nvidia_hip_runtime_api.h"

#else

#error("Must define exactly one of __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__");

#endif


#if defined(__cplusplus) && !defined(__HIP_DISABLE_CPP_FUNCTIONS__)

template <class T>

static inline hipError_t hipMalloc(T** devPtr, size_t size) {

    return hipMalloc((void**)devPtr, size);

}


// Provide an override to automatically typecast the pointer type from void**, and also provide a

// default for the flags.

template <class T>

static inline hipError_t hipHostMalloc(T** ptr, size_t size,

                                       unsigned int flags = hipHostMallocDefault) {

    return hipHostMalloc((void**)ptr, size, flags);

}


template <class T>

static inline hipError_t hipMallocManaged(T** devPtr, size_t size,

                                       unsigned int flags = hipMemAttachGlobal) {

    return hipMallocManaged((void**)devPtr, size, flags);

}


#endif

#endif


#include <hip/amd_detail/amd_hip_runtime_pt_api.h>


#if USE_PROF_API

#include <hip/amd_detail/hip_prof_str.h>

#endif

driver_types.h

hipMemcpyKind
hipMemcpyKind
Definition driver_types.h:344

hipMemcpyDeviceToHost
@ hipMemcpyDeviceToHost
Device-to-Host Copy.
Definition driver_types.h:347

hipMemcpyHostToDevice
@ hipMemcpyHostToDevice
Host-to-Device Copy.
Definition driver_types.h:346

hipPointer_attribute
hipPointer_attribute
Definition driver_types.h:441

hipDeviceptr_t
void * hipDeviceptr_t
Definition driver_types.h:40

hipFunction_attribute
hipFunction_attribute
Definition driver_types.h:427

hipArray_Format
hipArray_Format
Definition driver_types.h:58

hipResourceType
hipResourceType
Definition driver_types.h:134

hipApiName
const char * hipApiName(uint32_t id)

hipKernelNameRef
const char * hipKernelNameRef(const hipFunction_t f)

hipKernelNameRefByPtr
const char * hipKernelNameRefByPtr(const void *hostFunction, hipStream_t stream)

hipGetStreamDeviceId
int hipGetStreamDeviceId(hipStream_t stream)

hipSetupArgument
hipError_t hipSetupArgument(const void *arg, size_t size, size_t offset)
Set a kernel argument.

__hipPopCallConfiguration
hipError_t __hipPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream)
Pop configuration of a kernel launch.

__hipPushCallConfiguration
hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0))
Push configuration of a kernel launch.

hipLaunchHostFunc
hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void *userData)
Enqueues a host function call in a stream.

hipExtLaunchKernel
hipError_t hipExtLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream, hipEvent_t startEvent, hipEvent_t stopEvent, int flags)
Launches kernel from the pointer address, with arguments and shared memory on stream.

hipConfigureCall
hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0))
Configure a kernel launch.

hipLaunchByPtr
hipError_t hipLaunchByPtr(const void *func)
Launch a kernel.

hipLaunchKernel
hipError_t hipLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes __dparm(0), hipStream_t stream __dparm(0))
C compliant kernel launch API.

hipDrvMemcpy2DUnaligned
hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipCtxGetFlags
hipError_t hipCtxGetFlags(unsigned int *flags)
Return flags used for creating default context.

hipCtxPopCurrent
hipError_t hipCtxPopCurrent(hipCtx_t *ctx)
Pop the current/default context and return the popped context.

hipCtxGetSharedMemConfig
hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)
Get Shared memory bank configuration.

hipCtxGetCurrent
hipError_t hipCtxGetCurrent(hipCtx_t *ctx)
Get the handle of the current/ default context.

hipCtxSetCacheConfig
hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition.

hipCtxSetCurrent
hipError_t hipCtxSetCurrent(hipCtx_t ctx)
Set the passed context as current/default.

hipCtxEnablePeerAccess
hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)
Enables direct access to memory allocations in a peer context.

hipCtxGetDevice
hipError_t hipCtxGetDevice(hipDevice_t *device)
Get the handle of the device associated with current/default context.

hipCtxDestroy
hipError_t hipCtxDestroy(hipCtx_t ctx)
Destroy a HIP context.

hipCtxPushCurrent
hipError_t hipCtxPushCurrent(hipCtx_t ctx)
Push the context to be set as current/ default context.

hipCtxGetCacheConfig
hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)
Set Cache configuration for a specific function.

hipCtxCreate
hipError_t hipCtxCreate(hipCtx_t *ctx, unsigned int flags, hipDevice_t device)
Create a context and set it as current/ default context.

hipCtxGetApiVersion
hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)
Returns the approximate HIP api version.

hipCtxSynchronize
hipError_t hipCtxSynchronize(void)
Blocks until the default context has completed all preceding requested tasks.

hipCtxSetSharedMemConfig
hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)
Set Shared memory bank configuration.

hipCtxDisablePeerAccess
hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)
Disable direct access from current context's virtual address space to memory allocations physically l...

hipDevicePrimaryCtxSetFlags
hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)
Set flags for the primary context.

hipDevicePrimaryCtxGetState
hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int *flags, int *active)
Get the state of the primary context.

hipDevicePrimaryCtxRelease
hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)
Release the primary context on the GPU.

hipDevicePrimaryCtxRetain
hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)
Retain the primary context on the GPU.

hipDevicePrimaryCtxReset
hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)
Resets the primary context on the GPU.

hipGetDeviceFlags
hipError_t hipGetDeviceFlags(unsigned int *flags)
Gets the flags set for current device.

hipIpcGetEventHandle
hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)
Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool
hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)
Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig
hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)
Returns bank width of shared memory for current device.

hipDeviceSetMemPool
hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)
Sets the current memory pool of a device.

hipIpcOpenMemHandle
hipError_t hipIpcOpenMemHandle(void **devPtr, hipIpcMemHandle_t handle, unsigned int flags)
Opens an interprocess memory handle exported from another process and returns a device pointer usable...

hipGetDeviceProperties
hipError_t hipGetDeviceProperties(hipDeviceProp_t *prop, int deviceId)
Returns device properties.

hipDeviceGetCacheConfig
hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)
Get Cache configuration for a specific Device.

hipSetDevice
hipError_t hipSetDevice(int deviceId)
Set default device to be used for subsequent hip API calls from this thread.

hipExtGetLinkTypeAndHopCount
hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t *linktype, uint32_t *hopcount)
Returns the link type and hop count between two devices.

hipSetDeviceFlags
hipError_t hipSetDeviceFlags(unsigned flags)
The current device behavior is changed according the flags passed.

hipDeviceGetAttribute
hipError_t hipDeviceGetAttribute(int *pi, hipDeviceAttribute_t attr, int deviceId)
Query for a specific device attribute.

hipGetDevice
hipError_t hipGetDevice(int *deviceId)
Return the default device id for the calling host thread.

hipGetDeviceCount
hipError_t hipGetDeviceCount(int *count)
Return number of compute-capable devices.

hipDeviceGetMemPool
hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)
Gets the current memory pool for the specified device.

hipDeviceReset
hipError_t hipDeviceReset(void)
The state of current device is discarded and updated to a fresh state.

hipDeviceGetLimit
hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)
Get Resource limits of current device.

hipDeviceSetSharedMemConfig
hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)
The bank width of shared memory on current device is set.

hipDeviceSetLimit
hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)
Set Resource limits of current device.

hipDeviceSetCacheConfig
hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition.

hipIpcCloseMemHandle
hipError_t hipIpcCloseMemHandle(void *devPtr)
Close memory mapped with hipIpcOpenMemHandle.

hipIpcOpenEventHandle
hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)
Opens an interprocess event handles.

hipDeviceSynchronize
hipError_t hipDeviceSynchronize(void)
Waits on all active streams on current device.

hipChooseDevice
hipError_t hipChooseDevice(int *device, const hipDeviceProp_t *prop)
Device which matches hipDeviceProp_t is returned.

hipIpcGetMemHandle
hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)
Gets an interprocess memory handle for an existing device memory allocation.

hipInit
hipError_t hipInit(unsigned int flags)
Explicitly initializes the HIP runtime.

hipDeviceComputeCapability
hipError_t hipDeviceComputeCapability(int *major, int *minor, hipDevice_t device)
Returns the compute capability of the device.

hipDeviceGetName
hipError_t hipDeviceGetName(char *name, int len, hipDevice_t device)
Returns an identifer string for the device.

hipDeviceGetByPCIBusId
hipError_t hipDeviceGetByPCIBusId(int *device, const char *pciBusId)
Returns a handle to a compute device.

hipDeviceGetUuid
hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)
Returns an UUID for the device.[BETA].

hipDeviceTotalMem
hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)
Returns the total amount of memory on the device.

hipDeviceGetPCIBusId
hipError_t hipDeviceGetPCIBusId(char *pciBusId, int len, int device)
Returns a PCI Bus Id string for the device, overloaded to take int device ID.

hipDeviceGet
hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)
Returns a handle to a compute device.

hipRuntimeGetVersion
hipError_t hipRuntimeGetVersion(int *runtimeVersion)
Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute
hipError_t hipDeviceGetP2PAttribute(int *value, hipDeviceP2PAttr attr, int srcDevice, int dstDevice)
Returns a value for attr of link between two devices.

hipDriverGetVersion
hipError_t hipDriverGetVersion(int *driverVersion)
Returns the approximate HIP driver version.

hipGetErrorString
const char * hipGetErrorString(hipError_t hipError)
Return handy text string message to explain the error which occurred.

hipPeekAtLastError
hipError_t hipPeekAtLastError(void)
Return last error returned by any HIP runtime API call.

hipDrvGetErrorString
hipError_t hipDrvGetErrorString(hipError_t hipError, const char **errorString)
Return handy text string message to explain the error which occurred.

hipGetLastError
hipError_t hipGetLastError(void)
Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...

hipDrvGetErrorName
hipError_t hipDrvGetErrorName(hipError_t hipError, const char **errorString)
Return hip error as text string form.

hipGetErrorName
const char * hipGetErrorName(hipError_t hip_error)
Return hip error as text string form.

hipEventSynchronize
hipError_t hipEventSynchronize(hipEvent_t event)
Wait for an event to complete.

hipEventRecord
hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream)
Record an event in the specified stream.

hipEventQuery
hipError_t hipEventQuery(hipEvent_t event)
Query event status.

hipEventCreate
hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy
hipError_t hipEventDestroy(hipEvent_t event)
Destroy the specified event.

hipEventElapsedTime
hipError_t hipEventElapsedTime(float *ms, hipEvent_t start, hipEvent_t stop)
Return the elapsed time between two events.

hipEventCreateWithFlags
hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)
Create an event with the specified flags.

hipFuncSetSharedMemConfig
hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)
Set shared memory configuation for a specific function.

hipFuncSetAttribute
hipError_t hipFuncSetAttribute(const void *func, hipFuncAttribute attr, int value)
Set attribute for a specific function.

hipFuncSetCacheConfig
hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)
Set Cache configuration for a specific function.

hipGLGetDevices
hipError_t hipGLGetDevices(unsigned int *pHipDeviceCount, int *pHipDevices, unsigned int hipDeviceCount, hipGLDeviceList deviceList)

hipGraphicsGLRegisterImage
hipError_t hipGraphicsGLRegisterImage(hipGraphicsResource **resource, GLuint image, GLenum target, unsigned int flags)

hipGraphicsUnregisterResource
hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

hipGraphicsGLRegisterBuffer
hipError_t hipGraphicsGLRegisterBuffer(hipGraphicsResource **resource, GLuint buffer, unsigned int flags)

hipGraphicsMapResources
hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream __dparm(0))

GLenum
unsigned int GLenum
Definition hip_runtime_api.h:6676

hipGraphicsSubResourceGetMappedArray
hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t *array, hipGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel)

GLuint
unsigned int GLuint
Definition hip_runtime_api.h:6675

hipGraphicsUnmapResources
hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream __dparm(0))

hipGraphicsResourceGetMappedPointer
hipError_t hipGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, hipGraphicsResource_t resource)

hipMemAllocationHandleType
hipMemAllocationHandleType
Definition hip_runtime_api.h:852

hipGraphicsResource_t
hipGraphicsResource * hipGraphicsResource_t
Definition hip_runtime_api.h:1065

hipGLDeviceList
hipGLDeviceList
Definition hip_runtime_api.h:1040

hipAccessProperty
hipAccessProperty
Definition hip_runtime_api.h:1138

hipMemRangeAttribute
hipMemRangeAttribute
Definition hip_runtime_api.h:726

hipMemAttachSingle
#define hipMemAttachSingle
Definition hip_runtime_api.h:621

hipMemoryAdvise
hipMemoryAdvise
Definition hip_runtime_api.h:689

hipArrayDefault
#define hipArrayDefault
Definition hip_runtime_api.h:663

hipSharedMemConfig
hipSharedMemConfig
Definition hip_runtime_api.h:923

hipComputeMode
hipComputeMode
Definition hip_runtime_api.h:462

hipStreamCaptureMode
hipStreamCaptureMode
Definition hip_runtime_api.h:1175

hipGraphNodeType
hipGraphNodeType
Definition hip_runtime_api.h:1091

hipExternalMemoryHandleType
hipExternalMemoryHandleType
Definition hip_runtime_api.h:950

hipMemAttachGlobal
#define hipMemAttachGlobal
Definition hip_runtime_api.h:615

hipFuncAttribute
hipFuncAttribute
Definition hip_runtime_api.h:906

hipExternalSemaphoreHandleType
hipExternalSemaphoreHandleType
Definition hip_runtime_api.h:977

hipJitOption
hipJitOption
Definition hip_runtime_api.h:883

hipUserObjectRetainFlags
hipUserObjectRetainFlags
Definition hip_runtime_api.h:1202

hipError_t
enum __HIP_NODISCARD hipError_t hipError_t
Definition hip_runtime_api.h:206

hipHostFn_t
void(* hipHostFn_t)(void *userData)
Definition hip_runtime_api.h:1107

hipOccupancyDefault
#define hipOccupancyDefault
Definition hip_runtime_api.h:668

hipStreamUpdateCaptureDependenciesFlags
hipStreamUpdateCaptureDependenciesFlags
Definition hip_runtime_api.h:1187

hipGraph_t
struct ihipGraph * hipGraph_t
Definition hip_runtime_api.h:1070

hipMemHandleType
hipMemHandleType
Definition hip_runtime_api.h:1246

hipFuncCache_t
hipFuncCache_t
Definition hip_runtime_api.h:914

hipUserObjectFlags
hipUserObjectFlags
Definition hip_runtime_api.h:1198

__HIP_NODISCARD
#define __HIP_NODISCARD
Definition hip_runtime_api.h:195

hipGraphMemAttributeType
hipGraphMemAttributeType
Definition hip_runtime_api.h:1192

hipMemPoolAttr
hipMemPoolAttr
Definition hip_runtime_api.h:744

hipUserObject_t
struct hipUserObject * hipUserObject_t
Definition hip_runtime_api.h:1083

hipMemOperationType
hipMemOperationType
Definition hip_runtime_api.h:1255

hipExternalSemaphore_t
void * hipExternalSemaphore_t
Definition hip_runtime_api.h:994

hipGraphicsRegisterFlags
hipGraphicsRegisterFlags
Definition hip_runtime_api.h:1053

hipMemRangeCoherencyMode
hipMemRangeCoherencyMode
Definition hip_runtime_api.h:712

hipMemAccessFlags
hipMemAccessFlags
Definition hip_runtime_api.h:822

hipMemAllocationGranularity_flags
hipMemAllocationGranularity_flags
Definition hip_runtime_api.h:1236

hipGraphExec_t
struct hipGraphExec * hipGraphExec_t
Definition hip_runtime_api.h:1078

hipGraphExecUpdateResult
hipGraphExecUpdateResult
Definition hip_runtime_api.h:1160

hipExternalMemory_t
void * hipExternalMemory_t
Definition hip_runtime_api.h:976

hipStreamCaptureStatus
hipStreamCaptureStatus
Definition hip_runtime_api.h:1180

hipDeviceAttribute_t
hipDeviceAttribute_t
Definition hip_runtime_api.h:329

hipHostMallocDefault
#define hipHostMallocDefault
Definition hip_runtime_api.h:591

hipGraphicsResource
struct _hipGraphicsResource hipGraphicsResource
Definition hip_runtime_api.h:1063

hipMemAllocationType
hipMemAllocationType
Definition hip_runtime_api.h:839

hipGraphNode_t
struct hipGraphNode * hipGraphNode_t
Definition hip_runtime_api.h:1074

hipMemGenericAllocationHandle_t
struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t
Definition hip_runtime_api.h:1229

hipGraphInstantiateFlags
hipGraphInstantiateFlags
Definition hip_runtime_api.h:1206

hipKernelNodeAttrID
hipKernelNodeAttrID
Definition hip_runtime_api.h:1134

hipMemLocationType
hipMemLocationType
Definition hip_runtime_api.h:804

hipArraySparseSubresourceType
hipArraySparseSubresourceType
Definition hip_runtime_api.h:1265

hipMemHandleTypeWin32
@ hipMemHandleTypeWin32
Allows a Win32 NT handle for exporting. (HANDLE)
Definition hip_runtime_api.h:855

hipMemHandleTypeWin32Kmt
@ hipMemHandleTypeWin32Kmt
Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)
Definition hip_runtime_api.h:856

hipMemHandleTypeNone
@ hipMemHandleTypeNone
Does not allow any export mechanism.
Definition hip_runtime_api.h:853

hipMemHandleTypePosixFileDescriptor
@ hipMemHandleTypePosixFileDescriptor
Allows a file descriptor for exporting. Permitted only on POSIX systems.
Definition hip_runtime_api.h:854

hipGLDeviceListNextFrame
@ hipGLDeviceListNextFrame
frame.
Definition hip_runtime_api.h:1044

hipGLDeviceListAll
@ hipGLDeviceListAll
All hip devices used by current OpenGL context.
Definition hip_runtime_api.h:1041

hipGLDeviceListCurrentFrame
@ hipGLDeviceListCurrentFrame
frame
Definition hip_runtime_api.h:1042

hipAccessPropertyNormal
@ hipAccessPropertyNormal
Definition hip_runtime_api.h:1139

hipAccessPropertyPersisting
@ hipAccessPropertyPersisting
Definition hip_runtime_api.h:1141

hipAccessPropertyStreaming
@ hipAccessPropertyStreaming
Definition hip_runtime_api.h:1140

hipMemRangeAttributeLastPrefetchLocation
@ hipMemRangeAttributeLastPrefetchLocation
prefetched
Definition hip_runtime_api.h:732

hipMemRangeAttributePreferredLocation
@ hipMemRangeAttributePreferredLocation
The preferred location of the range.
Definition hip_runtime_api.h:729

hipMemRangeAttributeAccessedBy
@ hipMemRangeAttributeAccessedBy
Definition hip_runtime_api.h:730

hipMemRangeAttributeReadMostly
@ hipMemRangeAttributeReadMostly
Definition hip_runtime_api.h:727

hipMemRangeAttributeCoherencyMode
@ hipMemRangeAttributeCoherencyMode
Definition hip_runtime_api.h:734

hipMemAdviseUnsetAccessedBy
@ hipMemAdviseUnsetAccessedBy
Definition hip_runtime_api.h:698

hipMemAdviseUnsetCoarseGrain
@ hipMemAdviseUnsetCoarseGrain
Restores cache coherency policy back to fine-grain.
Definition hip_runtime_api.h:705

hipMemAdviseSetCoarseGrain
@ hipMemAdviseSetCoarseGrain
Definition hip_runtime_api.h:700

hipMemAdviseUnsetPreferredLocation
@ hipMemAdviseUnsetPreferredLocation
Clear the preferred location for the data.
Definition hip_runtime_api.h:695

hipMemAdviseSetAccessedBy
@ hipMemAdviseSetAccessedBy
Definition hip_runtime_api.h:696

hipMemAdviseSetPreferredLocation
@ hipMemAdviseSetPreferredLocation
Definition hip_runtime_api.h:693

hipMemAdviseSetReadMostly
@ hipMemAdviseSetReadMostly
Definition hip_runtime_api.h:690

hipMemAdviseUnsetReadMostly
@ hipMemAdviseUnsetReadMostly
Undo the effect of hipMemAdviseSetReadMostly.
Definition hip_runtime_api.h:692

hipSharedMemBankSizeFourByte
@ hipSharedMemBankSizeFourByte
Definition hip_runtime_api.h:925

hipSharedMemBankSizeEightByte
@ hipSharedMemBankSizeEightByte
Definition hip_runtime_api.h:927

hipSharedMemBankSizeDefault
@ hipSharedMemBankSizeDefault
The compiler selects a device-specific value for the banking.
Definition hip_runtime_api.h:924

hipComputeModeProhibited
@ hipComputeModeProhibited
Definition hip_runtime_api.h:465

hipComputeModeExclusive
@ hipComputeModeExclusive
Definition hip_runtime_api.h:464

hipComputeModeDefault
@ hipComputeModeDefault
Definition hip_runtime_api.h:463

hipComputeModeExclusiveProcess
@ hipComputeModeExclusiveProcess
Definition hip_runtime_api.h:466

hipStreamCaptureModeRelaxed
@ hipStreamCaptureModeRelaxed
Definition hip_runtime_api.h:1178

hipStreamCaptureModeThreadLocal
@ hipStreamCaptureModeThreadLocal
Definition hip_runtime_api.h:1177

hipStreamCaptureModeGlobal
@ hipStreamCaptureModeGlobal
Definition hip_runtime_api.h:1176

hipGraphNodeTypeGraph
@ hipGraphNodeTypeGraph
Node which executes an embedded graph.
Definition hip_runtime_api.h:1096

hipGraphNodeTypeMemset
@ hipGraphNodeTypeMemset
Memset node.
Definition hip_runtime_api.h:1094

hipGraphNodeTypeEventRecord
@ hipGraphNodeTypeEventRecord
External event record node.
Definition hip_runtime_api.h:1099

hipGraphNodeTypeExtSemaphoreSignal
@ hipGraphNodeTypeExtSemaphoreSignal
External Semaphore signal node.
Definition hip_runtime_api.h:1100

hipGraphNodeTypeMemcpy
@ hipGraphNodeTypeMemcpy
Memcpy node.
Definition hip_runtime_api.h:1093

hipGraphNodeTypeWaitEvent
@ hipGraphNodeTypeWaitEvent
External event wait node.
Definition hip_runtime_api.h:1098

hipGraphNodeTypeCount
@ hipGraphNodeTypeCount
Definition hip_runtime_api.h:1104

hipGraphNodeTypeKernel
@ hipGraphNodeTypeKernel
GPU kernel node.
Definition hip_runtime_api.h:1092

hipGraphNodeTypeHost
@ hipGraphNodeTypeHost
Host (executable) node.
Definition hip_runtime_api.h:1095

hipGraphNodeTypeMemcpyFromSymbol
@ hipGraphNodeTypeMemcpyFromSymbol
MemcpyFromSymbol node.
Definition hip_runtime_api.h:1102

hipGraphNodeTypeMemcpyToSymbol
@ hipGraphNodeTypeMemcpyToSymbol
MemcpyToSymbol node.
Definition hip_runtime_api.h:1103

hipGraphNodeTypeEmpty
@ hipGraphNodeTypeEmpty
Empty (no-op) node.
Definition hip_runtime_api.h:1097

hipGraphNodeTypeExtSemaphoreWait
@ hipGraphNodeTypeExtSemaphoreWait
External Semaphore wait node.
Definition hip_runtime_api.h:1101

hipExternalMemoryHandleTypeD3D11Resource
@ hipExternalMemoryHandleTypeD3D11Resource
Definition hip_runtime_api.h:956

hipExternalMemoryHandleTypeD3D12Resource
@ hipExternalMemoryHandleTypeD3D12Resource
Definition hip_runtime_api.h:955

hipExternalMemoryHandleTypeOpaqueFd
@ hipExternalMemoryHandleTypeOpaqueFd
Definition hip_runtime_api.h:951

hipExternalMemoryHandleTypeD3D12Heap
@ hipExternalMemoryHandleTypeD3D12Heap
Definition hip_runtime_api.h:954

hipExternalMemoryHandleTypeOpaqueWin32Kmt
@ hipExternalMemoryHandleTypeOpaqueWin32Kmt
Definition hip_runtime_api.h:953

hipExternalMemoryHandleTypeOpaqueWin32
@ hipExternalMemoryHandleTypeOpaqueWin32
Definition hip_runtime_api.h:952

hipExternalMemoryHandleTypeD3D11ResourceKmt
@ hipExternalMemoryHandleTypeD3D11ResourceKmt
Definition hip_runtime_api.h:957

hipFuncAttributePreferredSharedMemoryCarveout
@ hipFuncAttributePreferredSharedMemoryCarveout
Definition hip_runtime_api.h:908

hipFuncAttributeMaxDynamicSharedMemorySize
@ hipFuncAttributeMaxDynamicSharedMemorySize
Definition hip_runtime_api.h:907

hipFuncAttributeMax
@ hipFuncAttributeMax
Definition hip_runtime_api.h:909

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt
@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt
Definition hip_runtime_api.h:980

hipExternalSemaphoreHandleTypeOpaqueFd
@ hipExternalSemaphoreHandleTypeOpaqueFd
Definition hip_runtime_api.h:978

hipExternalSemaphoreHandleTypeOpaqueWin32
@ hipExternalSemaphoreHandleTypeOpaqueWin32
Definition hip_runtime_api.h:979

hipExternalSemaphoreHandleTypeD3D12Fence
@ hipExternalSemaphoreHandleTypeD3D12Fence
Definition hip_runtime_api.h:981

hipJitOptionCacheMode
@ hipJitOptionCacheMode
Definition hip_runtime_api.h:898

hipJitOptionFastCompile
@ hipJitOptionFastCompile
Definition hip_runtime_api.h:900

hipJitOptionInfoLogBuffer
@ hipJitOptionInfoLogBuffer
Definition hip_runtime_api.h:887

hipJitOptionErrorLogBuffer
@ hipJitOptionErrorLogBuffer
Definition hip_runtime_api.h:889

hipJitOptionTarget
@ hipJitOptionTarget
Definition hip_runtime_api.h:893

hipJitOptionThreadsPerBlock
@ hipJitOptionThreadsPerBlock
Definition hip_runtime_api.h:885

hipJitOptionNumOptions
@ hipJitOptionNumOptions
Definition hip_runtime_api.h:901

hipJitOptionGenerateLineInfo
@ hipJitOptionGenerateLineInfo
Definition hip_runtime_api.h:897

hipJitOptionOptimizationLevel
@ hipJitOptionOptimizationLevel
Definition hip_runtime_api.h:891

hipJitOptionErrorLogBufferSizeBytes
@ hipJitOptionErrorLogBufferSizeBytes
Definition hip_runtime_api.h:890

hipJitOptionWallTime
@ hipJitOptionWallTime
Definition hip_runtime_api.h:886

hipJitOptionInfoLogBufferSizeBytes
@ hipJitOptionInfoLogBufferSizeBytes
Definition hip_runtime_api.h:888

hipJitOptionTargetFromContext
@ hipJitOptionTargetFromContext
Definition hip_runtime_api.h:892

hipJitOptionGenerateDebugInfo
@ hipJitOptionGenerateDebugInfo
Definition hip_runtime_api.h:895

hipJitOptionLogVerbose
@ hipJitOptionLogVerbose
Definition hip_runtime_api.h:896

hipJitOptionMaxRegisters
@ hipJitOptionMaxRegisters
Definition hip_runtime_api.h:884

hipJitOptionSm3xOpt
@ hipJitOptionSm3xOpt
Definition hip_runtime_api.h:899

hipJitOptionFallbackStrategy
@ hipJitOptionFallbackStrategy
Definition hip_runtime_api.h:894

hipGraphUserObjectMove
@ hipGraphUserObjectMove
Add new reference or retain.
Definition hip_runtime_api.h:1203

hipStreamAddCaptureDependencies
@ hipStreamAddCaptureDependencies
Add new nodes to the dependency set.
Definition hip_runtime_api.h:1188

hipStreamSetCaptureDependencies
@ hipStreamSetCaptureDependencies
Replace the dependency set with the new nodes.
Definition hip_runtime_api.h:1189

hipMemHandleTypeGeneric
@ hipMemHandleTypeGeneric
Generic handle type.
Definition hip_runtime_api.h:1247

hipFuncCachePreferNone
@ hipFuncCachePreferNone
no preference for shared memory or L1 (default)
Definition hip_runtime_api.h:915

hipFuncCachePreferEqual
@ hipFuncCachePreferEqual
prefer equal size L1 cache and shared memory
Definition hip_runtime_api.h:918

hipFuncCachePreferL1
@ hipFuncCachePreferL1
prefer larger L1 cache and smaller shared memory
Definition hip_runtime_api.h:917

hipFuncCachePreferShared
@ hipFuncCachePreferShared
prefer larger shared memory and smaller L1 cache
Definition hip_runtime_api.h:916

hipUserObjectNoDestructorSync
@ hipUserObjectNoDestructorSync
Destructor execution is not synchronized.
Definition hip_runtime_api.h:1199

hipGraphMemAttrReservedMemHigh
@ hipGraphMemAttrReservedMemHigh
High watermark of memory, in bytes, currently allocated for graphs.
Definition hip_runtime_api.h:1196

hipGraphMemAttrUsedMemCurrent
@ hipGraphMemAttrUsedMemCurrent
Amount of memory, in bytes, currently associated with graphs.
Definition hip_runtime_api.h:1193

hipGraphMemAttrUsedMemHigh
@ hipGraphMemAttrUsedMemHigh
High watermark of memory, in bytes, associated with graphs since the last time.
Definition hip_runtime_api.h:1194

hipGraphMemAttrReservedMemCurrent
@ hipGraphMemAttrReservedMemCurrent
Amount of memory, in bytes, currently allocated for graphs.
Definition hip_runtime_api.h:1195

hipMemPoolAttrUsedMemCurrent
@ hipMemPoolAttrUsedMemCurrent
Definition hip_runtime_api.h:791

hipMemPoolAttrReservedMemHigh
@ hipMemPoolAttrReservedMemHigh
Definition hip_runtime_api.h:786

hipMemPoolAttrReservedMemCurrent
@ hipMemPoolAttrReservedMemCurrent
Definition hip_runtime_api.h:780

hipMemPoolAttrReleaseThreshold
@ hipMemPoolAttrReleaseThreshold
Definition hip_runtime_api.h:775

hipMemPoolAttrUsedMemHigh
@ hipMemPoolAttrUsedMemHigh
Definition hip_runtime_api.h:797

hipMemPoolReuseAllowInternalDependencies
@ hipMemPoolReuseAllowInternalDependencies
Definition hip_runtime_api.h:766

hipMemPoolReuseFollowEventDependencies
@ hipMemPoolReuseFollowEventDependencies
Definition hip_runtime_api.h:753

hipMemPoolReuseAllowOpportunistic
@ hipMemPoolReuseAllowOpportunistic
Definition hip_runtime_api.h:759

hipMemOperationTypeMap
@ hipMemOperationTypeMap
Map operation.
Definition hip_runtime_api.h:1256

hipMemOperationTypeUnmap
@ hipMemOperationTypeUnmap
Unmap operation.
Definition hip_runtime_api.h:1257

hipGraphicsRegisterFlagsReadOnly
@ hipGraphicsRegisterFlagsReadOnly
HIP will not write to this registered resource.
Definition hip_runtime_api.h:1055

hipGraphicsRegisterFlagsTextureGather
@ hipGraphicsRegisterFlagsTextureGather
HIP will perform texture gather operations on this registered resource.
Definition hip_runtime_api.h:1059

hipGraphicsRegisterFlagsWriteDiscard
@ hipGraphicsRegisterFlagsWriteDiscard
HIP will only write and will not read from this registered resource.
Definition hip_runtime_api.h:1056

hipGraphicsRegisterFlagsNone
@ hipGraphicsRegisterFlagsNone
Definition hip_runtime_api.h:1054

hipGraphicsRegisterFlagsSurfaceLoadStore
@ hipGraphicsRegisterFlagsSurfaceLoadStore
HIP will bind this resource to a surface.
Definition hip_runtime_api.h:1058

hipMemRangeCoherencyModeFineGrain
@ hipMemRangeCoherencyModeFineGrain
Definition hip_runtime_api.h:713

hipMemRangeCoherencyModeIndeterminate
@ hipMemRangeCoherencyModeIndeterminate
Definition hip_runtime_api.h:717

hipMemRangeCoherencyModeCoarseGrain
@ hipMemRangeCoherencyModeCoarseGrain
Definition hip_runtime_api.h:715

hipMemAccessFlagsProtRead
@ hipMemAccessFlagsProtRead
Set the address range read accessible.
Definition hip_runtime_api.h:824

hipMemAccessFlagsProtNone
@ hipMemAccessFlagsProtNone
Default, make the address range not accessible.
Definition hip_runtime_api.h:823

hipMemAccessFlagsProtReadWrite
@ hipMemAccessFlagsProtReadWrite
Set the address range read-write accessible.
Definition hip_runtime_api.h:825

hipMemAllocationGranularityMinimum
@ hipMemAllocationGranularityMinimum
Minimum granularity.
Definition hip_runtime_api.h:1237

hipMemAllocationGranularityRecommended
@ hipMemAllocationGranularityRecommended
Recommended granularity for performance.
Definition hip_runtime_api.h:1238

hipGraphExecUpdateErrorNotSupported
@ hipGraphExecUpdateErrorNotSupported
The update failed because something about the node is not supported.
Definition hip_runtime_api.h:1170

hipGraphExecUpdateErrorNodeTypeChanged
@ hipGraphExecUpdateErrorNodeTypeChanged
The update failed because a node type changed.
Definition hip_runtime_api.h:1165

hipGraphExecUpdateErrorTopologyChanged
@ hipGraphExecUpdateErrorTopologyChanged
The update failed because the topology changed.
Definition hip_runtime_api.h:1164

hipGraphExecUpdateErrorUnsupportedFunctionChange
@ hipGraphExecUpdateErrorUnsupportedFunctionChange
Definition hip_runtime_api.h:1172

hipGraphExecUpdateError
@ hipGraphExecUpdateError
Definition hip_runtime_api.h:1162

hipGraphExecUpdateErrorFunctionChanged
@ hipGraphExecUpdateErrorFunctionChanged
The update failed because the function of a kernel node changed.
Definition hip_runtime_api.h:1166

hipGraphExecUpdateSuccess
@ hipGraphExecUpdateSuccess
The update succeeded.
Definition hip_runtime_api.h:1161

hipGraphExecUpdateErrorParametersChanged
@ hipGraphExecUpdateErrorParametersChanged
The update failed because the parameters changed in a way that is not supported.
Definition hip_runtime_api.h:1168

hipStreamCaptureStatusInvalidated
@ hipStreamCaptureStatusInvalidated
Definition hip_runtime_api.h:1183

hipStreamCaptureStatusNone
@ hipStreamCaptureStatusNone
Stream is not capturing.
Definition hip_runtime_api.h:1181

hipStreamCaptureStatusActive
@ hipStreamCaptureStatusActive
Stream is actively capturing.
Definition hip_runtime_api.h:1182

hipDeviceAttributeDirectManagedMemAccessFromHost
@ hipDeviceAttributeDirectManagedMemAccessFromHost
Definition hip_runtime_api.h:347

hipDeviceAttributeSurfaceAlignment
@ hipDeviceAttributeSurfaceAlignment
Cuda only. Alignment requirement for surfaces.
Definition hip_runtime_api.h:417

hipDeviceAttributeMaxGridDimX
@ hipDeviceAttributeMaxGridDimX
Max grid size in width.
Definition hip_runtime_api.h:364

hipDeviceAttributeMaxSurfaceCubemapLayered
@ hipDeviceAttributeMaxSurfaceCubemapLayered
Cuda only. Maximum dimension of Cubemap layered surface.
Definition hip_runtime_api.h:373

hipDeviceAttributeMaxSurface3D
@ hipDeviceAttributeMaxSurface3D
Maximum dimension (width, height, depth) of 3D surface.
Definition hip_runtime_api.h:371

hipDeviceAttributeMaxPitch
@ hipDeviceAttributeMaxPitch
Maximum pitch in bytes allowed by memory copies.
Definition hip_runtime_api.h:394

hipDeviceAttributeTccDriver
@ hipDeviceAttributeTccDriver
Cuda only. Whether device is a Tesla device using TCC driver.
Definition hip_runtime_api.h:418

hipDeviceAttributeHostNativeAtomicSupported
@ hipDeviceAttributeHostNativeAtomicSupported
Cuda only. Link between the device and the host supports native atomic operations.
Definition hip_runtime_api.h:350

hipDeviceAttributePageableMemoryAccessUsesHostPageTables
@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables
Device accesses pageable memory via the host's page tables.
Definition hip_runtime_api.h:403

hipDeviceAttributeMaxBlockDimY
@ hipDeviceAttributeMaxBlockDimY
Max block size in height.
Definition hip_runtime_api.h:362

hipDeviceAttributeMaxSurfaceCubemap
@ hipDeviceAttributeMaxSurfaceCubemap
Cuda only. Maximum dimensions of Cubemap surface.
Definition hip_runtime_api.h:372

hipDeviceAttributeName
@ hipDeviceAttributeName
Device name.
Definition hip_runtime_api.h:400

hipDeviceAttributePageableMemoryAccess
@ hipDeviceAttributePageableMemoryAccess
Definition hip_runtime_api.h:401

hipDeviceAttributeClockRate
@ hipDeviceAttributeClockRate
Peak clock frequency in kilohertz.
Definition hip_runtime_api.h:338

hipDeviceAttributeCudaCompatibleEnd
@ hipDeviceAttributeCudaCompatibleEnd
Definition hip_runtime_api.h:429

hipDeviceAttributeMaxTexture1DMipmap
@ hipDeviceAttributeMaxTexture1DMipmap
Cuda only. Maximum size of 1D mipmapped texture.
Definition hip_runtime_api.h:378

hipDeviceAttributeComputeCapabilityMajor
@ hipDeviceAttributeComputeCapabilityMajor
Major compute capability version number.
Definition hip_runtime_api.h:358

hipDeviceAttributeGlobalL1CacheSupported
@ hipDeviceAttributeGlobalL1CacheSupported
Cuda only. Device supports caching globals in L1.
Definition hip_runtime_api.h:349

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem
Definition hip_runtime_api.h:445

hipDeviceAttributeAccessPolicyMaxWindowSize
@ hipDeviceAttributeAccessPolicyMaxWindowSize
Cuda only. The maximum size of the window policy in bytes.
Definition hip_runtime_api.h:333

hipDeviceAttributeMaxTexture3DHeight
@ hipDeviceAttributeMaxTexture3DHeight
Maximum dimension height of 3D texture.
Definition hip_runtime_api.h:386

hipDeviceAttributeComputeCapabilityMinor
@ hipDeviceAttributeComputeCapabilityMinor
Minor compute capability version number.
Definition hip_runtime_api.h:397

hipDeviceAttributeMaxTextureCubemap
@ hipDeviceAttributeMaxTextureCubemap
Cuda only. Maximum dimensions of Cubemap texture.
Definition hip_runtime_api.h:389

hipDeviceAttributeDeviceOverlap
@ hipDeviceAttributeDeviceOverlap
Definition hip_runtime_api.h:345

hipDeviceAttributeMaxTexture2DLinear
@ hipDeviceAttributeMaxTexture2DLinear
Cuda only. Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.
Definition hip_runtime_api.h:383

hipDeviceAttributeMaxSurface2D
@ hipDeviceAttributeMaxSurface2D
Maximum dimension (width, height) of 2D surface.
Definition hip_runtime_api.h:369

hipDeviceAttributeMaxSurface1DLayered
@ hipDeviceAttributeMaxSurface1DLayered
Cuda only. Maximum dimensions of 1D layered surface.
Definition hip_runtime_api.h:368

hipDeviceAttributeHdpRegFlushCntl
@ hipDeviceAttributeHdpRegFlushCntl
Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:438

hipDeviceAttributeComputeMode
@ hipDeviceAttributeComputeMode
Compute mode that device is currently in.
Definition hip_runtime_api.h:339

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc
Definition hip_runtime_api.h:439

hipDeviceAttributeAsicRevision
@ hipDeviceAttributeAsicRevision
Revision of the GPU in this device.
Definition hip_runtime_api.h:448

hipDeviceAttributeCooperativeMultiDeviceLaunch
@ hipDeviceAttributeCooperativeMultiDeviceLaunch
Support cooperative launch on multiple devices.
Definition hip_runtime_api.h:344

hipDeviceAttributeMaxTexture2DHeight
@ hipDeviceAttributeMaxTexture2DHeight
Maximum dimension hight of 2D texture.
Definition hip_runtime_api.h:380

hipDeviceAttributePersistingL2CacheMaxSize
@ hipDeviceAttributePersistingL2CacheMaxSize
Cuda11 only. Maximum l2 persisting lines capacity in bytes.
Definition hip_runtime_api.h:407

hipDeviceAttributeEccEnabled
@ hipDeviceAttributeEccEnabled
Whether ECC support is enabled.
Definition hip_runtime_api.h:332

hipDeviceAttributeCanUseHostPointerForRegisteredMem
@ hipDeviceAttributeCanUseHostPointerForRegisteredMem
Definition hip_runtime_api.h:336

hipDeviceAttributePciBusId
@ hipDeviceAttributePciBusId
PCI Bus ID.
Definition hip_runtime_api.h:404

hipDeviceAttributeL2CacheSize
@ hipDeviceAttributeL2CacheSize
Size of L2 cache in bytes. 0 if the device doesn't have L2 cache.
Definition hip_runtime_api.h:354

hipDeviceAttributeKernelExecTimeout
@ hipDeviceAttributeKernelExecTimeout
Run time limit for kernels executed on the device.
Definition hip_runtime_api.h:353

hipDeviceAttributeMaxThreadsDim
@ hipDeviceAttributeMaxThreadsDim
Maximum dimension of a block.
Definition hip_runtime_api.h:391

hipDeviceAttributeSingleToDoublePrecisionPerfRatio
@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio
Cuda only. Performance ratio of single precision to double precision.
Definition hip_runtime_api.h:415

hipDeviceAttributeMaxGridDimY
@ hipDeviceAttributeMaxGridDimY
Max grid size in height.
Definition hip_runtime_api.h:365

hipDeviceAttributeMultiprocessorCount
@ hipDeviceAttributeMultiprocessorCount
Number of multiprocessors on the device.
Definition hip_runtime_api.h:399

hipDeviceAttributeUuid
@ hipDeviceAttributeUuid
Cuda only. Unique ID in 16 byte.
Definition hip_runtime_api.h:424

hipDeviceAttributeAmdSpecificBegin
@ hipDeviceAttributeAmdSpecificBegin
Definition hip_runtime_api.h:430

hipDeviceAttributeMaxRegistersPerMultiprocessor
@ hipDeviceAttributeMaxRegistersPerMultiprocessor
32-bit registers available per block.
Definition hip_runtime_api.h:410

hipDeviceAttributeGcnArchName
@ hipDeviceAttributeGcnArchName
Device gcnArch name in 256 bytes.
Definition hip_runtime_api.h:436

hipDeviceAttributeIsMultiGpuBoard
@ hipDeviceAttributeIsMultiGpuBoard
Multiple GPU devices.
Definition hip_runtime_api.h:352

hipDeviceAttributeSharedMemPerBlockOptin
@ hipDeviceAttributeSharedMemPerBlockOptin
Cuda only. Maximum shared memory per block usable by special opt in.
Definition hip_runtime_api.h:413

hipDeviceAttributeMaxSurface2DLayered
@ hipDeviceAttributeMaxSurface2DLayered
Cuda only. Maximum dimensions of 2D layered surface.
Definition hip_runtime_api.h:370

hipDeviceAttributeAmdSpecificEnd
@ hipDeviceAttributeAmdSpecificEnd
Definition hip_runtime_api.h:457

hipDeviceAttributeMemoryClockRate
@ hipDeviceAttributeMemoryClockRate
Peak memory clock frequency in kilohertz.
Definition hip_runtime_api.h:396

hipDeviceAttributeGcnArch
@ hipDeviceAttributeGcnArch
Device gcn architecture.
Definition hip_runtime_api.h:435

hipDeviceAttributeMaxGridDimZ
@ hipDeviceAttributeMaxGridDimZ
Max grid size in depth.
Definition hip_runtime_api.h:366

hipDeviceAttributeHdpMemFlushCntl
@ hipDeviceAttributeHdpMemFlushCntl
Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:437

hipDeviceAttributeFineGrainSupport
@ hipDeviceAttributeFineGrainSupport
'1' if Device supports fine grain, '0' otherwise
Definition hip_runtime_api.h:454

hipDeviceAttributeCooperativeLaunch
@ hipDeviceAttributeCooperativeLaunch
Support cooperative launch.
Definition hip_runtime_api.h:343

hipDeviceAttributeUnifiedAddressing
@ hipDeviceAttributeUnifiedAddressing
Cuda only. An unified address space shared with the host.
Definition hip_runtime_api.h:423

hipDeviceAttributeAsyncEngineCount
@ hipDeviceAttributeAsyncEngineCount
Cuda only. Asynchronous engines number.
Definition hip_runtime_api.h:334

hipDeviceAttributeMultiGpuBoardGroupID
@ hipDeviceAttributeMultiGpuBoardGroupID
Cuda only. Unique ID of device group on the same multi-GPU board.
Definition hip_runtime_api.h:398

hipDeviceAttributeStreamPrioritiesSupported
@ hipDeviceAttributeStreamPrioritiesSupported
Cuda only. Whether to support stream priorities.
Definition hip_runtime_api.h:416

hipDeviceAttributeMaxSharedMemoryPerBlock
@ hipDeviceAttributeMaxSharedMemoryPerBlock
Maximum shared memory available per block in bytes.
Definition hip_runtime_api.h:412

hipDeviceAttributeLocalL1CacheSupported
@ hipDeviceAttributeLocalL1CacheSupported
caching locals in L1 is supported
Definition hip_runtime_api.h:355

hipDeviceAttributeCanUseStreamWaitValue
@ hipDeviceAttributeCanUseStreamWaitValue
Definition hip_runtime_api.h:449

hipDeviceAttributeMaxRegistersPerBlock
@ hipDeviceAttributeMaxRegistersPerBlock
Definition hip_runtime_api.h:408

hipDeviceAttributeMaxThreadsPerBlock
@ hipDeviceAttributeMaxThreadsPerBlock
Maximum number of threads per block.
Definition hip_runtime_api.h:392

hipDeviceAttributeMemoryBusWidth
@ hipDeviceAttributeMemoryBusWidth
Global memory bus width in bits.
Definition hip_runtime_api.h:395

hipDeviceAttributeComputePreemptionSupported
@ hipDeviceAttributeComputePreemptionSupported
Cuda only. Device supports Compute Preemption.
Definition hip_runtime_api.h:340

hipDeviceAttributeMaxSurface1D
@ hipDeviceAttributeMaxSurface1D
Maximum size of 1D surface.
Definition hip_runtime_api.h:367

hipDeviceAttributeMaxTexture3DAlt
@ hipDeviceAttributeMaxTexture3DAlt
Cuda only. Maximum dimensions of alternate 3D texture.
Definition hip_runtime_api.h:388

hipDeviceAttributeMaxTexture1DLinear
@ hipDeviceAttributeMaxTexture1DLinear
Definition hip_runtime_api.h:376

hipDeviceAttributeMaxTexture2DGather
@ hipDeviceAttributeMaxTexture2DGather
Cuda only. Maximum dimensions of 2D texture if gather operations performed.
Definition hip_runtime_api.h:381

hipDeviceAttributeWallClockRate
@ hipDeviceAttributeWallClockRate
Constant frequency of wall clock in kilohertz.
Definition hip_runtime_api.h:455

hipDeviceAttributePciDeviceId
@ hipDeviceAttributePciDeviceId
PCI Device ID.
Definition hip_runtime_api.h:405

hipDeviceAttributeCanMapHostMemory
@ hipDeviceAttributeCanMapHostMemory
Whether host memory can be mapped into device address space.
Definition hip_runtime_api.h:335

hipDeviceAttributeMaxTexture1DWidth
@ hipDeviceAttributeMaxTexture1DWidth
Maximum size of 1D texture.
Definition hip_runtime_api.h:374

hipDeviceAttributeConcurrentManagedAccess
@ hipDeviceAttributeConcurrentManagedAccess
Device can coherently access managed memory concurrently with the CPU.
Definition hip_runtime_api.h:342

hipDeviceAttributeVendorSpecificBegin
@ hipDeviceAttributeVendorSpecificBegin
Definition hip_runtime_api.h:458

hipDeviceAttributeArch
@ hipDeviceAttributeArch
Device architecture.
Definition hip_runtime_api.h:433

hipDeviceAttributeManagedMemory
@ hipDeviceAttributeManagedMemory
Device supports allocating managed memory on this system.
Definition hip_runtime_api.h:359

hipDeviceAttributeIntegrated
@ hipDeviceAttributeIntegrated
Device is integrated GPU.
Definition hip_runtime_api.h:351

hipDeviceAttributeMaxTexture2DLayered
@ hipDeviceAttributeMaxTexture2DLayered
Cuda only. Maximum dimensions of 2D layered texture.
Definition hip_runtime_api.h:382

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim
Definition hip_runtime_api.h:441

hipDeviceAttributeMaxTexture3DDepth
@ hipDeviceAttributeMaxTexture3DDepth
Maximum dimension depth of 3D texture.
Definition hip_runtime_api.h:387

hipDeviceAttributeImageSupport
@ hipDeviceAttributeImageSupport
'1' if Device supports image, '0' otherwise.
Definition hip_runtime_api.h:451

hipDeviceAttributeTotalGlobalMem
@ hipDeviceAttributeTotalGlobalMem
Global memory available on devicice.
Definition hip_runtime_api.h:422

hipDeviceAttributeMaxBlocksPerMultiProcessor
@ hipDeviceAttributeMaxBlocksPerMultiProcessor
Cuda only. Max block size per multiprocessor.
Definition hip_runtime_api.h:360

hipDeviceAttributeIsLargeBar
@ hipDeviceAttributeIsLargeBar
Whether it is LargeBar.
Definition hip_runtime_api.h:447

hipDeviceAttributeMaxTexture2DWidth
@ hipDeviceAttributeMaxTexture2DWidth
Maximum dimension width of 2D texture.
Definition hip_runtime_api.h:379

hipDeviceAttributeMaxBlockDimX
@ hipDeviceAttributeMaxBlockDimX
Max block size in width.
Definition hip_runtime_api.h:361

hipDeviceAttributeMaxTexture3DWidth
@ hipDeviceAttributeMaxTexture3DWidth
Maximum dimension width of 3D texture.
Definition hip_runtime_api.h:385

hipDeviceAttributeTotalConstantMemory
@ hipDeviceAttributeTotalConstantMemory
Constant memory size in bytes.
Definition hip_runtime_api.h:421

hipDeviceAttributeTextureAlignment
@ hipDeviceAttributeTextureAlignment
Alignment requirement for textures.
Definition hip_runtime_api.h:419

hipDeviceAttributeMaxTexture1DLayered
@ hipDeviceAttributeMaxTexture1DLayered
Cuda only. Maximum dimensions of 1D layered texture.
Definition hip_runtime_api.h:375

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor
@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor
Maximum Shared Memory PerMultiprocessor.
Definition hip_runtime_api.h:434

hipDeviceAttributeReservedSharedMemPerBlock
@ hipDeviceAttributeReservedSharedMemPerBlock
Cuda11 only. Shared memory reserved by CUDA driver per block.
Definition hip_runtime_api.h:411

hipDeviceAttributeCudaCompatibleBegin
@ hipDeviceAttributeCudaCompatibleBegin
Definition hip_runtime_api.h:330

hipDeviceAttributeConcurrentKernels
@ hipDeviceAttributeConcurrentKernels
Device can possibly execute multiple kernels concurrently.
Definition hip_runtime_api.h:341

hipDeviceAttributeLuid
@ hipDeviceAttributeLuid
Cuda only. 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms.
Definition hip_runtime_api.h:356

hipDeviceAttributePciDomainID
@ hipDeviceAttributePciDomainID
PCI Domain ID.
Definition hip_runtime_api.h:406

hipDeviceAttributeMaxThreadsPerMultiProcessor
@ hipDeviceAttributeMaxThreadsPerMultiProcessor
Maximum resident threads per multiprocessor.
Definition hip_runtime_api.h:393

hipDeviceAttributeTexturePitchAlignment
@ hipDeviceAttributeTexturePitchAlignment
Pitch alignment requirement for 2D texture references bound to pitched memory;.
Definition hip_runtime_api.h:420

hipDeviceAttributePhysicalMultiProcessorCount
@ hipDeviceAttributePhysicalMultiProcessorCount
Definition hip_runtime_api.h:452

hipDeviceAttributeSharedMemPerMultiprocessor
@ hipDeviceAttributeSharedMemPerMultiprocessor
Cuda only. Shared memory available per multiprocessor.
Definition hip_runtime_api.h:414

hipDeviceAttributeLuidDeviceNodeMask
@ hipDeviceAttributeLuidDeviceNodeMask
Cuda only. Luid device node mask. Undefined on TCC and non-Windows platforms.
Definition hip_runtime_api.h:357

hipDeviceAttributeMaxTextureCubemapLayered
@ hipDeviceAttributeMaxTextureCubemapLayered
Cuda only. Maximum dimensions of Cubemap layered texture.
Definition hip_runtime_api.h:390

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim
Definition hip_runtime_api.h:443

hipDeviceAttributeVirtualMemoryManagementSupported
@ hipDeviceAttributeVirtualMemoryManagementSupported
Device supports HIP virtual memory management.
Definition hip_runtime_api.h:427

hipDeviceAttributeMemoryPoolsSupported
@ hipDeviceAttributeMemoryPoolsSupported
Device supports HIP Stream Ordered Memory Allocator.
Definition hip_runtime_api.h:426

hipDeviceAttributeClockInstructionRate
@ hipDeviceAttributeClockInstructionRate
Frequency in khz of the timer used by the device-side "clock*".
Definition hip_runtime_api.h:432

hipDeviceAttributeMaxTexture2DMipmap
@ hipDeviceAttributeMaxTexture2DMipmap
Cuda only. Maximum dimensions of 2D mipmapped texture.
Definition hip_runtime_api.h:384

hipDeviceAttributeMaxBlockDimZ
@ hipDeviceAttributeMaxBlockDimZ
Max block size in depth.
Definition hip_runtime_api.h:363

hipDeviceAttributeWarpSize
@ hipDeviceAttributeWarpSize
Warp size in threads.
Definition hip_runtime_api.h:425

hipMemAllocationTypeMax
@ hipMemAllocationTypeMax
Definition hip_runtime_api.h:845

hipMemAllocationTypePinned
@ hipMemAllocationTypePinned
Definition hip_runtime_api.h:844

hipMemAllocationTypeInvalid
@ hipMemAllocationTypeInvalid
Definition hip_runtime_api.h:840

hipGraphInstantiateFlagAutoFreeOnLaunch
@ hipGraphInstantiateFlagAutoFreeOnLaunch
Automatically free memory allocated in a graph before relaunching.
Definition hip_runtime_api.h:1207

hipKernelNodeAttributeCooperative
@ hipKernelNodeAttributeCooperative
Definition hip_runtime_api.h:1136

hipKernelNodeAttributeAccessPolicyWindow
@ hipKernelNodeAttributeAccessPolicyWindow
Definition hip_runtime_api.h:1135

hipMemLocationTypeInvalid
@ hipMemLocationTypeInvalid
Definition hip_runtime_api.h:805

hipMemLocationTypeDevice
@ hipMemLocationTypeDevice
Device location, thus it's HIP device ID.
Definition hip_runtime_api.h:806

hipArraySparseSubresourceTypeSparseLevel
@ hipArraySparseSubresourceTypeSparseLevel
Sparse level.
Definition hip_runtime_api.h:1266

hipArraySparseSubresourceTypeMiptail
@ hipArraySparseSubresourceTypeMiptail
Miptail.
Definition hip_runtime_api.h:1267

hipGraphKernelNodeSetParams
hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)
Sets a kernel node's parameters.

hipGraphNodeGetDependencies
hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t *pDependencies, size_t *pNumDependencies)
Returns a node's dependencies.

hipGraphCreate
hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)
Creates a graph.

hipGraphAddMemcpyNode1D
hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *src, size_t count, hipMemcpyKind kind)
Creates a 1D memcpy node and adds it to a graph.

hipDeviceSetGraphMemAttribute
hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)
Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams
hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)
Sets a memcpy node's parameters.

hipUserObjectCreate
hipError_t hipUserObjectCreate(hipUserObject_t *object_out, void *ptr, hipHostFn_t destroy, unsigned int initialRefcount, unsigned int flags)
Create an instance of userObject to manage lifetime of a resource.

hipGraphExecUpdate
hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph, hipGraphNode_t *hErrorNode_out, hipGraphExecUpdateResult *updateResult_out)
Check whether an executable graph can be updated with a graph and perform the update if * possible.

hipGraphNodeFindInClone
hipError_t hipGraphNodeFindInClone(hipGraphNode_t *pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph)
Finds a cloned version of a node.

hipGraphAddEventWaitNode
hipError_t hipGraphAddEventWaitNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event)
Creates an event wait node and adds it to a graph.

hipGraphMemcpyNodeSetParamsToSymbol
hipError_t hipGraphMemcpyNodeSetParamsToSymbol(hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)
Sets a memcpy node's parameters to copy to a symbol on the device.

hipGraphRetainUserObject
hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count __dparm(1), unsigned int flags __dparm(0))
Retain user object for graphs.

hipStreamIsCapturing
hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)
Get stream's capture state.

hipGraphAddChildGraphNode
hipError_t hipGraphAddChildGraphNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraph_t childGraph)
Creates a child graph node and adds it to a graph.

hipGraphDestroyNode
hipError_t hipGraphDestroyNode(hipGraphNode_t node)
Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol
hipError_t hipGraphMemcpyNodeSetParamsFromSymbol(hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)
Sets a memcpy node's parameters to copy from a symbol on the device.

hipGraphReleaseUserObject
hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count)
Release user object from graphs.

hipGraphRemoveDependencies
hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)
Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D
hipError_t hipGraphMemcpyNodeSetParams1D(hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind)
Sets a memcpy node's parameters to perform a 1-dimensional copy.

hipGraphExecMemcpyNodeSetParams1D
hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind)
Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional copy.

hipGraphExecDestroy
hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)
Destroys an executable graph.

hipGraphExecHostNodeSetParams
hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams *pNodeParams)
Sets the parameters for a host node in the given graphExec.

hipGraphExecChildGraphNodeSetParams
hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph)
Updates node parameters in the child graph node in the given graphExec.

hipStreamGetCaptureInfo
hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus, unsigned long long *pId)
Get capture status of a stream.

hipGraphAddDependencies
hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)
Adds dependency edges to a graph.

hipGraphExecKernelNodeSetParams
hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)
Sets the parameters for a kernel node in the given graphExec.

hipGraphNodeGetDependentNodes
hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t *pDependentNodes, size_t *pNumDependentNodes)
Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute
hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)
Get the mem attribute for graphs.

hipGraphHostNodeGetParams
hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)
Returns a host node's parameters.

hipGraphInstantiateWithFlags
hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t *pGraphExec, hipGraph_t graph, unsigned long long flags)
Creates an executable graph from a graph.

hipGraphUpload
hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)
uploads an executable graph in a stream

hipGraphExecMemcpyNodeSetParamsToSymbol
hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)
Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the device.

hipGraphKernelNodeGetParams
hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)
Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol
hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)
Creates a memcpy node to copy from a symbol on the device and adds it to a graph.

hipUserObjectRelease
hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count __dparm(1))
Release number of references to resource.

hipGraphMemcpyNodeGetParams
hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)
Gets a memcpy node's parameters.

hipGraphAddEventRecordNode
hipError_t hipGraphAddEventRecordNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event)
Creates an event record node and adds it to a graph.

hipStreamUpdateCaptureDependencies
hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t *dependencies, size_t numDependencies, unsigned int flags __dparm(0))
Update the set of dependencies in a capturing stream.

hipStreamBeginCapture
hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)
Begins graph capture on a stream.

hipStreamEndCapture
hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)
Ends capture on a stream, returning the captured graph.

hipGraphNodeGetType
hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)
Returns a node's type.

hipGraphExecMemcpyNodeSetParams
hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)
Sets the parameters for a memcpy node in the given graphExec.

hipGraphHostNodeSetParams
hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)
Sets a host node's parameters.

hipUserObjectRetain
hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count __dparm(1))
Retain number of references to resource.

hipGraphExecEventRecordNodeSetEvent
hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)
Sets the event for an event record node in the given graphExec.

hipGraphMemsetNodeGetParams
hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)
Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph
hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)
Gets a handle to the embedded graph of a child graph node.

hipGraphKernelNodeGetAttribute
hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue *value)
Gets a node attribute.

hipThreadExchangeStreamCaptureMode
hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)
Swaps the stream capture mode of a thread.

hipGraphLaunch
hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)
launches an executable graph in a stream

hipGraphExecMemsetNodeSetParams
hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams *pNodeParams)
Sets the parameters for a memset node in the given graphExec.

hipGraphGetEdges
hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t *from, hipGraphNode_t *to, size_t *numEdges)
Returns a graph's dependency edges.

hipGraphAddKernelNode
hipError_t hipGraphAddKernelNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipKernelNodeParams *pNodeParams)
Creates a kernel execution node and adds it to a graph.

hipGraphExecEventWaitNodeSetEvent
hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)
Sets the event for an event record node in the given graphExec.

hipGraphEventWaitNodeSetEvent
hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)
Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent
hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)
Sets an event record node's event.

hipGraphEventWaitNodeGetEvent
hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)
Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute
hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue *value)
Sets a node attribute.

hipGraphMemsetNodeSetParams
hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)
Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent
hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)
Returns the event associated with an event record node.

hipGraphAddEmptyNode
hipError_t hipGraphAddEmptyNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies)
Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol
hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)
Creates a memcpy node to copy to a symbol on the device and adds it to a graph.

hipGraphDestroy
hipError_t hipGraphDestroy(hipGraph_t graph)
Destroys a graph.

hipGraphExecMemcpyNodeSetParamsFromSymbol
hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)
Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on the.

hipGraphAddHostNode
hipError_t hipGraphAddHostNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipHostNodeParams *pNodeParams)
Creates a host execution node and adds it to a graph.

hipGraphGetNodes
hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t *nodes, size_t *numNodes)
Returns graph nodes.

hipGraphAddMemsetNode
hipError_t hipGraphAddMemsetNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemsetParams *pMemsetParams)
Creates a memset node and adds it to a graph.

hipGraphInstantiate
hipError_t hipGraphInstantiate(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize)
Creates an executable graph from a graph.

hipDeviceGraphMemTrim
hipError_t hipDeviceGraphMemTrim(int device)
Free unused memory on specific device used for graph back to OS.

hipGraphClone
hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)
Clones a graph.

hipGraphGetRootNodes
hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t *pRootNodes, size_t *pNumRootNodes)
Returns graph's root nodes.

hipGraphAddMemcpyNode
hipError_t hipGraphAddMemcpyNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemcpy3DParms *pCopyParams)
Creates a memcpy node and adds it to a graph.

hipStreamGetCaptureInfo_v2
hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus *captureStatus_out, unsigned long long *id_out __dparm(0), hipGraph_t *graph_out __dparm(0), const hipGraphNode_t **dependencies_out __dparm(0), size_t *numDependencies_out __dparm(0))
Get stream's capture state.

hipFreeMipmappedArray
hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)
Frees a mipmapped array on the device.

hipMemcpyToSymbol
hipError_t hipMemcpyToSymbol(const void *symbol, const void *src, size_t sizeBytes, size_t offset __dparm(0), hipMemcpyKind kind __dparm(hipMemcpyHostToDevice))
Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side...

hipDestroyExternalMemory
hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)
Destroys an external memory object.

hipImportExternalSemaphore
hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc)
Imports an external semaphore.

hipMemcpyAtoH
hipError_t hipMemcpyAtoH(void *dst, hipArray *srcArray, size_t srcOffset, size_t count)
Copies data between host and device.

hipHostAlloc
hipError_t hipHostAlloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory [Deprecated].

hipMemcpy2DToArrayAsync
hipError_t hipMemcpy2DToArrayAsync(hipArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data between host and device.

hipGetMipmappedArrayLevel
hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)
Gets a mipmap level of a HIP mipmapped array.

hipMemsetD16Async
hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...

hipFreeHost
hipError_t hipFreeHost(void *ptr)
Free memory allocated by the hcc hip host memory allocation API. [Deprecated].

hipMemcpyFromSymbol
hipError_t hipMemcpyFromSymbol(void *dst, const void *symbol, size_t sizeBytes, size_t offset __dparm(0), hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost))
Copies data from the given symbol on the device.

hipHostFree
hipError_t hipHostFree(void *ptr)
Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDevi...

hipMemcpyToArray
hipError_t hipMemcpyToArray(hipArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind)
Copies data between host and device.

hipMemcpy2DFromArrayAsync
hipError_t hipMemcpy2DFromArrayAsync(void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data between host and device asynchronously.

hipMemGetInfo
hipError_t hipMemGetInfo(size_t *free, size_t *total)
Query memory info. Return snapshot of free memory, and total allocatable memory on the device.

hipExtMallocWithFlags
hipError_t hipExtMallocWithFlags(void **ptr, size_t sizeBytes, unsigned int flags)
Allocate memory on the default accelerator.

hipImportExternalMemory
hipError_t hipImportExternalMemory(hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc)
Imports an external memory object.

hipMemcpy3D
hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)
Copies data between host and device.

hipMemcpy3DAsync
hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms *p, hipStream_t stream __dparm(0))
Copies data between host and device asynchronously.

hipMemset3D
hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent)
Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.

hipModuleGetGlobal
hipError_t hipModuleGetGlobal(hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name)
Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the globa...

hipMemsetD16
hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count)
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...

hipMemcpyFromSymbolAsync
hipError_t hipMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data from the given symbol on the device asynchronously.

hipMalloc
hipError_t hipMalloc(void **ptr, size_t size)
Allocate memory on the default accelerator.

hipHostUnregister
hipError_t hipHostUnregister(void *hostPtr)
Un-register host pointer.

hipHostGetFlags
hipError_t hipHostGetFlags(unsigned int *flagsPtr, void *hostPtr)
Return flags associated with host pointer.

hipMemsetD32
hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count)
Fills the memory area pointed to by dest with the constant integer value for specified number of time...

hipDrvMemcpy3DAsync
hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)
Copies data between host and device asynchronously.

hipMallocHost
hipError_t hipMallocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].

hipMalloc3DArray
hipError_t hipMalloc3DArray(hipArray **array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags)
Allocate an array on the device.

hipFree
hipError_t hipFree(void *ptr)
Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSy...

hipMemcpyToSymbolAsync
hipError_t hipMemcpyToSymbolAsync(const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data to the given symbol on the device asynchronously.

hipPointerGetAttributes
hipError_t hipPointerGetAttributes(hipPointerAttribute_t *attributes, const void *ptr)
Return attributes for the specified pointer.

hipMallocPitch
hipError_t hipMallocPitch(void **ptr, size_t *pitch, size_t width, size_t height)

hipMemcpyDtoD
hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Device.

hipMemcpy2D
hipError_t hipMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind)
Copies data between host and device.

hipMemcpyFromArray
hipError_t hipMemcpyFromArray(void *dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind)
Copies data between host and device.

hipHostGetDevicePointer
hipError_t hipHostGetDevicePointer(void **devPtr, void *hstPtr, unsigned int flags)
Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyParam2DAsync
hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream __dparm(0))
Copies memory for 2D arrays.

hipDestroyExternalSemaphore
hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)
Destroys an external semaphore object and releases any references to the underlying resource....

hipMemsetD8Async
hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpy2DFromArray
hipError_t hipMemcpy2DFromArray(void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind)
Copies data between host and device.

hipDrvMemcpy3D
hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)
Copies data between host and device.

hipMemcpyHtoD
hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void *src, size_t sizeBytes)
Copy data from Host to Device.

hipMemcpyParam2D
hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)
Copies memory for 2D arrays.

hipMemsetAsync
hipError_t hipMemsetAsync(void *dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value val...

hipMemset3DAsync
hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream __dparm(0))
Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.

hipHostMalloc
hipError_t hipHostMalloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory.

hipMemcpy2DToArray
hipError_t hipMemcpy2DToArray(hipArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind)
Copies data between host and device.

hipMemcpyAsync
hipError_t hipMemcpyAsync(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copy data from src to dst asynchronously.

hipArray3DCreate
hipError_t hipArray3DCreate(hipArray **array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray)

hipHostRegister
hipError_t hipHostRegister(void *hostPtr, size_t sizeBytes, unsigned int flags)
Register host memory so it can be accessed from the current device.

hipMemcpy
hipError_t hipMemcpy(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind)
Copy data from src to dst.

hipMemset
hipError_t hipMemset(void *dst, int value, size_t sizeBytes)
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpy2DAsync
hipError_t hipMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data between host and device.

hipDrvPointerGetAttributes
hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr)
Returns information about the specified pointer.[BETA].

hipMalloc3D
hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

hipMallocArray
hipError_t hipMallocArray(hipArray **array, const hipChannelFormatDesc *desc, size_t width, size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault))
Allocate an array on the device.

hipMemcpyDtoDAsync
hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Device asynchronously.

hipMemAllocPitch
hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)

hipMemsetD8
hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count)
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpyDtoHAsync
hipError_t hipMemcpyDtoHAsync(void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Host asynchronously.

hipMemset2DAsync
hipError_t hipMemset2DAsync(void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream __dparm(0))
Fills asynchronously the memory area pointed to by dst with the constant value.

hipWaitExternalSemaphoresAsync
hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream)
Waits on a set of external semaphore objects.

hipMallocMipmappedArray
hipError_t hipMallocMipmappedArray(hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags __dparm(0))
Allocate a mipmapped array on the device.

hipMemset2D
hipError_t hipMemset2D(void *dst, size_t pitch, int value, size_t width, size_t height)
Fills the memory area pointed to by dst with the constant value.

hipFreeArray
hipError_t hipFreeArray(hipArray *array)
Frees an array on the device.

hipMemcpyHtoDAsync
hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void *src, size_t sizeBytes, hipStream_t stream)
Copy data from Host to Device asynchronously.

hipGetSymbolSize
hipError_t hipGetSymbolSize(size_t *size, const void *symbol)
Gets the size of the given symbol on the device.

hipMemcpyDtoH
hipError_t hipMemcpyDtoH(void *dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Host.

hipMemcpyWithStream
hipError_t hipMemcpyWithStream(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)

hipSignalExternalSemaphoresAsync
hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream)
Signals a set of external semaphore objects.

hipGetSymbolAddress
hipError_t hipGetSymbolAddress(void **devPtr, const void *symbol)
Gets device pointer associated with symbol on the device.

hipArrayCreate
hipError_t hipArrayCreate(hipArray **pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray)

hipMemAllocHost
hipError_t hipMemAllocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].

hipPointerGetAttribute
hipError_t hipPointerGetAttribute(void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr)
Returns information about the specified pointer.[BETA].

hipArrayDestroy
hipError_t hipArrayDestroy(hipArray *array)

hipMemcpyHtoA
hipError_t hipMemcpyHtoA(hipArray *dstArray, size_t dstOffset, const void *srcHost, size_t count)
Copies data between host and device.

hipMemPtrGetInfo
hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

hipMemsetD32Async
hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count, hipStream_t stream __dparm(0))
Fills the memory area pointed to by dev with the constant integer value for specified number of times...

hipExternalMemoryGetMappedBuffer
hipError_t hipExternalMemoryGetMappedBuffer(void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc)
Maps a buffer onto an imported memory object.

hipStreamAttachMemAsync
hipError_t hipStreamAttachMemAsync(hipStream_t stream, void *dev_ptr, size_t length __dparm(0), unsigned int flags __dparm(hipMemAttachSingle))
Attach memory to a stream asynchronously in HIP.

hipMemRangeGetAttributes
hipError_t hipMemRangeGetAttributes(void **data, size_t *data_sizes, hipMemRangeAttribute *attributes, size_t num_attributes, const void *dev_ptr, size_t count)
Query attributes of a given memory range in HIP.

hipMemAdvise
hipError_t hipMemAdvise(const void *dev_ptr, size_t count, hipMemoryAdvise advice, int device)
Advise about the usage of a given memory range to HIP.

hipMemPrefetchAsync
hipError_t hipMemPrefetchAsync(const void *dev_ptr, size_t count, int device, hipStream_t stream __dparm(0))
Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttribute
hipError_t hipMemRangeGetAttribute(void *data, size_t data_size, hipMemRangeAttribute attribute, const void *dev_ptr, size_t count)
Query an attribute of a given memory range in HIP.

hipMallocManaged
hipError_t hipMallocManaged(void **dev_ptr, size_t size, unsigned int flags __dparm(hipMemAttachGlobal))
Allocates memory that will be automatically managed by HIP.

hipFuncGetAttributes
hipError_t hipFuncGetAttributes(struct hipFuncAttributes *attr, const void *func)
Find out attributes for a given function.

hipModuleGetTexRef
hipError_t hipModuleGetTexRef(textureReference **texRef, hipModule_t hmod, const char *name)
returns the handle of the texture reference with the name from the module.

hipExtLaunchMultiKernelMultiDevice
hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams *launchParamsList, int numDevices, unsigned int flags)
Launches kernels on multiple devices and guarantees all specified kernels are dispatched on respectiv...

hipModuleLaunchKernel
hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, hipStream_t stream, void **kernelParams, void **extra)
launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelp...

hipModuleLoad
hipError_t hipModuleLoad(hipModule_t *module, const char *fname)
Loads code object from file into a hipModule_t.

hipModuleLoadDataEx
hipError_t hipModuleLoadDataEx(hipModule_t *module, const void *image, unsigned int numOptions, hipJitOption *options, void **optionValues)
builds module from code object which resides in host memory. Image is pointer to that location....

hipFuncGetAttribute
hipError_t hipFuncGetAttribute(int *value, hipFunction_attribute attrib, hipFunction_t hfunc)
Find out a specific attribute for a given function.

hipLaunchCooperativeKernelMultiDevice
hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams *launchParamsList, int numDevices, unsigned int flags)
Launches kernels on multiple devices where thread blocks can cooperate and synchronize as they execut...

hipModuleGetFunction
hipError_t hipModuleGetFunction(hipFunction_t *function, hipModule_t module, const char *kname)
Function with kname will be extracted if present in module.

hipLaunchCooperativeKernel
hipError_t hipLaunchCooperativeKernel(const void *f, dim3 gridDim, dim3 blockDimX, void **kernelParams, unsigned int sharedMemBytes, hipStream_t stream)
launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelp...

hipModuleLoadData
hipError_t hipModuleLoadData(hipModule_t *module, const void *image)
builds module from code object which resides in host memory. Image is pointer to that location.

hipModuleUnload
hipError_t hipModuleUnload(hipModule_t module)
Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags __dparm(hipOccupancyDefault))
Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize
hipError_t hipModuleOccupancyMaxPotentialBlockSize(int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit)
determine the grid and block sizes to achieves maximum occupancy for a kernel

hipOccupancyMaxActiveBlocksPerMultiprocessor
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize
hipError_t hipOccupancyMaxPotentialBlockSize(int *gridSize, int *blockSize, const void *f, size_t dynSharedMemPerBlk, int blockSizeLimit)
determine the grid and block sizes to achieves maximum occupancy for a kernel

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)
Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags
hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit, unsigned int flags)
determine the grid and block sizes to achieves maximum occupancy for a kernel

hipDeviceCanAccessPeer
hipError_t hipDeviceCanAccessPeer(int *canAccessPeer, int deviceId, int peerDeviceId)
Determine if a device can access a peer's memory.

hipDeviceEnablePeerAccess
hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)
Enable direct access from current device's virtual address space to memory allocations physically loc...

hipDeviceDisablePeerAccess
hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)
Disable direct access from current device's virtual address space to memory allocations physically lo...

hipMemGetAddressRange
hipError_t hipMemGetAddressRange(hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr)
Get information on memory allocations.

hipProfilerStart
hipError_t hipProfilerStart()
Start recording of profiling information When using this API, start the profiler with profiling disab...

hipProfilerStop
hipError_t hipProfilerStop()
Stop recording of profiling information. When using this API, start the profiler with profiling disab...

hipDeviceGetStreamPriorityRange
hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)
Returns numerical values that correspond to the least and greatest stream priority.

hipStreamDestroy
hipError_t hipStreamDestroy(hipStream_t stream)
Destroys the specified stream.

hipStreamGetFlags
hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)
Return flags associated with this stream.

hipStreamAddCallback
hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void *userData, unsigned int flags)
Adds a callback to be called on the host after all currently enqueued items in the stream have comple...

hipStreamCallback_t
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition hip_runtime_api.h:2198

hipStreamQuery
hipError_t hipStreamQuery(hipStream_t stream)
Return hipSuccess if all of the operations in the specified stream have completed,...

hipStreamSynchronize
hipError_t hipStreamSynchronize(hipStream_t stream)
Wait for all commands in stream to complete.

hipStreamWaitEvent
hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags)
Make the specified compute stream wait for an event.

hipStreamCreateWithPriority
hipError_t hipStreamCreateWithPriority(hipStream_t *stream, unsigned int flags, int priority)
Create an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask
hipError_t hipExtStreamCreateWithCUMask(hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask)
Create an asynchronous stream with the specified CU mask.

hipStreamGetPriority
hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)
Query the priority of a stream.

hipExtStreamGetCUMask
hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask)
Get CU mask associated with an asynchronous stream.

hipStreamCreateWithFlags
hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)
Create an asynchronous stream.

hipStreamCreate
hipError_t hipStreamCreate(hipStream_t *stream)
Create an asynchronous stream.

hipStreamWriteValue64
hipError_t hipStreamWriteValue64(hipStream_t stream, void *ptr, uint64_t value, unsigned int flags)
Enqueues a write command to the stream.[BETA].

hipStreamWriteValue32
hipError_t hipStreamWriteValue32(hipStream_t stream, void *ptr, uint32_t value, unsigned int flags)
Enqueues a write command to the stream.[BETA].

hipStreamWaitValue32
hipError_t hipStreamWaitValue32(hipStream_t stream, void *ptr, uint32_t value, unsigned int flags, uint32_t mask __dparm(0xFFFFFFFF))
Enqueues a wait command to the stream.[BETA].

hipStreamWaitValue64
hipError_t hipStreamWaitValue64(hipStream_t stream, void *ptr, uint64_t value, unsigned int flags, uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF))
Enqueues a wait command to the stream.[BETA].

hipMemPoolImportPointer
hipError_t hipMemPoolImportPointer(void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data)
Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle
hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags)
Imports a memory pool from a shared handle.

hipMallocFromPoolAsync
hipError_t hipMallocFromPoolAsync(void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream)
Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync
hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)
Frees memory with stream ordered semantics.

hipMemPoolTrimTo
hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)
Releases freed memory back to the OS.

hipMemPoolCreate
hipError_t hipMemPoolCreate(hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props)
Creates a memory pool.

hipMemPoolSetAccess
hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count)
Controls visibility of the specified pool between devices.

hipMemPoolDestroy
hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)
Destroys the specified memory pool.

hipMemPoolSetAttribute
hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)
Sets attributes of a memory pool.

hipMemPoolGetAttribute
hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)
Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle
hipError_t hipMemPoolExportToShareableHandle(void *shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags)
Exports a memory pool to the requested handle type.

hipMemPoolExportPointer
hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)
Export data to share a memory pool allocation between processes.

hipMallocAsync
hipError_t hipMallocAsync(void **dev_ptr, size_t size, hipStream_t stream)
Allocates memory with stream ordered semantics.

hipMemPoolGetAccess
hipError_t hipMemPoolGetAccess(hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location)
Returns the accessibility of a pool from a device.

hipTexRefGetFilterMode
hipError_t hipTexRefGetFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

hipTexRefGetMipmapLevelClamp
hipError_t hipTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, const textureReference *texRef)

hipTexRefGetAddressMode
hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode *pam, const textureReference *texRef, int dim)

hipTexRefGetFlags
hipError_t hipTexRefGetFlags(unsigned int *pFlags, const textureReference *texRef)

hipTexRefSetAddress
hipError_t hipTexRefSetAddress(size_t *ByteOffset, textureReference *texRef, hipDeviceptr_t dptr, size_t bytes)

hipTexRefSetFilterMode
hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hipTexRefSetMipmappedArray
hipError_t hipTexRefSetMipmappedArray(textureReference *texRef, struct hipMipmappedArray *mipmappedArray, unsigned int Flags)

hipTexRefGetMipmapFilterMode
hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

hipGetTextureAlignmentOffset
hipError_t hipGetTextureAlignmentOffset(size_t *offset, const textureReference *texref)

hipBindTexture2D
hipError_t hipBindTexture2D(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t width, size_t height, size_t pitch)

hipTexRefGetMaxAnisotropy
hipError_t hipTexRefGetMaxAnisotropy(int *pmaxAnsio, const textureReference *texRef)

hipUnbindTexture
hipError_t hipUnbindTexture(const textureReference *tex)

hipTexRefSetFormat
hipError_t hipTexRefSetFormat(textureReference *texRef, hipArray_Format fmt, int NumPackedComponents)

hipTexRefGetAddress
hipError_t hipTexRefGetAddress(hipDeviceptr_t *dev_ptr, const textureReference *texRef)

hipTexRefSetFlags
hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

hipTexRefSetAddressMode
hipError_t hipTexRefSetAddressMode(textureReference *texRef, int dim, enum hipTextureAddressMode am)

hipTexRefGetMipMappedArray
hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t *pArray, const textureReference *texRef)

hipTexRefSetMaxAnisotropy
hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

hipTexRefSetMipmapLevelClamp
hipError_t hipTexRefSetMipmapLevelClamp(textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp)

hipTexRefSetBorderColor
hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

hipTexRefSetArray
hipError_t hipTexRefSetArray(textureReference *tex, hipArray_const_t array, unsigned int flags)

hipTexRefSetMipmapLevelBias
hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

hipTexRefGetMipmapLevelBias
hipError_t hipTexRefGetMipmapLevelBias(float *pbias, const textureReference *texRef)

hipBindTextureToArray
hipError_t hipBindTextureToArray(const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc)

hipBindTexture
hipError_t hipBindTexture(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t size __dparm(UINT_MAX))

hipGetTextureReference
hipError_t hipGetTextureReference(const textureReference **texref, const void *symbol)
Gets the texture reference related with the symbol.

hipTexRefSetAddress2D
hipError_t hipTexRefSetAddress2D(textureReference *texRef, const HIP_ARRAY_DESCRIPTOR *desc, hipDeviceptr_t dptr, size_t Pitch)

hipTexRefSetMipmapFilterMode
hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hipTexRefGetFormat
hipError_t hipTexRefGetFormat(hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef)

hipBindTextureToMipmappedArray
hipError_t hipBindTextureToMipmappedArray(const textureReference *tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc *desc)
Binds a mipmapped array to a texture.

hipTexObjectCreate
hipError_t hipTexObjectCreate(hipTextureObject_t *pTexObject, const HIP_RESOURCE_DESC *pResDesc, const HIP_TEXTURE_DESC *pTexDesc, const HIP_RESOURCE_VIEW_DESC *pResViewDesc)
Creates a texture object.

hipGetTextureObjectResourceDesc
hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)
Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc
hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)
Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc
hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)
Gets texture descriptor of a texture object.

hipCreateTextureObject
hipError_t hipCreateTextureObject(hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc)
Creates a texture object.

hipTexObjectDestroy
hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)
Destroys a texture object.

hipGetChannelDesc
hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)
Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc
hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)
Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc
hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)
Gets resource view descriptor of a texture object.

hipDestroyTextureObject
hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)
Destroys a texture object.

hipGetTextureObjectTextureDesc
hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)
Gets texture descriptor for the texture object.

hipMipmappedArrayGetLevel
hipError_t hipMipmappedArrayGetLevel(hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level)

hipMipmappedArrayDestroy
hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

hipMipmappedArrayCreate
hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels)

hipMemAddressFree
hipError_t hipMemAddressFree(void *devPtr, size_t size)
Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle
hipError_t hipMemExportToShareableHandle(void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags)
Exports an allocation to a requested shareable handle type.

hipMemGetAccess
hipError_t hipMemGetAccess(unsigned long long *flags, const hipMemLocation *location, void *ptr)
Get the access flags set for the given location and ptr.

hipMemSetAccess
hipError_t hipMemSetAccess(void *ptr, size_t size, const hipMemAccessDesc *desc, size_t count)
Set the access flags for each location specified in desc for the given virtual address range.

hipMemRelease
hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)
Release a memory handle representing a memory allocation which was previously allocated through hipMe...

hipMemUnmap
hipError_t hipMemUnmap(void *ptr, size_t size)
Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity
hipError_t hipMemGetAllocationGranularity(size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option)
Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle
hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)
Returns the allocation handle of the backing memory allocation given the address.

hipMemCreate
hipError_t hipMemCreate(hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags)
Creates a memory allocation described by the properties and size.

hipMemMap
hipError_t hipMemMap(void *ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags)
Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve
hipError_t hipMemAddressReserve(void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags)
Reserves an address range.

hipMemGetAllocationPropertiesFromHandle
hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)
Retrieve the property structure of the given handle.

hipMemMapArrayAsync
hipError_t hipMemMapArrayAsync(hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream)
Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.

hipMemImportFromShareableHandle
hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType)
Imports an allocation from a requested shareable handle type.

hip_common.h

hipLimit_t
hipLimit_t
Definition hip_runtime_api.h:551

hipLimitMallocHeapSize
@ hipLimitMallocHeapSize
Definition hip_runtime_api.h:554

hipLimitStackSize
@ hipLimitStackSize
Definition hip_runtime_api.h:552

hipLimitRange
@ hipLimitRange
Definition hip_runtime_api.h:555

hipLimitPrintfFifoSize
@ hipLimitPrintfFifoSize
Definition hip_runtime_api.h:553

hipErrorIllegalAddress
hipErrorIllegalAddress
Definition hip_runtime_api.h:266

hipErrorMemoryAllocation
hipErrorMemoryAllocation
Memory allocation error.
Definition hip_runtime_api.h:212

hipErrorNotFound
hipErrorNotFound
Definition hip_runtime_api.h:261

hipCtx_t
struct ihipCtx_t * hipCtx_t
Definition hip_runtime_api.h:513

hipErrorProfilerDisabled
hipErrorProfilerDisabled
Definition hip_runtime_api.h:217

__dparm
#define __dparm(x)
Definition hip_runtime_api.h:497

hipStream_t
struct ihipStream_t * hipStream_t
Definition hip_runtime_api.h:522

hipErrorInvalidDevicePointer
hipErrorInvalidDevicePointer
Invalid Device Pointer.
Definition hip_runtime_api.h:224

hipDevice_t
int hipDevice_t
Definition hip_runtime_api.h:515

hipErrorRuntimeMemory
hipErrorRuntimeMemory
Definition hip_runtime_api.h:315

hipErrorInvalidImage
hipErrorInvalidImage
Definition hip_runtime_api.h:232

hipErrorPeerAccessUnsupported
hipErrorPeerAccessUnsupported
Definition hip_runtime_api.h:249

hipErrorArrayIsMapped
hipErrorArrayIsMapped
Definition hip_runtime_api.h:239

hipErrorStreamCaptureIsolation
hipErrorStreamCaptureIsolation
Definition hip_runtime_api.h:296

hipErrorInvalidKernelFile
hipErrorInvalidKernelFile
In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.
Definition hip_runtime_api.h:250

hipErrorNotMapped
hipErrorNotMapped
Definition hip_runtime_api.h:243

hipEvent_t
struct ihipEvent_t * hipEvent_t
Definition hip_runtime_api.h:550

hipErrorGraphExecUpdateFailure
hipErrorGraphExecUpdateFailure
Definition hip_runtime_api.h:309

hipErrorNotInitialized
hipErrorNotInitialized
Definition hip_runtime_api.h:213

hipErrorInvalidResourceHandle
hipErrorInvalidResourceHandle
Resource handle (hipEvent_t or hipStream_t) invalid.
Definition hip_runtime_api.h:259

hipErrorSharedObjectInitFailed
hipErrorSharedObjectInitFailed
Definition hip_runtime_api.h:255

hipErrorInvalidPitchValue
hipErrorInvalidPitchValue
Definition hip_runtime_api.h:222

hipErrorNoBinaryForGpu
hipErrorNoBinaryForGpu
Definition hip_runtime_api.h:241

hipErrorInvalidContext
hipErrorInvalidContext
Produced when input context is invalid.
Definition hip_runtime_api.h:233

hipDeviceP2PAttr
hipDeviceP2PAttr
Definition hip_runtime_api.h:516

hipDevP2PAttrAccessSupported
@ hipDevP2PAttrAccessSupported
Definition hip_runtime_api.h:518

hipDevP2PAttrHipArrayAccessSupported
@ hipDevP2PAttrHipArrayAccessSupported
Definition hip_runtime_api.h:520

hipDevP2PAttrNativeAtomicSupported
@ hipDevP2PAttrNativeAtomicSupported
Definition hip_runtime_api.h:519

hipDevP2PAttrPerformanceRank
@ hipDevP2PAttrPerformanceRank
Definition hip_runtime_api.h:517

hipErrorStreamCaptureUnsupported
hipErrorStreamCaptureUnsupported
Definition hip_runtime_api.h:287

hipErrorPeerAccessNotEnabled
hipErrorPeerAccessNotEnabled
Peer access was never enabled from the current device.
Definition hip_runtime_api.h:271

hipErrorOperatingSystem
hipErrorOperatingSystem
Definition hip_runtime_api.h:256

hipErrorStreamCaptureUnjoined
hipErrorStreamCaptureUnjoined
Definition hip_runtime_api.h:294

hipErrorInitializationError
hipErrorInitializationError
Definition hip_runtime_api.h:215

hipErrorNotMappedAsPointer
hipErrorNotMappedAsPointer
Definition hip_runtime_api.h:245

hipErrorPriorLaunchFailure
hipErrorPriorLaunchFailure
Definition hip_runtime_api.h:228

hipErrorContextIsDestroyed
hipErrorContextIsDestroyed
Definition hip_runtime_api.h:274

hipErrorInvalidValue
hipErrorInvalidValue
Definition hip_runtime_api.h:208

hipErrorLaunchTimeOut
hipErrorLaunchTimeOut
Definition hip_runtime_api.h:268

hipErrorUnmapFailed
hipErrorUnmapFailed
Definition hip_runtime_api.h:238

hipErrorSetOnActiveProcess
hipErrorSetOnActiveProcess
Definition hip_runtime_api.h:273

hipErrorFileNotFound
hipErrorFileNotFound
Definition hip_runtime_api.h:253

hipErrorLaunchFailure
hipErrorLaunchFailure
An exception occurred on the device while executing a kernel.
Definition hip_runtime_api.h:280

hipErrorInvalidDevice
hipErrorInvalidDevice
DeviceID must be in range 0...#compute-devices.
Definition hip_runtime_api.h:231

hipErrorUnsupportedLimit
hipErrorUnsupportedLimit
Definition hip_runtime_api.h:247

hipErrorMapBufferObjectFailed
hipErrorMapBufferObjectFailed
Produced when the IPC memory attach failed from ROCr.
Definition hip_runtime_api.h:237

hipErrorHostMemoryAlreadyRegistered
hipErrorHostMemoryAlreadyRegistered
Produced when trying to lock a page-locked memory.
Definition hip_runtime_api.h:276

hipErrorMissingConfiguration
hipErrorMissingConfiguration
Definition hip_runtime_api.h:227

hipErrorSharedObjectSymbolNotFound
hipErrorSharedObjectSymbolNotFound
Definition hip_runtime_api.h:254

hipErrorECCNotCorrectable
hipErrorECCNotCorrectable
Definition hip_runtime_api.h:246

hipErrorStreamCaptureWrongThread
hipErrorStreamCaptureWrongThread
Definition hip_runtime_api.h:305

hipErrorAssert
hipErrorAssert
Produced when the kernel calls assert.
Definition hip_runtime_api.h:275

DEPRECATED_MSG
#define DEPRECATED_MSG
Definition hip_runtime_api.h:489

hipErrorContextAlreadyInUse
hipErrorContextAlreadyInUse
Definition hip_runtime_api.h:248

hipErrorNotReady
hipErrorNotReady
Definition hip_runtime_api.h:262

hipErrorInvalidSource
hipErrorInvalidSource
Definition hip_runtime_api.h:252

hipErrorLaunchOutOfResources
hipErrorLaunchOutOfResources
Out of resources error.
Definition hip_runtime_api.h:267

hipErrorInvalidDeviceFunction
hipErrorInvalidDeviceFunction
Definition hip_runtime_api.h:229

hipErrorCooperativeLaunchTooLarge
hipErrorCooperativeLaunchTooLarge
Definition hip_runtime_api.h:282

hipErrorAlreadyMapped
hipErrorAlreadyMapped
Definition hip_runtime_api.h:240

hipModule_t
struct ihipModule_t * hipModule_t
Definition hip_runtime_api.h:531

hipErrorProfilerNotInitialized
hipErrorProfilerNotInitialized
Definition hip_runtime_api.h:218

hipErrorProfilerAlreadyStarted
hipErrorProfilerAlreadyStarted
Definition hip_runtime_api.h:219

hipErrorNoDevice
hipErrorNoDevice
Call to hipGetDeviceCount returned 0 devices.
Definition hip_runtime_api.h:230

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES
@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES
Definition hip_runtime_api.h:42

HIP_ERROR_INVALID_VALUE
@ HIP_ERROR_INVALID_VALUE
Definition hip_runtime_api.h:40

HIP_SUCCESS
@ HIP_SUCCESS
Definition hip_runtime_api.h:39

HIP_ERROR_NOT_INITIALIZED
@ HIP_ERROR_NOT_INITIALIZED
Definition hip_runtime_api.h:41

hipErrorMapFailed
hipErrorMapFailed
Definition hip_runtime_api.h:235

hipErrorStreamCaptureInvalidated
hipErrorStreamCaptureInvalidated
Definition hip_runtime_api.h:289

hipFunction_t
struct ihipModuleSymbol_t * hipFunction_t
Definition hip_runtime_api.h:532

hipErrorProfilerAlreadyStopped
hipErrorProfilerAlreadyStopped
Definition hip_runtime_api.h:220

hipErrorDeinitialized
hipErrorDeinitialized
Definition hip_runtime_api.h:216

hipErrorPeerAccessAlreadyEnabled
hipErrorPeerAccessAlreadyEnabled
Peer access was already enabled from the current device.
Definition hip_runtime_api.h:269

hipErrorNotMappedAsArray
hipErrorNotMappedAsArray
Definition hip_runtime_api.h:244

DEPRECATED
#define DEPRECATED(msg)
Definition hip_runtime_api.h:487

hipErrorNotSupported
hipErrorNotSupported
Produced when the hip API is not supported/implemented.
Definition hip_runtime_api.h:286

hipErrorInvalidConfiguration
hipErrorInvalidConfiguration
Definition hip_runtime_api.h:221

hipErrorStreamCaptureImplicit
hipErrorStreamCaptureImplicit
Definition hip_runtime_api.h:300

hipErrorStreamCaptureMerge
hipErrorStreamCaptureMerge
Definition hip_runtime_api.h:291

hipErrorInvalidGraphicsContext
hipErrorInvalidGraphicsContext
Definition hip_runtime_api.h:251

hipErrorIllegalState
hipErrorIllegalState
Resource required is not in a valid state to perform operation.
Definition hip_runtime_api.h:260

hipErrorOutOfMemory
hipErrorOutOfMemory
Definition hip_runtime_api.h:210

hipErrorInvalidSymbol
hipErrorInvalidSymbol
Definition hip_runtime_api.h:223

hipSuccess
hipSuccess
Successful completion.
Definition hip_runtime_api.h:207

hipErrorUnknown
hipErrorUnknown
Definition hip_runtime_api.h:313

hipMemoryType
hipMemoryType
Definition hip_runtime_api.h:159

hipMemoryTypeDevice
@ hipMemoryTypeDevice
Definition hip_runtime_api.h:161

hipMemoryTypeHost
@ hipMemoryTypeHost
Memory is physically located on host.
Definition hip_runtime_api.h:160

hipMemoryTypeArray
@ hipMemoryTypeArray
Definition hip_runtime_api.h:163

hipMemoryTypeManaged
@ hipMemoryTypeManaged
Managed memory, automaticallly managed by the unified memory system.
Definition hip_runtime_api.h:166

hipMemoryTypeUnified
@ hipMemoryTypeUnified
Not used currently.
Definition hip_runtime_api.h:165

hipErrorInvalidHandle
hipErrorInvalidHandle
Definition hip_runtime_api.h:257

hipErrorStreamCaptureUnmatched
hipErrorStreamCaptureUnmatched
The capture was not initiated in this stream.
Definition hip_runtime_api.h:293

hipErrorCapturedEvent
hipErrorCapturedEvent
Definition hip_runtime_api.h:303

hipErrorAlreadyAcquired
hipErrorAlreadyAcquired
Definition hip_runtime_api.h:242

hipErrorInsufficientDriver
hipErrorInsufficientDriver
Definition hip_runtime_api.h:226

hipErrorHostMemoryNotRegistered
hipErrorHostMemoryNotRegistered
Produced when trying to unlock a non-page-locked memory.
Definition hip_runtime_api.h:278

HIP_IPC_HANDLE_SIZE
#define HIP_IPC_HANDLE_SIZE
Definition hip_runtime_api.h:524

hipMemPool_t
struct ihipMemPoolHandle_t * hipMemPool_t
Definition hip_runtime_api.h:536

hipErrorRuntimeOther
hipErrorRuntimeOther
Definition hip_runtime_api.h:317

hipErrorContextAlreadyCurrent
hipErrorContextAlreadyCurrent
Definition hip_runtime_api.h:234

hipErrorInvalidMemcpyDirection
hipErrorInvalidMemcpyDirection
Invalid memory copy direction.
Definition hip_runtime_api.h:225

HIP_ARRAY3D_DESCRIPTOR
Definition driver_types.h:74

HIP_ARRAY_DESCRIPTOR
Definition driver_types.h:68

HIP_MEMCPY3D
Definition driver_types.h:379

HIP_RESOURCE_DESC
Definition driver_types.h:282

HIP_RESOURCE_VIEW_DESC
Definition driver_types.h:328

HIP_TEXTURE_DESC
Definition driver_types.h:165

dim3
Definition hip_runtime_api.h:934

dim3::y
uint32_t y
y
Definition hip_runtime_api.h:936

dim3::z
uint32_t z
z
Definition hip_runtime_api.h:937

dim3::x
uint32_t x
x
Definition hip_runtime_api.h:935

hip_Memcpy2D
Definition driver_types.h:95

hipAccessPolicyWindow
Definition hip_runtime_api.h:1143

hipAccessPolicyWindow::hitProp
hipAccessProperty hitProp
Definition hip_runtime_api.h:1145

hipAccessPolicyWindow::missProp
hipAccessProperty missProp
Definition hip_runtime_api.h:1147

hipAccessPolicyWindow::hitRatio
float hitRatio
Definition hip_runtime_api.h:1146

hipAccessPolicyWindow::base_ptr
void * base_ptr
Definition hip_runtime_api.h:1144

hipAccessPolicyWindow::num_bytes
size_t num_bytes
Definition hip_runtime_api.h:1148

hipArray
Definition driver_types.h:82

hipArrayMapInfo
Definition hip_runtime_api.h:1273

hipArrayMapInfo::subresource
union hipArrayMapInfo::@24 subresource

hipArrayMapInfo::level
unsigned int level
For mipmapped arrays must be a valid mipmap level. For arrays must be zero.
Definition hip_runtime_api.h:1282

hipArrayMapInfo::flags
unsigned int flags
flags for future use, must be zero now.
Definition hip_runtime_api.h:1304

hipArrayMapInfo::subresourceType
hipArraySparseSubresourceType subresourceType
Sparse subresource type.
Definition hip_runtime_api.h:1279

hipArrayMapInfo::extentDepth
unsigned int extentDepth
Depth in elements.
Definition hip_runtime_api.h:1289

hipArrayMapInfo::offsetX
unsigned int offsetX
X offset in elements.
Definition hip_runtime_api.h:1284

hipArrayMapInfo::array
hipArray_t array
Definition hip_runtime_api.h:1277

hipArrayMapInfo::sparseLevel
struct hipArrayMapInfo::@24::@26 sparseLevel

hipArrayMapInfo::resourceType
hipResourceType resourceType
Resource type.
Definition hip_runtime_api.h:1274

hipArrayMapInfo::memOperationType
hipMemOperationType memOperationType
Memory operation type.
Definition hip_runtime_api.h:1297

hipArrayMapInfo::reserved
unsigned int reserved[2]
Reserved for future use, must be zero now.
Definition hip_runtime_api.h:1305

hipArrayMapInfo::extentWidth
unsigned int extentWidth
Width in elements.
Definition hip_runtime_api.h:1287

hipArrayMapInfo::extentHeight
unsigned int extentHeight
Height in elements.
Definition hip_runtime_api.h:1288

hipArrayMapInfo::offsetY
unsigned int offsetY
Y offset in elements.
Definition hip_runtime_api.h:1285

hipArrayMapInfo::resource
union hipArrayMapInfo::@23 resource

hipArrayMapInfo::memHandleType
hipMemHandleType memHandleType
Memory handle type.
Definition hip_runtime_api.h:1298

hipArrayMapInfo::miptail
struct hipArrayMapInfo::@24::@27 miptail

hipArrayMapInfo::memHandle
hipMemGenericAllocationHandle_t memHandle
Definition hip_runtime_api.h:1300

hipArrayMapInfo::mipmap
hipMipmappedArray mipmap
Definition hip_runtime_api.h:1276

hipArrayMapInfo::layer
unsigned int layer
For layered arrays must be a valid layer index. Otherwise, must be zero.
Definition hip_runtime_api.h:1283

hipArrayMapInfo::deviceBitMask
unsigned int deviceBitMask
Device ordinal bit mask.
Definition hip_runtime_api.h:1303

hipArrayMapInfo::size
unsigned long long size
Extent in bytes.
Definition hip_runtime_api.h:1294

hipArrayMapInfo::offset
unsigned long long offset
Offset within mip tail.
Definition hip_runtime_api.h:1293

hipArrayMapInfo::offsetZ
unsigned int offsetZ
Z offset in elements.
Definition hip_runtime_api.h:1286

hipChannelFormatDesc
Definition driver_types.h:47

hipDeviceArch_t
Definition hip_runtime_api.h:45

hipDeviceArch_t::hasSharedInt64Atomics
unsigned hasSharedInt64Atomics
64-bit integer atomics for shared memory.
Definition hip_runtime_api.h:55

hipDeviceArch_t::hasSharedInt32Atomics
unsigned hasSharedInt32Atomics
32-bit integer atomics for shared memory.
Definition hip_runtime_api.h:49

hipDeviceArch_t::hasFloatAtomicAdd
unsigned hasFloatAtomicAdd
32-bit float atomic add in global and shared memory.
Definition hip_runtime_api.h:51

hipDeviceArch_t::hasDoubles
unsigned hasDoubles
Double-precision floating point.
Definition hip_runtime_api.h:58

hipDeviceArch_t::hasWarpVote
unsigned hasWarpVote
Warp vote instructions (__any, __all).
Definition hip_runtime_api.h:61

hipDeviceArch_t::hasWarpShuffle
unsigned hasWarpShuffle
Warp shuffle operations. (__shfl_*).
Definition hip_runtime_api.h:63

hipDeviceArch_t::hasGlobalInt32Atomics
unsigned hasGlobalInt32Atomics
32-bit integer atomics for global memory.
Definition hip_runtime_api.h:47

hipDeviceArch_t::hasGlobalFloatAtomicExch
unsigned hasGlobalFloatAtomicExch
32-bit float atomic exch for global memory.
Definition hip_runtime_api.h:48

hipDeviceArch_t::hasDynamicParallelism
unsigned hasDynamicParallelism
Dynamic parallelism.
Definition hip_runtime_api.h:73

hipDeviceArch_t::hasSurfaceFuncs
unsigned hasSurfaceFuncs
Surface functions.
Definition hip_runtime_api.h:71

hipDeviceArch_t::has3dGrid
unsigned has3dGrid
Grid and group dims are 3D (rather than 2D).
Definition hip_runtime_api.h:72

hipDeviceArch_t::hasFunnelShift
unsigned hasFunnelShift
Funnel two words into one with shift&mask caps.
Definition hip_runtime_api.h:64

hipDeviceArch_t::hasThreadFenceSystem
unsigned hasThreadFenceSystem
__threadfence_system.
Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalInt64Atomics
unsigned hasGlobalInt64Atomics
64-bit integer atomics for global memory.
Definition hip_runtime_api.h:54

hipDeviceArch_t::hasSyncThreadsExt
unsigned hasSyncThreadsExt
__syncthreads_count, syncthreads_and, syncthreads_or.
Definition hip_runtime_api.h:68

hipDeviceArch_t::hasWarpBallot
unsigned hasWarpBallot
Warp ballot instructions (__ballot).
Definition hip_runtime_api.h:62

hipDeviceArch_t::hasSharedFloatAtomicExch
unsigned hasSharedFloatAtomicExch
32-bit float atomic exch for shared memory.
Definition hip_runtime_api.h:50

hipDeviceProp_t
Definition hip_runtime_api.h:87

hipDeviceProp_t::ECCEnabled
int ECCEnabled
Device has ECC support enabled.
Definition hip_runtime_api.h:135

hipDeviceProp_t::maxTexture1DLinear
int maxTexture1DLinear
Maximum size for 1D textures bound to linear memory.
Definition hip_runtime_api.h:125

hipDeviceProp_t::pciBusID
int pciBusID
PCI Bus ID.
Definition hip_runtime_api.h:115

hipDeviceProp_t::maxTexture1D
int maxTexture1D
Maximum number of elements in 1D images.
Definition hip_runtime_api.h:126

hipDeviceProp_t::memoryBusWidth
int memoryBusWidth
Global memory bus width in bits.
Definition hip_runtime_api.h:98

hipDeviceProp_t::clockRate
int clockRate
Max clock frequency of the multiProcessors in khz.
Definition hip_runtime_api.h:96

hipDeviceProp_t::maxThreadsPerMultiProcessor
int maxThreadsPerMultiProcessor
Maximum resident threads per multi-processor.
Definition hip_runtime_api.h:108

hipDeviceProp_t::l2CacheSize
int l2CacheSize
L2 cache size.
Definition hip_runtime_api.h:107

hipDeviceProp_t::totalConstMem
size_t totalConstMem
Size of shared memory region (in bytes).
Definition hip_runtime_api.h:99

hipDeviceProp_t::memPitch
size_t memPitch
Maximum pitch in bytes allowed by memory copies.
Definition hip_runtime_api.h:131

hipDeviceProp_t::sharedMemPerBlock
size_t sharedMemPerBlock
Size of shared memory region (in bytes).
Definition hip_runtime_api.h:90

hipDeviceProp_t::cooperativeMultiDeviceLaunch
int cooperativeMultiDeviceLaunch
HIP device supports cooperative launch on multiple devices.
Definition hip_runtime_api.h:124

hipDeviceProp_t::pageableMemoryAccess
int pageableMemoryAccess
Definition hip_runtime_api.h:150

hipDeviceProp_t::name
char name[256]
Device name.
Definition hip_runtime_api.h:88

hipDeviceProp_t::textureAlignment
size_t textureAlignment
Alignment requirement for textures.
Definition hip_runtime_api.h:132

hipDeviceProp_t::memoryClockRate
int memoryClockRate
Max global memory clock frequency in khz.
Definition hip_runtime_api.h:97

hipDeviceProp_t::clockInstructionRate
int clockInstructionRate
Definition hip_runtime_api.h:110

hipDeviceProp_t::regsPerBlock
int regsPerBlock
Registers per block.
Definition hip_runtime_api.h:91

hipDeviceProp_t::maxTexture2D
int maxTexture2D[2]
Maximum dimensions (width, height) of 2D images, in image elements.
Definition hip_runtime_api.h:127

hipDeviceProp_t::cooperativeLaunch
int cooperativeLaunch
HIP device supports cooperative launch.
Definition hip_runtime_api.h:123

hipDeviceProp_t::maxTexture3D
int maxTexture3D[3]
Maximum dimensions (width, height, depth) of 3D images, in image elements.
Definition hip_runtime_api.h:128

hipDeviceProp_t::directManagedMemAccessFromHost
int directManagedMemAccessFromHost
Host can directly access managed memory on the device without migration.
Definition hip_runtime_api.h:148

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc
int cooperativeMultiDeviceUnmatchedFunc
Definition hip_runtime_api.h:137

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables
int pageableMemoryAccessUsesHostPageTables
Device accesses pageable memory via the host's page tables.
Definition hip_runtime_api.h:152

hipDeviceProp_t::hdpRegFlushCntl
unsigned int * hdpRegFlushCntl
Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:130

hipDeviceProp_t::maxThreadsDim
int maxThreadsDim[3]
Max number of threads in each dimension (XYZ) of a block.
Definition hip_runtime_api.h:94

hipDeviceProp_t::isMultiGpuBoard
int isMultiGpuBoard
1 if device is on a multi-GPU board, 0 if not.
Definition hip_runtime_api.h:118

hipDeviceProp_t::pciDomainID
int pciDomainID
PCI Domain ID.
Definition hip_runtime_api.h:114

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor
size_t maxSharedMemoryPerMultiProcessor
Maximum Shared Memory Per Multiprocessor.
Definition hip_runtime_api.h:117

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim
int cooperativeMultiDeviceUnmatchedGridDim
Definition hip_runtime_api.h:139

hipDeviceProp_t::minor
int minor
Definition hip_runtime_api.h:103

hipDeviceProp_t::gcnArchName
char gcnArchName[256]
AMD GCN Arch Name.
Definition hip_runtime_api.h:121

hipDeviceProp_t::kernelExecTimeoutEnabled
int kernelExecTimeoutEnabled
Run time limit for kernels executed on the device.
Definition hip_runtime_api.h:134

hipDeviceProp_t::hdpMemFlushCntl
unsigned int * hdpMemFlushCntl
Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:129

hipDeviceProp_t::concurrentManagedAccess
int concurrentManagedAccess
Device can coherently access managed memory concurrently with the CPU.
Definition hip_runtime_api.h:149

hipDeviceProp_t::integrated
int integrated
APU vs dGPU.
Definition hip_runtime_api.h:122

hipDeviceProp_t::canMapHostMemory
int canMapHostMemory
Check whether HIP can map host memory.
Definition hip_runtime_api.h:119

hipDeviceProp_t::asicRevision
int asicRevision
Revision of the GPU in this device.
Definition hip_runtime_api.h:146

hipDeviceProp_t::totalGlobalMem
size_t totalGlobalMem
Size of global memory region (in bytes).
Definition hip_runtime_api.h:89

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim
int cooperativeMultiDeviceUnmatchedBlockDim
Definition hip_runtime_api.h:141

hipDeviceProp_t::concurrentKernels
int concurrentKernels
Device can possibly execute multiple kernels concurrently.
Definition hip_runtime_api.h:113

hipDeviceProp_t::isLargeBar
int isLargeBar
1: if it is a large PCI bar device, else 0
Definition hip_runtime_api.h:145

hipDeviceProp_t::gcnArch
int gcnArch
DEPRECATED: use gcnArchName instead.
Definition hip_runtime_api.h:120

hipDeviceProp_t::multiProcessorCount
int multiProcessorCount
Number of multi-processors (compute units).
Definition hip_runtime_api.h:106

hipDeviceProp_t::maxGridSize
int maxGridSize[3]
Max grid dimensions (XYZ).
Definition hip_runtime_api.h:95

hipDeviceProp_t::pciDeviceID
int pciDeviceID
PCI Device ID.
Definition hip_runtime_api.h:116

hipDeviceProp_t::computeMode
int computeMode
Compute mode.
Definition hip_runtime_api.h:109

hipDeviceProp_t::major
int major
Definition hip_runtime_api.h:100

hipDeviceProp_t::warpSize
int warpSize
Warp size.
Definition hip_runtime_api.h:92

hipDeviceProp_t::tccDriver
int tccDriver
1:If device is Tesla device using TCC driver, else 0
Definition hip_runtime_api.h:136

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem
int cooperativeMultiDeviceUnmatchedSharedMem
Definition hip_runtime_api.h:143

hipDeviceProp_t::maxThreadsPerBlock
int maxThreadsPerBlock
Max work items per work group or workgroup max size.
Definition hip_runtime_api.h:93

hipDeviceProp_t::arch
hipDeviceArch_t arch
Architectural feature flags. New for HIP.
Definition hip_runtime_api.h:112

hipDeviceProp_t::managedMemory
int managedMemory
Device supports allocating managed memory on this system.
Definition hip_runtime_api.h:147

hipDeviceProp_t::texturePitchAlignment
size_t texturePitchAlignment
Pitch alignment requirement for texture references bound to pitched memory.
Definition hip_runtime_api.h:133

hipExtent
Definition driver_types.h:358

hipExternalMemoryBufferDesc
Definition hip_runtime_api.h:971

hipExternalMemoryBufferDesc::flags
unsigned int flags
Definition hip_runtime_api.h:974

hipExternalMemoryBufferDesc::offset
unsigned long long offset
Definition hip_runtime_api.h:972

hipExternalMemoryBufferDesc::size
unsigned long long size
Definition hip_runtime_api.h:973

hipExternalMemoryHandleDesc
Definition hip_runtime_api.h:959

hipExternalMemoryHandleDesc::flags
unsigned int flags
Definition hip_runtime_api.h:969

hipExternalMemoryHandleDesc::name
const void * name
Definition hip_runtime_api.h:965

hipExternalMemoryHandleDesc::fd
int fd
Definition hip_runtime_api.h:962

hipExternalMemoryHandleDesc::size
unsigned long long size
Definition hip_runtime_api.h:968

hipExternalMemoryHandleDesc::type
hipExternalMemoryHandleType type
Definition hip_runtime_api.h:960

hipExternalMemoryHandleDesc::handle
void * handle
Definition hip_runtime_api.h:964

hipExternalSemaphoreHandleDesc
Definition hip_runtime_api.h:983

hipExternalSemaphoreHandleDesc::flags
unsigned int flags
Definition hip_runtime_api.h:992

hipExternalSemaphoreHandleDesc::name
const void * name
Definition hip_runtime_api.h:989

hipExternalSemaphoreHandleDesc::type
hipExternalSemaphoreHandleType type
Definition hip_runtime_api.h:984

hipExternalSemaphoreHandleDesc::handle
void * handle
Definition hip_runtime_api.h:988

hipExternalSemaphoreHandleDesc::fd
int fd
Definition hip_runtime_api.h:986

hipExternalSemaphoreSignalParams
Definition hip_runtime_api.h:995

hipExternalSemaphoreSignalParams::value
unsigned long long value
Definition hip_runtime_api.h:998

hipExternalSemaphoreSignalParams::flags
unsigned int flags
Definition hip_runtime_api.h:1005

hipExternalSemaphoreSignalParams::key
unsigned long long key
Definition hip_runtime_api.h:1001

hipExternalSemaphoreWaitParams
Definition hip_runtime_api.h:1011

hipExternalSemaphoreWaitParams::value
unsigned long long value
Definition hip_runtime_api.h:1014

hipExternalSemaphoreWaitParams::timeoutMs
unsigned int timeoutMs
Definition hip_runtime_api.h:1018

hipExternalSemaphoreWaitParams::key
unsigned long long key
Definition hip_runtime_api.h:1017

hipExternalSemaphoreWaitParams::flags
unsigned int flags
Definition hip_runtime_api.h:1022

hipFuncAttributes
Definition hip_runtime_api.h:538

hipFuncAttributes::cacheModeCA
int cacheModeCA
Definition hip_runtime_api.h:540

hipFuncAttributes::binaryVersion
int binaryVersion
Definition hip_runtime_api.h:539

hipFuncAttributes::constSizeBytes
size_t constSizeBytes
Definition hip_runtime_api.h:541

hipFuncAttributes::preferredShmemCarveout
int preferredShmemCarveout
Definition hip_runtime_api.h:546

hipFuncAttributes::sharedSizeBytes
size_t sharedSizeBytes
Definition hip_runtime_api.h:548

hipFuncAttributes::maxDynamicSharedSizeBytes
int maxDynamicSharedSizeBytes
Definition hip_runtime_api.h:543

hipFuncAttributes::ptxVersion
int ptxVersion
Definition hip_runtime_api.h:547

hipFuncAttributes::numRegs
int numRegs
Definition hip_runtime_api.h:545

hipFuncAttributes::localSizeBytes
size_t localSizeBytes
Definition hip_runtime_api.h:542

hipFuncAttributes::maxThreadsPerBlock
int maxThreadsPerBlock
Definition hip_runtime_api.h:544

hipHostNodeParams
Definition hip_runtime_api.h:1108

hipHostNodeParams::fn
hipHostFn_t fn
Definition hip_runtime_api.h:1109

hipHostNodeParams::userData
void * userData
Definition hip_runtime_api.h:1110

hipIpcEventHandle_t
Definition hip_runtime_api.h:528

hipIpcMemHandle_t
Definition hip_runtime_api.h:525

hipKernelNodeParams
Definition hip_runtime_api.h:1112

hipKernelNodeParams::gridDim
dim3 gridDim
Definition hip_runtime_api.h:1116

hipKernelNodeParams::sharedMemBytes
unsigned int sharedMemBytes
Definition hip_runtime_api.h:1118

hipKernelNodeParams::blockDim
dim3 blockDim
Definition hip_runtime_api.h:1113

hipKernelNodeParams::kernelParams
void ** kernelParams
Definition hip_runtime_api.h:1117

hipKernelNodeParams::extra
void ** extra
Definition hip_runtime_api.h:1114

hipKernelNodeParams::func
void * func
Definition hip_runtime_api.h:1115

hipLaunchParams
Definition hip_runtime_api.h:942

hipLaunchParams::sharedMem
size_t sharedMem
Shared memory.
Definition hip_runtime_api.h:947

hipLaunchParams::args
void ** args
Arguments.
Definition hip_runtime_api.h:946

hipLaunchParams::blockDim
dim3 blockDim
Block dimentions.
Definition hip_runtime_api.h:945

hipLaunchParams::gridDim
dim3 gridDim
Grid dimentions.
Definition hip_runtime_api.h:944

hipLaunchParams::func
void * func
Device function symbol.
Definition hip_runtime_api.h:943

hipLaunchParams::stream
hipStream_t stream
Stream identifier.
Definition hip_runtime_api.h:948

hipMemAccessDesc
Definition hip_runtime_api.h:830

hipMemAccessDesc::flags
hipMemAccessFlags flags
Accessibility flags to set.
Definition hip_runtime_api.h:832

hipMemAccessDesc::location
hipMemLocation location
Location on which the accessibility has to change.
Definition hip_runtime_api.h:831

hipMemAllocationProp
Definition hip_runtime_api.h:1214

hipMemAllocationProp::win32HandleMetaData
void * win32HandleMetaData
Metadata for Win32 handles.
Definition hip_runtime_api.h:1218

hipMemAllocationProp::type
hipMemAllocationType type
Memory allocation type.
Definition hip_runtime_api.h:1215

hipMemAllocationProp::gpuDirectRDMACapable
unsigned char gpuDirectRDMACapable
RDMA capable.
Definition hip_runtime_api.h:1221

hipMemAllocationProp::usage
unsigned short usage
Usage.
Definition hip_runtime_api.h:1222

hipMemAllocationProp::requestedHandleType
hipMemAllocationHandleType requestedHandleType
Requested handle type.
Definition hip_runtime_api.h:1216

hipMemAllocationProp::location
hipMemLocation location
Memory location.
Definition hip_runtime_api.h:1217

hipMemAllocationProp::compressionType
unsigned char compressionType
Compression type.
Definition hip_runtime_api.h:1220

hipMemAllocationProp::allocFlags
struct hipMemAllocationProp::@22 allocFlags

hipMemLocation
Definition hip_runtime_api.h:813

hipMemLocation::id
int id
Identifier for the provided location type hipMemLocationType.
Definition hip_runtime_api.h:815

hipMemLocation::type
hipMemLocationType type
Specifies the location type, which describes the meaning of id.
Definition hip_runtime_api.h:814

hipMemPoolProps
Definition hip_runtime_api.h:861

hipMemPoolProps::location
hipMemLocation location
Location where allocations should reside.
Definition hip_runtime_api.h:864

hipMemPoolProps::handleTypes
hipMemAllocationHandleType handleTypes
Handle types that will be supported by allocations from the pool.
Definition hip_runtime_api.h:863

hipMemPoolProps::allocType
hipMemAllocationType allocType
Allocation type. Currently must be specified as hipMemAllocationTypePinned.
Definition hip_runtime_api.h:862

hipMemPoolProps::reserved
unsigned char reserved[64]
Reserved for future use, must be 0.
Definition hip_runtime_api.h:869

hipMemPoolProps::win32SecurityAttributes
void * win32SecurityAttributes
Definition hip_runtime_api.h:868

hipMemPoolPtrExportData
Definition hip_runtime_api.h:874

hipMemPoolPtrExportData::reserved
unsigned char reserved[64]
Definition hip_runtime_api.h:875

hipMemcpy3DParms
Definition driver_types.h:369

hipMemsetParams
Definition hip_runtime_api.h:1120

hipMemsetParams::dst
void * dst
Definition hip_runtime_api.h:1121

hipMemsetParams::value
unsigned int value
Definition hip_runtime_api.h:1125

hipMemsetParams::elementSize
unsigned int elementSize
Definition hip_runtime_api.h:1122

hipMemsetParams::width
size_t width
Definition hip_runtime_api.h:1126

hipMemsetParams::pitch
size_t pitch
Definition hip_runtime_api.h:1124

hipMemsetParams::height
size_t height
Definition hip_runtime_api.h:1123

hipMipmappedArray
Definition driver_types.h:117

hipPitchedPtr
Definition driver_types.h:352

hipPointerAttribute_t
Definition hip_runtime_api.h:172

hipPointerAttribute_t::device
int device
Definition hip_runtime_api.h:174

hipPointerAttribute_t::memoryType
enum hipMemoryType memoryType
Definition hip_runtime_api.h:173

hipPointerAttribute_t::hostPointer
void * hostPointer
Definition hip_runtime_api.h:176

hipPointerAttribute_t::isManaged
int isManaged
Definition hip_runtime_api.h:177

hipPointerAttribute_t::devicePointer
void * devicePointer
Definition hip_runtime_api.h:175

hipPointerAttribute_t::allocationFlags
unsigned allocationFlags
Definition hip_runtime_api.h:178

hipResourceDesc
Definition driver_types.h:258

hipResourceViewDesc
Definition driver_types.h:314

hipTextureDesc
Definition texture_types.h:109

hipUUID
Definition hip_runtime_api.h:76

textureReference
Definition texture_types.h:88

surface_types.h
Defines surface types for HIP runtime.

hipSurfaceObject_t
struct __hip_surface * hipSurfaceObject_t
Definition surface_types.h:34

texture_types.h

hipTextureObject_t
struct __hip_texture * hipTextureObject_t
Definition texture_types.h:63

hipTextureAddressMode
hipTextureAddressMode
Definition texture_types.h:68

hipTextureFilterMode
hipTextureFilterMode
Definition texture_types.h:78

hipKernelNodeAttrValue
Definition hip_runtime_api.h:1150

hipKernelNodeAttrValue::cooperative
int cooperative
Definition hip_runtime_api.h:1152

hipKernelNodeAttrValue::accessPolicyWindow
hipAccessPolicyWindow accessPolicyWindow
Definition hip_runtime_api.h:1151