include/hip/hip_runtime_api.h Source File

include/hip/hip_runtime_api.h Source File#

HIP Runtime API Reference: include/hip/hip_runtime_api.h Source File
hip_runtime_api.h
Go to the documentation of this file.
1/*
2 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
3 *
4 * SPDX-License-Identifier: MIT
5 */
6
15#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H
16#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H
17
18#if __cplusplus
19#include <climits>
20#include <cstdint>
21#include <cstdlib>
22#include <utility>
23#else
24#include <limits.h>
25#include <stdint.h>
26#include <stdlib.h>
27#endif
28
29#include <hip/hip_version.h>
30#include <hip/hip_common.h>
31#include <hip/linker_types.h>
32
33#if HIP_TARGET_API_VERSION > HIP_API_VERSION
34# error "HIP_TARGET_API_VERSION is newer than the installed HIP headers"
35#endif
36
37enum {
42};
43// hack to get these to show up in Doxygen:
53typedef struct {
54 // 32-bit Atomics
55 unsigned hasGlobalInt32Atomics : 1;
57 unsigned hasSharedInt32Atomics : 1;
59 unsigned hasFloatAtomicAdd : 1;
60
61 // 64-bit Atomics
62 unsigned hasGlobalInt64Atomics : 1;
63 unsigned hasSharedInt64Atomics : 1;
64
65 // Doubles
66 unsigned hasDoubles : 1;
67
68 // Warp cross-lane operations
69 unsigned hasWarpVote : 1;
70 unsigned hasWarpBallot : 1;
71 unsigned hasWarpShuffle : 1;
72 unsigned hasFunnelShift : 1;
73
74 // Sync
75 unsigned hasThreadFenceSystem : 1;
76 unsigned hasSyncThreadsExt : 1;
77
78 // Misc
79 unsigned hasSurfaceFuncs : 1;
80 unsigned has3dGrid : 1;
81 unsigned hasDynamicParallelism : 1;
83
84typedef struct hipUUID_t {
85 char bytes[16];
86} hipUUID;
87
88//---
89// Common headers for both NVCC and HIP-Clang paths:
90
91// Ignoring error-code return values from hip APIs is discouraged. On C++17,
92// we can make that yield a warning
93#if __cplusplus >= 201703L
94#define __HIP_NODISCARD [[nodiscard]]
95#else
96#define __HIP_NODISCARD
97#endif
98
99#if defined(_MSC_VER) && (_MSC_VER >= 1800)
100#define UINT32_BASE :uint32_t
101#else
102#define UINT32_BASE
103#endif
104
109// Developer note - when updating these, update the hipErrorName and hipErrorString functions in
110// NVCC and HIP-Clang paths Also update the hipCUDAErrorTohipError function in NVCC path.
111
117 // Deprecated
120 // Deprecated
142 // Deprecated
164 // Deprecated
227 // HSA Runtime Error Codes start here.
235 hipErrorTbd
237
238#undef __HIP_NODISCARD
239#undef UINT32_BASE
240
241/*
242 Versioning struct. Because each public API must use the versioned struct to
243 ensure ABI compatibility, we must typedef the actual struct name here.
244*/
245
246#if HIP_TARGET_API_VERSION < 600
247
248#include <hip/hip_deprecated.h>
249// Legacy version, HIP_ABI_IMPL is on the latest version, so it must not see this.
251// Dummy struct for hip_prof_str.h
253
254#endif
255
256#if HIP_TARGET_API_VERSION >= 600
257// Latest version.
258
263typedef struct hipDeviceProp_t {
264 char name[256];
266 char luid[8];
267 unsigned int luidDeviceNodeMask;
272 size_t memPitch;
276 int maxGridSize[3];
280 int major;
284 int minor;
376 unsigned int
383 int reserved[63];
384
385 int hipReserved[32];
386
387 /* HIP Only struct members */
388 char gcnArchName[256];
393 unsigned int* hdpMemFlushCntl;
394 unsigned int* hdpRegFlushCntl;
410
411// Latest version, HIP_ABI_IMPL should see this.
413#endif
414
435
439typedef struct hipPointerAttribute_t {
445 unsigned allocationFlags; /* flags specified when memory was allocated*/
446 /* peers? */
448
455
605
608
654
657 // Extended attributes for vendors
659
660// Flags that can be used with hipGetProcAddress.
664#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0
665
667#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1
668
671#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2
672
678
685
698
704
711
723
724#if defined(__HIP_PLATFORM_AMD__) && !defined(__HIP_PLATFORM_NVIDIA__)
725
726#ifndef GENERIC_GRID_LAUNCH
727#define GENERIC_GRID_LAUNCH 1
728#endif
729#include <hip/amd_detail/host_defines.h>
730#include <hip/driver_types.h>
731#include <hip/texture_types.h>
732#include <hip/surface_types.h>
733
734#if defined(HIP_ABI_IMPL)
735// Nothing is deprecated if we are implementing the HIP ABI.
736#define HIP_DEPRECATED(x)
737#elif defined(_MSC_VER)
738#define HIP_DEPRECATED(msg) __declspec(deprecated(msg))
739#else // !defined(_MSC_VER)
740#define HIP_DEPRECATED(msg) __attribute__((deprecated(msg)))
741#endif // !defined(_MSC_VER)
742
743#define HIP_DEPRECATED_MSG \
744 "This API is marked as deprecated and might not be supported in future releases. For more " \
745 "details please refer " \
746 "https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md"
747#define HIP_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)
748#define HIP_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)
749#define HIP_LAUNCH_PARAM_END ((void*)0x03)
750#ifdef __cplusplus
751#define __dparm(x) = x
752#else
753#define __dparm(x)
754#endif
755#ifdef __GNUC__
756#pragma GCC visibility push(default)
757#endif
758#ifdef __cplusplus
759namespace hip_impl {
761} // namespace hip_impl
762#endif
763// Structure definitions:
764#ifdef __cplusplus
765extern "C" {
766#endif
767//---
768// API-visible structures
769typedef struct ihipCtx_t* hipCtx_t;
770typedef struct ihipExecutionCtx_t* hipExecutionCtx_t;
771typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t;
790
791#define HIP_RESOURCE_ABI_BYTES 40
792
793typedef struct hipDevSmResource {
794 unsigned int smCount;
795 unsigned int minSmPartitionSize;
797 unsigned int flags;
799
805
809
810typedef struct hipDevResource_st {
812 unsigned char _internal_padding[92];
813 union {
817 unsigned char _oversize[HIP_RESOURCE_ABI_BYTES];
818 };
819 struct hipDevResource_st* nextResource;
821
822typedef struct hipDevSmResourceGroupParams_st {
823 unsigned int smCount;
824 unsigned int coscheduledSmCount;
826 unsigned int flags;
827 unsigned int reserved[12];
829
830// Note many APIs also use integer deviceIds as an alternative to the device pointer:
831typedef int hipDevice_t;
843typedef struct ihipStream_t* hipStream_t;
844#define hipIpcMemLazyEnablePeerAccess 0x01
845#define HIP_IPC_HANDLE_SIZE 64
846typedef struct hipIpcMemHandle_st {
847 char reserved[HIP_IPC_HANDLE_SIZE];
849typedef struct hipIpcEventHandle_st {
850 char reserved[HIP_IPC_HANDLE_SIZE];
852typedef struct hipMemFabricHandle_st {
853 unsigned char data[HIP_IPC_HANDLE_SIZE];
855typedef struct ihipModule_t* hipModule_t;
856typedef struct ihipModuleSymbol_t* hipFunction_t;
857typedef struct ihipLinkState_t* hipLinkState_t;
858typedef struct ihipLibrary_t* hipLibrary_t;
859typedef struct ihipKernel_t* hipKernel_t;
863typedef struct ihipMemPoolHandle_t* hipMemPool_t;
864
877typedef struct ihipEvent_t* hipEvent_t;
878
906
910// Flags that can be used with hipStreamCreateWithFlags.
912#define hipStreamDefault 0x00
913
915#define hipStreamNonBlocking 0x01
916
917// Flags that can be used with hipEventCreateWithFlags.
919#define hipEventDefault 0x0
920
922#define hipEventBlockingSync 0x1
923
925#define hipEventDisableTiming 0x2
926
928#define hipEventInterprocess 0x4
929
930// Flags that can be used with hipEventRecordWithFlags.
932#define hipEventRecordDefault 0x00
933
935#define hipEventRecordExternal 0x01
936
937//Flags that can be used with hipStreamWaitEvent.
939#define hipEventWaitDefault 0x00
940
942#define hipEventWaitExternal 0x01
943
952#define hipEventDisableSystemFence 0x20000000
953
956#define hipEventReleaseToDevice 0x40000000
957
960#define hipEventReleaseToSystem 0x80000000
961
962// Flags that can be used with hipGetDriverEntryPoint.
966#define hipEnableDefault 0x0
967
969#define hipEnableLegacyStream 0x1
970
973#define hipEnablePerThreadDefaultStream 0x2
974
975// Flags that can be used with hipHostMalloc/hipHostAlloc.
977#define hipHostAllocDefault 0x0
978
981#define hipHostMallocDefault 0x0
982
984#define hipHostAllocPortable 0x1
985
988#define hipHostMallocPortable 0x1
989
992#define hipHostAllocMapped 0x2
993
997#define hipHostMallocMapped 0x2
998
1004#define hipHostAllocWriteCombined 0x4
1005
1012#define hipHostMallocWriteCombined 0x4
1013
1019#define hipHostMallocUncached 0x10000000
1020#define hipHostAllocUncached hipHostMallocUncached
1021
1026#define hipHostMallocNumaUser 0x20000000
1027
1029#define hipHostMallocCoherent 0x40000000
1030
1032#define hipHostMallocNonCoherent 0x80000000
1033
1035#define hipMemAttachGlobal 0x01
1036
1038#define hipMemAttachHost 0x02
1039
1041#define hipMemAttachSingle 0x04
1042
1043#define hipDeviceMallocDefault 0x0
1044
1046#define hipDeviceMallocFinegrained 0x1
1047
1049#define hipMallocSignalMemory 0x2
1050
1052#define hipDeviceMallocUncached 0x3
1053
1055#define hipDeviceMallocContiguous 0x4
1056
1057// Flags that can be used with hipHostRegister.
1059#define hipHostRegisterDefault 0x0
1060
1062#define hipHostRegisterPortable 0x1
1063
1066#define hipHostRegisterMapped 0x2
1067
1072#define hipHostRegisterIoMemory 0x4
1073
1075#define hipHostRegisterReadOnly 0x08
1076
1078#define hipExtHostRegisterCoarseGrained 0x8
1079
1083#define hipExtHostRegisterUncached 0x80000000
1084
1086#define hipDeviceScheduleAuto 0x0
1087
1090#define hipDeviceScheduleSpin 0x1
1091
1094#define hipDeviceScheduleYield 0x2
1095#define hipDeviceScheduleBlockingSync 0x4
1096#define hipDeviceScheduleMask 0x7
1097#define hipDeviceMapHost 0x8
1098#define hipDeviceLmemResizeToMax 0x10
1100#define hipInitDeviceFlagsAreValid 0x1
1102#define hipArrayDefault 0x00
1103#define hipArrayLayered 0x01
1104#define hipArraySurfaceLoadStore 0x02
1105#define hipArrayCubemap 0x04
1106#define hipArrayTextureGather 0x08
1107#define hipOccupancyDefault 0x00
1108#define hipOccupancyDisableCachingOverride 0x01
1109#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01
1110#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02
1111#define hipCpuDeviceId ((int)-1)
1112#define hipInvalidDeviceId ((int)-2)
1113// Flags that can be used with hipExtLaunch Set of APIs.
1115#define hipExtAnyOrderLaunch 0x01
1116// Flags to be used with hipStreamWaitValue32 and hipStreamWaitValue64.
1117#define hipStreamWaitValueGte 0x0
1118#define hipStreamWaitValueEq 0x1
1119#define hipStreamWaitValueAnd 0x2
1120#define hipStreamWaitValueNor 0x3
1121// Flags to be used with hipStreamWriteValue32 and hipStreamWriteValue64.
1122#define hipStreamWriteValueDefault 0x0
1123#define hipExtStreamWriteValueIncrement 0x1000
1124#define hipExtStreamWriteValueDecrement 0x1001
1125
1135
1172typedef union hipStreamBatchMemOpParams_union {
1177 union {
1178 uint32_t value;
1179 uint64_t value64;
1180 };
1181 unsigned int flags;
1183 } waitValue;
1187 union {
1188 uint32_t value;
1189 uint64_t value64;
1190 };
1191 unsigned int flags;
1193 } writeValue;
1202 uint64_t pad[6];
1204
1238
1239// Stream per thread
1241#define hipStreamPerThread ((hipStream_t)2)
1242
1243#define hipStreamLegacy ((hipStream_t)1)
1244
1245// Indicates that the external memory object is a dedicated resource
1246#define hipExternalMemoryDedicated 0x1
1296
1355
1420 unsigned char reserved[64];
1422
1459typedef struct dim3 {
1460 uint32_t x;
1461 uint32_t y;
1462 uint32_t z;
1463#ifdef __cplusplus
1464 constexpr __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1)
1465 : x(_x), y(_y), z(_z) {};
1466#endif
1467} dim3;
1471typedef struct hipLaunchParams_t {
1472 void* func;
1475 void** args;
1476 size_t sharedMem;
1482typedef struct hipFunctionLaunchParams_t {
1484 unsigned int gridDimX;
1485 unsigned int gridDimY;
1486 unsigned int gridDimZ;
1487 unsigned int blockDimX;
1488 unsigned int blockDimY;
1489 unsigned int blockDimZ;
1490 unsigned int sharedMemBytes;
1504typedef struct hipExternalMemoryHandleDesc_st {
1506 union {
1507 int fd;
1508 struct {
1509 void* handle;
1510 const void* name;
1511 } win32;
1512 const void* nvSciBufObject;
1513 } handle;
1514 unsigned long long size;
1515 unsigned int flags;
1516 unsigned int reserved[16];
1518typedef struct hipExternalMemoryBufferDesc_st {
1519 unsigned long long offset;
1520 unsigned long long size;
1521 unsigned int flags;
1522 unsigned int reserved[16];
1524typedef struct hipExternalMemoryMipmappedArrayDesc_st {
1525 unsigned long long offset;
1528 unsigned int flags;
1529 unsigned int numLevels;
1544typedef struct hipExternalSemaphoreHandleDesc_st {
1546 union {
1547 int fd;
1548 struct {
1549 void* handle;
1550 const void* name;
1551 } win32;
1552 const void* NvSciSyncObj;
1553 } handle;
1554 unsigned int flags;
1555 unsigned int reserved[16];
1558typedef struct hipExternalSemaphoreSignalParams_st {
1559 struct {
1560 struct {
1561 unsigned long long value;
1562 } fence;
1563 union {
1564 void* fence;
1565 unsigned long long reserved;
1566 } nvSciSync;
1567 struct {
1568 unsigned long long key;
1569 } keyedMutex;
1570 unsigned int reserved[12];
1571 } params;
1572 unsigned int flags;
1573 unsigned int reserved[16];
1578typedef struct hipExternalSemaphoreWaitParams_st {
1579 struct {
1580 struct {
1581 unsigned long long value;
1582 } fence;
1583 union {
1584 void* fence;
1585 unsigned long long reserved;
1586 } nvSciSync;
1587 struct {
1588 unsigned long long key;
1589 unsigned int timeoutMs;
1590 } keyedMutex;
1591 unsigned int reserved[10];
1592 } params;
1593 unsigned int flags;
1594 unsigned int reserved[16];
1596
1601void __hipGetPCH(const char** pch, unsigned int* size);
1602
1615
1616typedef struct _hipGraphicsResource hipGraphicsResource;
1617
1619
1623typedef struct ihipGraph* hipGraph_t;
1627typedef struct hipGraphNode* hipGraphNode_t;
1631typedef struct hipGraphExec* hipGraphExec_t;
1632
1636typedef struct hipUserObject* hipUserObject_t;
1637
1638
1660
1661typedef void (*hipHostFn_t)(void* userData);
1674typedef struct hipMemsetParams {
1675 void* dst;
1676 unsigned int elementSize;
1677 size_t height;
1678 size_t pitch;
1679 unsigned int value;
1680 size_t width;
1682
1692
1701
1702/***
1703 * Specifies access policy for a window, a contiguous extent of memory
1704 * beginning at base_ptr and ending at base_ptr + num_bytes.
1705 */
1713
1718 unsigned char default_;
1719 unsigned char remote;
1721
1729
1740/* Cluster scheduling policies passed to hipFuncSetAttribute
1741*/
1748
1756
1771
1777#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2
1778
1794
1811
1812
1853
1857#define hipStreamAttrID hipLaunchAttributeID
1858#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow
1859#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy
1860#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap
1861#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain
1862#define hipStreamAttributePriority hipLaunchAttributePriority
1863
1864#define hipStreamAttrValue hipLaunchAttributeValue
1865
1869#define hipKernelNodeAttrID hipLaunchAttributeID
1870#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow
1871#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative
1872#define hipKernelNodeAttributePriority hipLaunchAttributePriority
1873
1877#define hipKernelNodeAttrValue hipLaunchAttributeValue
1878
1882#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative
1883
1884#define hipDrvLaunchAttributeID hipLaunchAttributeID
1885#define hipDrvLaunchAttributeValue hipLaunchAttributeValue
1886#define hipDrvLaunchAttribute hipLaunchAttribute
1887
1905
1917
1922
1936
1940
1951
1970
1985
1996
1997
2001typedef struct hipMemAllocationProp {
2003 union {
2004 hipMemAllocationHandleType requestedHandleType;
2005 hipMemAllocationHandleType requestedHandleTypes;
2006 };
2009 struct {
2010 unsigned char compressionType;
2011 unsigned char gpuDirectRDMACapable;
2012 unsigned short usage;
2015
2027
2039
2043typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;
2044
2052
2059
2067
2075
2079typedef struct hipArrayMapInfo {
2081 union {
2082 hipMipmappedArray mipmap;
2086 union {
2087 struct {
2088 unsigned int
2089 level;
2090 unsigned int
2091 layer;
2092 unsigned int offsetX;
2093 unsigned int offsetY;
2094 unsigned int offsetZ;
2095 unsigned int extentWidth;
2096 unsigned int extentHeight;
2097 unsigned int extentDepth;
2098 } sparseLevel;
2099 struct {
2100 unsigned int
2101 layer;
2102 unsigned long long offset;
2103 unsigned long long size;
2104 } miptail;
2111 unsigned long long offset;
2112 unsigned int deviceBitMask;
2113 unsigned int flags;
2114 unsigned int reserved[2];
2116
2125
2133
2140
2147
2154
2158typedef struct hipGraphNodeParams {
2161 union {
2162 long long reserved1[29];
2163 hipKernelNodeParams kernel;
2164 hipMemcpyNodeParams memcpy;
2165 hipMemsetParams memset;
2166 hipHostNodeParams host;
2168 hipEventWaitNodeParams eventWait;
2169 hipEventRecordNodeParams eventRecord;
2174 };
2175
2176 long long reserved2;
2178
2182#define hipGraphKernelNodePortDefault 0
2183
2187#define hipGraphKernelNodePortLaunchCompletion 2
2188
2194#define hipGraphKernelNodePortProgrammatic 1
2195
2200
2201typedef struct hipGraphEdgeData {
2202 unsigned char
2210 unsigned char reserved[5];
2211 unsigned char
2213 unsigned char type;
2215
2216
2220typedef struct hipLaunchAttribute_st {
2222 char pad[8 - sizeof(hipLaunchAttributeID)];
2223 union {
2226 };
2228
2240
2244typedef struct HIP_LAUNCH_CONFIG_st {
2245 unsigned int gridDimX;
2246 unsigned int gridDimY;
2247 unsigned int gridDimZ;
2248 unsigned int blockDimX;
2249 unsigned int blockDimY;
2250 unsigned int blockDimZ;
2251 unsigned int sharedMemBytes;
2254 unsigned int numAttrs;
2256
2264
2272
2280
2281
2282// Doxygen end group GlobalDefs
2314// TODO-ctx - more description on error codes.
2315hipError_t hipInit(unsigned int flags);
2316
2358
2367hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device);
2376hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device);
2402hipError_t hipDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, hipDevice_t device);
2413 int dstDevice);
2422hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device);
2430hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId);
2439// doxygen end initialization
2515hipError_t hipSetValidDevices(int* device_arr, int len);
2633
2634// hipDeviceProp_t and hipGetDeviceProperties/hipChooseDevice are versioned.
2635// See HIP_TARGET_API_VERSION in hip_common.h.
2636
2637#if HIP_TARGET_API_VERSION >= 600
2638
2640
2654static inline hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId) {
2655 return hipGetDevicePropertiesR0600(prop, deviceId);
2656}
2657
2658#endif
2659
2660
2678 int device);
2716hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit);
2740hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value);
2760hipError_t hipGetDeviceFlags(unsigned int* flags);
2805
2806#if HIP_TARGET_API_VERSION >= 600
2808
2817static inline hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop) {
2818 return hipChooseDeviceR0600(device, prop);
2819}
2820
2821#endif
2822
2847hipError_t hipInitDevice(int device, unsigned int deviceFlags, unsigned int flags);
2848
2862hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype,
2863 uint32_t* hopcount);
2864// TODO: implement IPC apis
2924hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);
2943
2961
2981
2982// end doxygen Device
3006hipError_t hipFuncSetAttribute(const void* func, hipFuncAttribute attr, int value);
3007
3024
3052 int device);
3053
3063
3097
3124// doxygen end execution
3147
3160
3180const char* hipGetErrorName(hipError_t hip_error);
3189const char* hipGetErrorString(hipError_t hipError);
3199hipError_t hipDrvGetErrorName(hipError_t hipError, const char** errorString);
3209hipError_t hipDrvGetErrorString(hipError_t hipError, const char** errorString);
3210// end doxygen Error
3290hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority);
3310hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority);
3394hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags __dparm(0));
3404hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags);
3414hipError_t hipStreamGetId(hipStream_t stream, unsigned long long* streamId);
3460 const uint32_t* cuMask);
3473hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t* cuMask);
3477typedef void (*hipStreamCallback_t)(hipStream_t stream, hipError_t status, void* userData);
3494 unsigned int flags);
3495
3504 const hipStreamAttrValue* value);
3505
3514 hipStreamAttrValue* value_out);
3515
3523
3524// end doxygen Stream
3572hipError_t hipStreamWaitValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags,
3573 uint32_t mask __dparm(0xFFFFFFFF));
3574
3611hipError_t hipStreamWaitValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags,
3612 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));
3613
3634hipError_t hipStreamWriteValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags);
3655hipError_t hipStreamWriteValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags);
3656
3676hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,
3677 hipStreamBatchMemOpParams* paramArray, unsigned int flags);
3678
3697 const hipGraphNode_t* dependencies, size_t numDependencies,
3698 const hipBatchMemOpNodeParams* nodeParams);
3699
3721 hipBatchMemOpNodeParams* nodeParams_out);
3722
3741 hipBatchMemOpNodeParams* nodeParams);
3742
3763 const hipBatchMemOpNodeParams* nodeParams);
3764
3765// end doxygen Stream Memory Operations
3851 unsigned int flags __dparm(0));
3882#ifdef __cplusplus
3884#else
3886#endif
3969// end doxygen Events
4001 hipDeviceptr_t ptr);
4002
4003
4055hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute* attributes,
4056 void** data, hipDeviceptr_t ptr);
4079 const hipExternalSemaphoreHandleDesc* semHandleDesc);
4094 const hipExternalSemaphoreSignalParams* paramsArray,
4095 unsigned int numExtSems, hipStream_t stream);
4110 const hipExternalSemaphoreWaitParams* paramsArray,
4111 unsigned int numExtSems, hipStream_t stream);
4124
4135 const hipExternalMemoryHandleDesc* memHandleDesc);
4147 const hipExternalMemoryBufferDesc* bufferDesc);
4172 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,
4173 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);
4174// end of external resource
4191hipError_t hipMalloc(void** ptr, size_t size);
4211hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags);
4212
4213
4236HIP_DEPRECATED("use hipHostMalloc instead")
4237hipError_t hipMallocHost(void** ptr, size_t size);
4250HIP_DEPRECATED("use hipHostMalloc instead")
4251hipError_t hipMemAllocHost(void** ptr, size_t size);
4252// end doxygen deprecated management memory
4289hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags);
4324hipError_t hipMallocManaged(void** dev_ptr, size_t size,
4325 unsigned int flags __dparm(hipMemAttachGlobal));
4338hipError_t hipMemPrefetchAsync(const void* dev_ptr, size_t count, int device,
4339 hipStream_t stream __dparm(0));
4353hipError_t hipMemPrefetchAsync_v2(const void* dev_ptr, size_t count, hipMemLocation location,
4354 unsigned int flags, hipStream_t stream __dparm(0));
4355
4372hipError_t hipMemPrefetchBatchAsync(void** dev_ptrs, size_t* sizes, size_t count,
4373 hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs,
4374 size_t num_prefetch_locs, unsigned long long flags,
4375 hipStream_t stream);
4400hipError_t hipMemDiscardBatchAsync(void** dev_ptrs, size_t* sizes, size_t count,
4401 unsigned long long flags, hipStream_t stream);
4422hipError_t hipDrvMemDiscardBatchAsync(hipDeviceptr_t* dptrs, size_t* sizes, size_t count,
4423 unsigned long long flags, hipStream_t stream);
4453hipError_t hipMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count,
4454 hipMemLocation* prefetchLocs,
4455 size_t* prefetchLocIdxs,
4456 size_t numPrefetchLocs,
4457 unsigned long long flags, hipStream_t stream);
4477 hipMemLocation* prefetchLocs,
4478 size_t* prefetchLocIdxs,
4479 size_t numPrefetchLocs,
4480 unsigned long long flags, hipStream_t stream);
4481
4482// Deprecated since 800. Introduced in 700.
4483#if (HIP_TARGET_API_VERSION >= 700 && HIP_TARGET_API_VERSION < 800) || defined(HIP_ABI_IMPL)
4484
4504hipError_t hipMemAdvise_v2(const void* dev_ptr, size_t count, hipMemoryAdvise advice,
4505 hipMemLocation location);
4506
4507#endif
4508
4509// Deprecated since 800.
4510#if HIP_TARGET_API_VERSION < 800 || defined(HIP_ABI_IMPL)
4511
4531hipError_t hipMemAdvise(const void* dev_ptr, size_t count, hipMemoryAdvise advice, int device);
4532
4533#endif
4534
4535// Latest
4536#if HIP_TARGET_API_VERSION >= 800 && !defined(HIP_ABI_IMPL)
4537
4538hipError_t hipMemAdvise_v2(const void* dev_ptr, size_t count, hipMemoryAdvise advice,
4539 hipMemLocation location);
4540
4561static inline hipError_t hipMemAdvise(const void* dev_ptr, size_t count, hipMemoryAdvise advice,
4562 hipMemLocation location) {
4563 return hipMemAdvise_v2(dev_ptr, count, advice, location);
4564}
4565
4566#endif
4567
4582hipError_t hipMemRangeGetAttribute(void* data, size_t data_size, hipMemRangeAttribute attribute,
4583 const void* dev_ptr, size_t count);
4600hipError_t hipMemRangeGetAttributes(void** data, size_t* data_sizes,
4601 hipMemRangeAttribute* attributes, size_t num_attributes,
4602 const void* dev_ptr, size_t count);
4618hipError_t hipStreamAttachMemAsync(hipStream_t stream, void* dev_ptr, size_t length __dparm(0),
4619 unsigned int flags __dparm(hipMemAttachSingle));
4620// end doxygen Managed Memory
4679hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipStream_t stream);
4703hipError_t hipFreeAsync(void* dev_ptr, hipStream_t stream);
4730hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);
4826 size_t count);
4846 hipMemLocation* location);
4932hipError_t hipMallocFromPoolAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool,
4933 hipStream_t stream);
4960 hipMemAllocationHandleType handle_type,
4961 unsigned int flags);
4985 hipMemAllocationHandleType handle_type,
4986 unsigned int flags);
5034 hipMemPoolPtrExportData* export_data);
5059
5073
5074// Doxygen end of Stream Ordered Memory Allocator
5098hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags);
5110hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags);
5120hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr);
5170hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags);
5198hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height);
5221hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height,
5222 unsigned int elementSizeBytes);
5295hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);
5313hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,
5314 hipStream_t stream);
5332hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, const void* src, size_t sizeBytes);
5350hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes);
5387hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset,
5388 size_t ByteCount);
5407hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice,
5408 size_t ByteCount);
5409
5429hipError_t hipMemcpyAtoA(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray,
5430 size_t srcOffset, size_t ByteCount);
5449hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, const void* src, size_t sizeBytes,
5450 hipStream_t stream);
5469hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream);
5489 hipStream_t stream);
5509hipError_t hipMemcpyAtoHAsync(void* dstHost, hipArray_t srcArray, size_t srcOffset,
5510 size_t ByteCount, hipStream_t stream);
5530hipError_t hipMemcpyHtoAAsync(hipArray_t dstArray, size_t dstOffset, const void* srcHost,
5531 size_t ByteCount, hipStream_t stream);
5551 const char* name);
5552
5562hipError_t hipGetSymbolAddress(void** devPtr, const void* symbol);
5563
5564
5574hipError_t hipGetSymbolSize(size_t* size, const void* symbol);
5575
5595hipError_t hipGetProcAddress(const char* symbol, void** pfn, int hipVersion, uint64_t flags,
5596 hipDriverProcAddressQueryResult* symbolStatus);
5597
5619hipError_t hipMemcpyToSymbol(const void* symbol, const void* src, size_t sizeBytes,
5620 size_t offset __dparm(0),
5622
5636hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src, size_t sizeBytes,
5637 size_t offset, hipMemcpyKind kind, hipStream_t stream __dparm(0));
5638
5651hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol, size_t sizeBytes,
5652 size_t offset __dparm(0),
5654
5668hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol, size_t sizeBytes, size_t offset,
5669 hipMemcpyKind kind, hipStream_t stream __dparm(0));
5698hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,
5699 hipStream_t stream __dparm(0));
5709hipError_t hipMemset(void* dst, int value, size_t sizeBytes);
5719hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count);
5735hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count,
5736 hipStream_t stream __dparm(0));
5746hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count);
5762hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count,
5763 hipStream_t stream __dparm(0));
5773hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count);
5789hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0));
5805hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count,
5806 hipStream_t stream __dparm(0));
5817hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height);
5829hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,
5830 hipStream_t stream __dparm(0));
5839hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent);
5849hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent,
5850 hipStream_t stream __dparm(0));
5851
5863hipError_t hipMemsetD2D8(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width,
5864 size_t height);
5877hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value,
5878 size_t width, size_t height, hipStream_t stream __dparm(0));
5879
5891hipError_t hipMemsetD2D16(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width,
5892 size_t height);
5905hipError_t hipMemsetD2D16Async(hipDeviceptr_t dst, size_t dstPitch, unsigned short value,
5906 size_t width, size_t height, hipStream_t stream __dparm(0));
5918hipError_t hipMemsetD2D32(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width,
5919 size_t height);
5932hipError_t hipMemsetD2D32Async(hipDeviceptr_t dst, size_t dstPitch, unsigned int value,
5933 size_t width, size_t height, hipStream_t stream __dparm(0));
5934
5951hipError_t hipMemGetInfo(size_t* free, size_t* total);
5952
5978 size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault));
6043 struct hipExtent extent, unsigned int flags);
6128hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
6129 size_t height, hipMemcpyKind kind);
6191hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
6192 size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));
6210hipError_t hipMemcpy2DToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,
6211 size_t spitch, size_t width, size_t height, hipMemcpyKind kind);
6230hipError_t hipMemcpy2DToArrayAsync(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,
6231 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,
6232 hipStream_t stream __dparm(0));
6251hipError_t hipMemcpy2DArrayToArray(hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst,
6252 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,
6253 size_t width, size_t height, hipMemcpyKind kind);
6273hipError_t hipMemcpyToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,
6274 size_t count, hipMemcpyKind kind);
6294hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,
6295 size_t count, hipMemcpyKind kind);
6313hipError_t hipMemcpy2DFromArray(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset,
6314 size_t hOffset, size_t width, size_t height, hipMemcpyKind kind);
6333hipError_t hipMemcpy2DFromArrayAsync(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset,
6334 size_t hOffset, size_t width, size_t height,
6335 hipMemcpyKind kind, hipStream_t stream __dparm(0));
6349hipError_t hipMemcpyAtoH(void* dst, hipArray_t srcArray, size_t srcOffset, size_t count);
6363hipError_t hipMemcpyHtoA(hipArray_t dstArray, size_t dstOffset, const void* srcHost, size_t count);
6423
6439hipError_t hipMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count,
6440 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,
6441 size_t* failIdx, hipStream_t stream __dparm(0));
6442
6469hipError_t hipExtMemcpyBatchAsync(void** dsts, void** srcs,
6470 size_t* sizes, size_t* sizesDst,
6471 hipExtMemcpyWait* waits,
6472 hipExtMemcpySignal* signals,
6473 size_t count,
6474 hipExtMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,
6475 hipStream_t stream __dparm(0));
6476
6489hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp* opList, size_t* failIdx,
6490 unsigned long long flags, hipStream_t stream __dparm(0));
6491
6514hipError_t hipMemcpyWithAttributesAsync(void* dst, const void* src, size_t size,
6515 hipMemcpyAttributes* attr,
6516 hipStream_t stream __dparm(0));
6517
6536 hipStream_t stream __dparm(0));
6537
6547
6557
6574 hipMipmappedArray_t mipmap, hipDevice_t device);
6575// doxygen end Memory
6610hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId);
6625hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags);
6637
6649hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId,
6650 size_t sizeBytes);
6663hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice,
6664 size_t sizeBytes, hipStream_t stream __dparm(0));
6665
6666// doxygen end PeerToPeer
6688 hipDevResourceType type);
6689
6706 const hipDevResource* input, hipDevResource* remainder,
6707 unsigned int flags, unsigned int minCount);
6708
6725hipError_t hipDevSmResourceSplit(hipDevResource* result, unsigned int nbGroups,
6726 const hipDevResource* input, hipDevResource* remainder,
6727 unsigned int flags,
6728 hipDevSmResourceGroupParams* groupParams);
6729
6741 unsigned int nbResources);
6742
6755 unsigned int flags);
6756
6765
6775
6787 unsigned int flags, int priority);
6788
6799 hipDevResourceType type);
6800
6810
6819hipError_t hipExecutionCtxGetId(hipExecutionCtx_t ctx, unsigned long long* ctxId);
6820
6831 hipDevResourceType type);
6832
6842
6851
6903hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);
7017hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int* apiVersion);
7120hipError_t hipCtxGetFlags(unsigned int* flags);
7144hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags);
7166
7183hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active);
7248// doxygen end Context Management
7272hipError_t hipModuleLoadFatBinary(hipModule_t* module, const void* fatbin);
7286hipError_t hipModuleLoad(hipModule_t* module, const char* fname);
7314hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname);
7315
7326
7337hipError_t hipModuleEnumerateFunctions(hipFunction_t* functions, unsigned int numFunctions,
7338 hipModule_t mod);
7339
7368 hipDevice_t dev);
7369
7383hipError_t hipLibraryLoadData(hipLibrary_t* library, const void* code, hipJitOption* jitOptions,
7384 void** jitOptionsValues, unsigned int numJitOptions,
7385 hipLibraryOption* libraryOptions, void** libraryOptionValues,
7386 unsigned int numLibraryOptions);
7387
7401hipError_t hipLibraryLoadFromFile(hipLibrary_t* library, const char* fileName,
7402 hipJitOption* jitOptions, void** jitOptionsValues,
7403 unsigned int numJitOptions, hipLibraryOption* libraryOptions,
7404 void** libraryOptionValues, unsigned int numLibraryOptions);
7405
7413
7422hipError_t hipLibraryGetKernel(hipKernel_t* pKernel, hipLibrary_t library, const char* name);
7423
7432
7447hipError_t hipLibraryGetGlobal(void** dptr, size_t* bytes, hipLibrary_t library,
7448 const char* name);
7449
7466hipError_t hipLibraryGetManaged(void** dptr, size_t* bytes, hipLibrary_t library,
7467 const char* name);
7468
7488
7497hipError_t hipLibraryEnumerateKernels(hipKernel_t* kernels, unsigned int numKernels,
7498 hipLibrary_t library);
7499
7508
7516hipError_t hipKernelGetName(const char** name, hipKernel_t kernel);
7517
7528hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t* paramOffset,
7529 size_t* paramSize);
7530
7539hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func);
7559hipError_t hipGetFuncBySymbol(hipFunction_t* functionPtr, const void* symbolPtr);
7571hipError_t hipGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags,
7572 hipDriverEntryPointQueryResult* driverStatus);
7606hipError_t hipModuleLoadData(hipModule_t* module, const void* image);
7619hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions,
7620 hipJitOption* options, void** optionValues);
7640 const char* name, unsigned int numOptions, hipJitOption* options,
7641 void** optionValues);
7642
7660 unsigned int numOptions, hipJitOption* options, void** optionValues);
7661
7676hipError_t hipLinkComplete(hipLinkState_t state, void** hipBinOut, size_t* sizeOut);
7677
7689hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption* options, void** optionValues,
7690 hipLinkState_t* stateOut);
7700
7729hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY,
7730 unsigned int gridDimZ, unsigned int blockDimX,
7731 unsigned int blockDimY, unsigned int blockDimZ,
7732 unsigned int sharedMemBytes, hipStream_t stream,
7733 void** kernelParams, void** extra);
7763 unsigned int gridDimY, unsigned int gridDimZ,
7764 unsigned int blockDimX, unsigned int blockDimY,
7765 unsigned int blockDimZ, unsigned int sharedMemBytes,
7766 hipStream_t stream, void** kernelParams);
7782 unsigned int numDevices, unsigned int flags);
7803hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX,
7804 void** kernelParams, unsigned int sharedMemBytes,
7805 hipStream_t stream);
7818 unsigned int flags);
7819
7820// Doxygen end group ModuleCooperativeG
7835 unsigned int flags);
7849hipError_t hipLaunchKernelExC(const hipLaunchConfig_t* config, const void* fPtr, void** args);
7866 void** extra);
7882 hipMemRangeHandleType handleType,
7883 unsigned long long flags);
7884// doxygen end Module
7912// TODO - Match CUoccupancyB2DSize
7914 size_t dynSharedMemPerBlk, int blockSizeLimit);
7930// TODO - Match CUoccupancyB2DSize
7932 hipFunction_t f,
7933 size_t dynSharedMemPerBlk,
7934 int blockSizeLimit, unsigned int flags);
7945 int blockSize,
7946 size_t dynSharedMemPerBlk);
7958 int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);
7969 int blockSize, size_t dynSharedMemPerBlk);
7981 int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk,
7982 unsigned int flags __dparm(hipOccupancyDefault));
7997hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize, const void* f,
7998 size_t dynSharedMemPerBlk, int blockSizeLimit);
8014hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* f,
8015 int numBlocks, int blockSize);
8026hipError_t hipOccupancyMaxActiveClusters(int* numClusters, const void* f,
8027 const hipLaunchConfig_t* config);
8038hipError_t hipOccupancyMaxPotentialClusterSize(int* clusterSize, const void* f,
8039 const hipLaunchConfig_t* config);
8040
8041// doxygen end Occupancy
8055// TODO - expand descriptions:
8062HIP_DEPRECATED("use roctracer/rocTX instead")
8070HIP_DEPRECATED("use roctracer/rocTX instead")
8072// doxygen end profiler
8099hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0),
8100 hipStream_t stream __dparm(0));
8111hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);
8120hipError_t hipLaunchByPtr(const void* func);
8137hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0),
8138 hipStream_t stream __dparm(0));
8158hipError_t __hipPopCallConfiguration(dim3* gridDim, dim3* blockDim, size_t* sharedMem,
8159 hipStream_t* stream);
8176hipError_t hipLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks,
8177 void** args, size_t sharedMemBytes __dparm(0),
8178 hipStream_t stream __dparm(0));
8179
8207
8216// TODO: Move this to hip_ext.h
8238hipError_t hipExtLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks,
8239 void** args, size_t sharedMemBytes, hipStream_t stream,
8240 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);
8241// doxygen end Clang launch
8268 const hipTextureDesc* pTexDesc,
8269 const struct hipResourceViewDesc* pResViewDesc);
8270
8280
8291
8302 hipTextureObject_t textureObject);
8303
8314 hipTextureObject_t textureObject);
8315
8326 hipTextureObject_t textureObject);
8327
8340 const HIP_TEXTURE_DESC* pTexDesc,
8341 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);
8342
8352
8363
8374 hipTextureObject_t texObject);
8375
8386
8402 const struct hipChannelFormatDesc* desc, struct hipExtent extent,
8403 unsigned int numLevels, unsigned int flags __dparm(0));
8404
8416
8430 hipMipmappedArray_const_t mipmappedArray, unsigned int level);
8431
8443hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,
8444 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,
8445 unsigned int numMipmapLevels);
8446
8457hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);
8458
8471hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,
8472 unsigned int level);
8473
8495 const hipChannelFormatDesc* desc);
8496
8508hipError_t hipGetTextureReference(const textureReference** texref, const void* symbol);
8509
8521hipError_t hipTexRefGetBorderColor(float* pBorderColor, const textureReference* texRef);
8522
8536
8550 enum hipTextureAddressMode am);
8590hipError_t hipTexRefSetFlags(textureReference* texRef, unsigned int Flags);
8605 int NumPackedComponents);
8621hipError_t hipBindTexture(size_t* offset, const textureReference* tex, const void* devPtr,
8622 const hipChannelFormatDesc* desc, size_t size __dparm(UINT_MAX));
8640hipError_t hipBindTexture2D(size_t* offset, const textureReference* tex, const void* devPtr,
8641 const hipChannelFormatDesc* desc, size_t width, size_t height,
8642 size_t pitch);
8657 const hipChannelFormatDesc* desc);
8710 int dim);
8736hipError_t hipTexRefGetFlags(unsigned int* pFlags, const textureReference* texRef);
8751 const textureReference* texRef);
8778 const textureReference* texRef);
8805hipError_t hipTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* pmaxMipmapLevelClamp,
8806 const textureReference* texRef);
8819hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t* pArray, const textureReference* texRef);
8835 size_t bytes);
8851 hipDeviceptr_t dptr, size_t Pitch);
8918 float maxMipMapLevelClamp);
8933 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);
8934
8935// doxygen end deprecated texture management
8940// doxygen end Texture management
8952// This group is for HIPrtc
8953
8954// doxygen end Runtime
8973const char* hipApiName(uint32_t id);
8982const char* hipKernelNameRef(const hipFunction_t f);
8992const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream);
9002
9003// doxygen end Callback
9026
9047 const hipGraphNode_t* dependencies,
9048 const hipGraphEdgeData* dependencyData,
9049 size_t numDependencies, hipStreamCaptureMode mode);
9050
9062
9074 unsigned long long* pId);
9075
9091 unsigned long long* id_out __dparm(0),
9092 hipGraph_t* graph_out __dparm(0),
9093 const hipGraphNode_t** dependencies_out __dparm(0),
9094 size_t* numDependencies_out __dparm(0));
9095
9106
9120 size_t numDependencies,
9121 unsigned int flags __dparm(0));
9122
9131
9141hipError_t hipGraphCreate(hipGraph_t* pGraph, unsigned int flags);
9142
9152
9164 const hipGraphNode_t* to, size_t numDependencies);
9165
9177 const hipGraphNode_t* to, size_t numDependencies);
9178
9195 size_t* numEdges);
9196
9211hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes);
9212
9228 size_t* pNumRootNodes);
9229
9245 size_t* pNumDependencies);
9246
9263 size_t* pNumDependentNodes);
9264
9274
9283
9292hipError_t hipGraphClone(hipGraph_t* pGraphClone, hipGraph_t originalGraph);
9293
9304 hipGraph_t clonedGraph);
9305
9320 hipGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize);
9321
9333 unsigned long long flags);
9334
9345 hipGraphInstantiateParams* instantiateParams);
9355
9365
9378 const hipGraphNode_t* pDependencies, size_t numDependencies,
9379 hipGraphNodeParams* nodeParams);
9380
9389hipError_t hipGraphExecGetFlags(hipGraphExec_t graphExec, unsigned long long* flags);
9390
9401
9413 hipGraphNodeParams* nodeParams);
9414
9424
9425// Check whether an executable graph can be updated with a graph and perform the update if possible.
9438 hipGraphNode_t* hErrorNode_out,
9439 hipGraphExecUpdateResult* updateResult_out);
9440
9453 const hipGraphNode_t* pDependencies, size_t numDependencies,
9454 const hipKernelNodeParams* pNodeParams);
9455
9465
9475
9486 const hipKernelNodeParams* pNodeParams);
9487
9501 const hipGraphNode_t* dependencies, size_t numDependencies,
9502 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);
9515 const hipGraphNode_t* pDependencies, size_t numDependencies,
9516 const hipMemcpy3DParms* pCopyParams);
9526
9536
9547 const hipKernelNodeAttrValue* value);
9558 hipKernelNodeAttrValue* value);
9569 hipMemcpy3DParms* pNodeParams);
9570
9586 const hipGraphNode_t* pDependencies, size_t numDependencies,
9587 void* dst, const void* src, size_t count, hipMemcpyKind kind);
9588
9601 size_t count, hipMemcpyKind kind);
9602
9617 void* dst, const void* src, size_t count,
9618 hipMemcpyKind kind);
9619
9636 const hipGraphNode_t* pDependencies,
9637 size_t numDependencies, void* dst, const void* symbol,
9638 size_t count, size_t offset, hipMemcpyKind kind);
9639
9653 size_t count, size_t offset, hipMemcpyKind kind);
9654
9670 void* dst, const void* symbol, size_t count,
9671 size_t offset, hipMemcpyKind kind);
9672
9689 const hipGraphNode_t* pDependencies,
9690 size_t numDependencies, const void* symbol,
9691 const void* src, size_t count, size_t offset,
9692 hipMemcpyKind kind);
9693
9707 const void* src, size_t count, size_t offset,
9708 hipMemcpyKind kind);
9709
9710
9725 const void* symbol, const void* src,
9726 size_t count, size_t offset, hipMemcpyKind kind);
9727
9740 const hipGraphNode_t* pDependencies, size_t numDependencies,
9741 const hipMemsetParams* pMemsetParams);
9742
9752
9762
9773 const hipMemsetParams* pNodeParams);
9774
9787 const hipGraphNode_t* pDependencies, size_t numDependencies,
9788 const hipHostNodeParams* pNodeParams);
9789
9799
9809
9820 const hipHostNodeParams* pNodeParams);
9821
9834 const hipGraphNode_t* pDependencies, size_t numDependencies,
9835 hipGraph_t childGraph);
9836
9846
9857 hipGraph_t childGraph);
9858
9870 const hipGraphNode_t* pDependencies, size_t numDependencies);
9871
9872
9885 const hipGraphNode_t* pDependencies, size_t numDependencies,
9886 hipEvent_t event);
9887
9897
9907
9918 hipEvent_t event);
9919
9932 const hipGraphNode_t* pDependencies, size_t numDependencies,
9933 hipEvent_t event);
9934
9935
9945
9955
9966 hipEvent_t event);
9967
9981 const hipGraphNode_t* pDependencies, size_t numDependencies,
9982 hipMemAllocNodeParams* pNodeParams);
9983
9993
10006 const hipGraphNode_t* pDependencies, size_t numDependencies,
10007 void* dev_ptr);
10008
10018
10029
10040
10049
10062 unsigned int initialRefcount, unsigned int flags);
10063
10073
10083
10095 unsigned int count __dparm(1), unsigned int flags __dparm(0));
10096
10107 unsigned int count __dparm(1));
10108
10118hipError_t hipGraphDebugDotPrint(hipGraph_t graph, const char* path, unsigned int flags);
10119
10134
10157 unsigned int isEnabled);
10178 unsigned int* isEnabled);
10179
10192 hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies,
10193 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);
10194
10207 hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies,
10208 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);
10218 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);
10228 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);
10259 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,
10260 const hipExternalSemaphoreSignalNodeParams* nodeParams);
10271 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,
10272 const hipExternalSemaphoreWaitNodeParams* nodeParams);
10273
10283
10293
10307 const hipGraphNode_t* dependencies, size_t numDependencies,
10308 const hipMemsetParams* memsetParams, hipCtx_t ctx);
10309
10322 const hipGraphNode_t* dependencies, size_t numDependencies,
10323 hipDeviceptr_t dptr);
10324
10336 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);
10337
10349 const hipMemsetParams* memsetParams, hipCtx_t ctx);
10350
10351// doxygen end graph API
10380
10392hipError_t hipMemAddressReserve(void** ptr, size_t size, size_t alignment, void* addr,
10393 unsigned long long flags);
10394
10412 const hipMemAllocationProp* prop, unsigned long long flags);
10413
10427 hipMemAllocationHandleType handleType,
10428 unsigned long long flags);
10429
10439hipError_t hipMemGetAccess(unsigned long long* flags, const hipMemLocation* location, void* ptr);
10440
10452
10463
10475 hipMemAllocationHandleType shHandleType);
10476
10488hipError_t hipMemMap(void* ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle,
10489 unsigned long long flags);
10490
10499hipError_t hipMemMapArrayAsync(hipArrayMapInfo* mapInfoList, unsigned int count,
10500 hipStream_t stream);
10501
10511
10521
10533hipError_t hipMemSetAccess(void* ptr, size_t size, const hipMemAccessDesc* desc, size_t count);
10534
10543hipError_t hipMemUnmap(void* ptr, size_t size);
10544
10545// doxygen end virtual memory management API
10568 hipStream_t stream __dparm(0));
10583 unsigned int arrayIndex, unsigned int mipLevel);
10595 hipGraphicsResource_t resource);
10607 hipStream_t stream __dparm(0));
10617// doxygen end GraphicsInterop
10652// end of surface
10653
10654
10691hipError_t hipExtSetLoggingParams(size_t log_level, size_t log_size, size_t log_mask);
10692
10696#ifdef __cplusplus
10697} /* extern "c" */
10698#endif
10699#ifdef __cplusplus
10700#if defined(__clang__) && defined(__HIP__)
10701template <typename T> static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSize(
10702 int* gridSize, int* blockSize, T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {
10703 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),
10704 dynSharedMemPerBlk, blockSizeLimit);
10705}
10706template <typename T> static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeWithFlags(
10707 int* gridSize, int* blockSize, T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0,
10708 unsigned int flags = 0) {
10709 (void)flags;
10710 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),
10711 dynSharedMemPerBlk, blockSizeLimit);
10712}
10713#endif // defined(__clang__) && defined(__HIP__)
10714
10724template <typename T> hipError_t hipGetSymbolAddress(void** devPtr, const T& symbol) {
10725 return ::hipGetSymbolAddress(devPtr, (const void*)&symbol);
10726}
10737template <typename T> hipError_t hipGetSymbolSize(size_t* size, const T& symbol) {
10738 return ::hipGetSymbolSize(size, (const void*)&symbol);
10739}
10740
10749template <typename T>
10750hipError_t hipMemcpyToSymbol(const T& symbol, const void* src, size_t sizeBytes,
10751 size_t offset __dparm(0),
10753 return ::hipMemcpyToSymbol((const void*)&symbol, src, sizeBytes, offset, kind);
10754}
10763template <typename T>
10764hipError_t hipMemcpyToSymbolAsync(const T& symbol, const void* src, size_t sizeBytes, size_t offset,
10765 hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
10766 return ::hipMemcpyToSymbolAsync((const void*)&symbol, src, sizeBytes, offset, kind, stream);
10767}
10775template <typename T>
10776hipError_t hipMemcpyFromSymbol(void* dst, const T& symbol, size_t sizeBytes,
10777 size_t offset __dparm(0),
10779 return ::hipMemcpyFromSymbol(dst, (const void*)&symbol, sizeBytes, offset, kind);
10780}
10788template <typename T>
10789hipError_t hipMemcpyFromSymbolAsync(void* dst, const T& symbol, size_t sizeBytes, size_t offset,
10790 hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
10791 return ::hipMemcpyFromSymbolAsync(dst, (const void*)&symbol, sizeBytes, offset, kind, stream);
10792}
10793
10805template <class T>
10806inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, T f, int blockSize,
10807 size_t dynSharedMemPerBlk) {
10808 return hipOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, reinterpret_cast<const void*>(f),
10809 blockSize, dynSharedMemPerBlk);
10810}
10825 int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) {
10827 numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk, flags);
10828}
10851template <typename UnaryFunction, class T>
10852static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(
10853 int* min_grid_size, int* block_size, T func, UnaryFunction block_size_to_dynamic_smem_size,
10854 int block_size_limit = 0, unsigned int flags = 0) {
10855 if (min_grid_size == nullptr || block_size == nullptr ||
10856 reinterpret_cast<const void*>(func) == nullptr) {
10857 return hipErrorInvalidValue;
10858 }
10859
10860 int dev;
10861 hipError_t status;
10862 if ((status = hipGetDevice(&dev)) != hipSuccess) {
10863 return status;
10864 }
10865
10866 int max_threads_per_cu;
10867 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,
10869 hipSuccess) {
10870 return status;
10871 }
10872
10873 int warp_size;
10874 if ((status = hipDeviceGetAttribute(&warp_size, hipDeviceAttributeWarpSize, dev)) != hipSuccess) {
10875 return status;
10876 }
10877
10878 int max_cu_count;
10879 if ((status = hipDeviceGetAttribute(&max_cu_count, hipDeviceAttributeMultiprocessorCount, dev)) !=
10880 hipSuccess) {
10881 return status;
10882 }
10883
10884 struct hipFuncAttributes attr;
10885 if ((status = hipFuncGetAttributes(&attr, reinterpret_cast<const void*>(func))) != hipSuccess) {
10886 return status;
10887 }
10888
10889 // Initial limits for the execution
10890 const int func_max_threads_per_block = attr.maxThreadsPerBlock;
10891 if (block_size_limit == 0) {
10892 block_size_limit = func_max_threads_per_block;
10893 }
10894
10895 if (func_max_threads_per_block < block_size_limit) {
10896 block_size_limit = func_max_threads_per_block;
10897 }
10898
10899 const int block_size_limit_aligned =
10900 ((block_size_limit + (warp_size - 1)) / warp_size) * warp_size;
10901
10902 // For maximum search
10903 int max_threads = 0;
10904 int max_block_size{};
10905 int max_num_blocks{};
10906 for (int block_size_check_aligned = block_size_limit_aligned; block_size_check_aligned > 0;
10907 block_size_check_aligned -= warp_size) {
10908 // Make sure the logic uses the requested limit and not aligned
10909 int block_size_check =
10910 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;
10911
10912 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);
10913 int optimal_blocks;
10915 &optimal_blocks, func, block_size_check, dyn_smem_size, flags)) != hipSuccess) {
10916 return status;
10917 }
10918
10919 int total_threads = block_size_check * optimal_blocks;
10920 if (total_threads > max_threads) {
10921 max_block_size = block_size_check;
10922 max_num_blocks = optimal_blocks;
10923 max_threads = total_threads;
10924 }
10925
10926 // Break if the logic reached possible maximum
10927 if (max_threads_per_cu == max_threads) {
10928 break;
10929 }
10930 }
10931
10932 // Grid size is the number of blocks per CU * CU count
10933 *min_grid_size = max_num_blocks * max_cu_count;
10934 *block_size = max_block_size;
10935
10936 return status;
10937}
10938
10960template <typename UnaryFunction, class T>
10961static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(
10962 int* min_grid_size, int* block_size, T func, UnaryFunction block_size_to_dynamic_smem_size,
10963 int block_size_limit = 0) {
10964 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(
10965 min_grid_size, block_size, func, block_size_to_dynamic_smem_size, block_size_limit);
10966}
10982template <typename F> inline hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize,
10983 int* blockSize, F kernel,
10984 size_t dynSharedMemPerBlk,
10985 uint32_t blockSizeLimit) {
10986 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, (hipFunction_t)kernel,
10987 dynSharedMemPerBlk, blockSizeLimit);
10988}
10989
11005template <typename F>
11006inline hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, F f,
11007 int numBlocks, int blockSize) {
11008 return hipOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, reinterpret_cast<const void*>(f),
11009 numBlocks, blockSize);
11010}
11032template <class T>
11033inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim, void** kernelParams,
11034 unsigned int sharedMemBytes, hipStream_t stream) {
11035 return hipLaunchCooperativeKernel(reinterpret_cast<const void*>(f), gridDim, blockDim,
11036 kernelParams, sharedMemBytes, stream);
11037}
11053template <class T>
11055 unsigned int numDevices,
11056 unsigned int flags = 0) {
11057 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);
11058}
11071template <class T>
11073 unsigned int numDevices,
11074 unsigned int flags = 0) {
11075 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);
11076}
11090template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11091static inline hipError_t hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex,
11092 const void* devPtr, size_t size = UINT_MAX) {
11093 return hipBindTexture(offset, &tex, devPtr, &tex.channelDesc, size);
11094}
11109template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11110static inline hipError_t
11111 hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex, const void* devPtr,
11112 const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) {
11113 return hipBindTexture(offset, &tex, devPtr, &desc, size);
11114}
11130template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11131static inline hipError_t
11132 hipBindTexture2D(size_t* offset, const struct texture<T, dim, readMode>& tex,
11133 const void* devPtr, size_t width, size_t height, size_t pitch) {
11134 return hipBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch);
11135}
11152template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11153static inline hipError_t
11154 hipBindTexture2D(size_t* offset, const struct texture<T, dim, readMode>& tex,
11155 const void* devPtr, const struct hipChannelFormatDesc& desc, size_t width,
11156 size_t height, size_t pitch) {
11157 return hipBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch);
11158}
11170template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11171static inline hipError_t
11176}
11189template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11190static inline hipError_t
11192 const struct hipChannelFormatDesc& desc) {
11193 return hipBindTextureToArray(&tex, array, &desc);
11194}
11206template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11212 if (err != hipSuccess) {
11213 return err;
11214 }
11217}
11230template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11233 const struct hipChannelFormatDesc& desc) {
11235}
11246template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)
11247static inline hipError_t hipUnbindTexture(const struct texture<T, dim, readMode>& tex) {
11248 return hipUnbindTexture(&tex);
11249}
11273static inline hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool,
11274 hipStream_t stream) {
11275 return hipMallocFromPoolAsync(dev_ptr, size, mem_pool, stream);
11276}
11287template <class T> static inline hipError_t hipMallocAsync(T** dev_ptr, size_t size,
11288 hipMemPool_t mem_pool,
11289 hipStream_t stream) {
11290 return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);
11291}
11302template <class T>
11303static inline hipError_t hipMallocAsync(T** dev_ptr, size_t size, hipStream_t stream) {
11304 return hipMallocAsync(reinterpret_cast<void**>(dev_ptr), size, stream);
11305}
11316template <class T> static inline hipError_t hipMallocFromPoolAsync(T** dev_ptr, size_t size,
11317 hipMemPool_t mem_pool,
11318 hipStream_t stream) {
11319 return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);
11320}
11334template <typename... KernelArgs, typename... Params>
11335static inline __host__ hipError_t hipLaunchKernelEx(const hipLaunchConfig_t* config,
11336 void (*kernel)(KernelArgs...),
11337 Params&&... args) {
11338 return [&](KernelArgs... convertedArgs) {
11339 void* pArgs[] = {&convertedArgs...};
11340 return ::hipLaunchKernelExC(config, reinterpret_cast<void*>(kernel), pArgs);
11341 }(std::forward<Params>(args)...);
11342}
11348#endif // __cplusplus
11349
11350#ifdef __GNUC__
11351#pragma GCC visibility pop
11352#endif
11353
11354
11355#elif !defined(__HIP_PLATFORM_AMD__) && defined(__HIP_PLATFORM_NVIDIA__)
11356#include "hip/nvidia_detail/nvidia_hip_runtime_api.h"
11357#else
11358#error ("Must define exactly one of __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__");
11359#endif
11360
11361
11373#if defined(__cplusplus) && !defined(__HIP_DISABLE_CPP_FUNCTIONS__)
11374template <class T> static inline hipError_t hipMalloc(T** devPtr, size_t size) {
11375 return hipMalloc((void**)devPtr, size);
11376}
11388template <class T>
11389static inline hipError_t hipMallocPitch(T** devPtr, size_t* pitch, size_t width, size_t height) {
11390 return hipMallocPitch((void**)devPtr, pitch, width, height);
11391}
11404template <class T>
11405static inline hipError_t hipHostMalloc(T** ptr, size_t size,
11406 unsigned int flags = hipHostMallocDefault) {
11407 return hipHostMalloc((void**)ptr, size, flags);
11408}
11421template <class T> static inline hipError_t hipHostAlloc(T** ptr, size_t size,
11422 unsigned int flags = hipHostAllocDefault) {
11423 return hipHostAlloc((void**)ptr, size, flags);
11424}
11439template <class T>
11440static inline hipError_t hipMallocManaged(T** devPtr, size_t size,
11441 unsigned int flags = hipMemAttachGlobal) {
11442 return hipMallocManaged((void**)devPtr, size, flags);
11443}
11444
11445#endif
11446#endif
11447// doxygen end HIP API
11451#include <hip/amd_detail/amd_hip_runtime_pt_api.h>
11452
11453#if USE_PROF_API
11454#include <hip/amd_detail/hip_prof_str.h>
11455#endif
hipError_t err
Definition hip_runtime_api.h:11174
const struct texture< T, dim, readMode > & tex
Definition hip_runtime_api.h:11091
const struct texture< T, dim, readMode > const void size_t size
Definition hip_runtime_api.h:11092
const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t size_t pitch
Definition hip_runtime_api.h:11133
hipArray_t levelArray
Definition hip_runtime_api.h:11210
const struct texture< T, dim, readMode > const void size_t int dim
Definition hip_runtime_api.h:11109
readMode hipMipmappedArray_const_t mipmappedArray
Definition hip_runtime_api.h:11208
const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t height
Definition hip_runtime_api.h:11133
const struct texture< T, dim, readMode > const void * devPtr
Definition hip_runtime_api.h:11092
const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc & desc
Definition hip_runtime_api.h:11112
readMode hipArray_const_t array
Definition hip_runtime_api.h:11172
const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t width
Definition hip_runtime_api.h:11133
const char * hipApiName(uint32_t id)
Returns HIP API name by ID.
const char * hipKernelNameRef(const hipFunction_t f)
Returns kernel name reference by function name.
const char * hipKernelNameRefByPtr(const void *hostFunction, hipStream_t stream)
Retrives kernel for a given host pointer, unless stated otherwise.
int hipGetStreamDeviceId(hipStream_t stream)
Returns device ID on the stream.
hipError_t hipSetupArgument(const void *arg, size_t size, size_t offset)
Set a kernel argument.
hipError_t __hipPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream)
Pop configuration of a kernel launch.
hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void *userData)
Enqueues a host function call in a stream.
hipError_t hipLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream)
C compliant kernel launch API.
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.
hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)
Push configuration of a kernel launch.
hipError_t hipLaunchByPtr(const void *func)
Launch a kernel.
hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)
hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)
Configure a kernel launch.
hipError_t hipCtxGetFlags(unsigned int *flags)
Return flags used for creating default context [Deprecated].
hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int *apiVersion)
Returns the approximate HIP api version.
hipError_t hipCtxPopCurrent(hipCtx_t *ctx)
Pop the current/default context and return the popped context [Deprecated].
hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)
Get Shared memory bank configuration [Deprecated].
hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)
Set flags for the primary context [Deprecated].
hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int *flags, int *active)
Get the state of the primary context [Deprecated].
hipError_t hipCtxGetCurrent(hipCtx_t *ctx)
Get the handle of the current/ default context [Deprecated].
hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)
Release the primary context on the GPU.
hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition [Deprecated].
hipError_t hipCtxSetCurrent(hipCtx_t ctx)
Set the passed context as current/default [Deprecated].
hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)
Enables direct access to memory allocations in a peer context [Deprecated].
hipError_t hipCtxGetDevice(hipDevice_t *device)
Get the handle of the device associated with current/default context [Deprecated].
hipError_t hipCtxDestroy(hipCtx_t ctx)
Destroy a HIP context [Deprecated].
hipError_t hipCtxPushCurrent(hipCtx_t ctx)
Push the context to be set as current/ default context [Deprecated].
hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)
Get Cache configuration for a specific function [Deprecated].
hipError_t hipCtxCreate(hipCtx_t *ctx, unsigned int flags, hipDevice_t device)
Create a context and set it as current/default context.
hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)
Retain the primary context on the GPU [Deprecated].
hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)
Resets the primary context on the GPU [Deprecated].
hipError_t hipCtxSynchronize(void)
Blocks until the default context has completed all preceding requested tasks [Deprecated].
hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)
Set Shared memory bank configuration [Deprecated].
hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)
Disable direct access from current context's virtual address space to memory allocations physically l...
hipError_t hipInitDevice(int device, unsigned int deviceFlags, unsigned int flags)
Initialize the specified device to be used for GPU executions.
hipError_t hipGetDeviceFlags(unsigned int *flags)
Gets the flags set for current device.
hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)
Gets an opaque interprocess handle for an event.
hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)
Returns the default memory pool of the specified device.
hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)
Returns bank width of shared memory for current device.
hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)
Sets the current memory pool of a device.
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...
hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)
Get Cache configuration for a specific Device.
hipError_t hipSetDevice(int deviceId)
Set default device to be used for subsequent hip API calls from this thread.
hipError_t hipDeviceFlushGPUDirectRDMAWrites(enum hipFlushGPUDirectRDMAWritesTarget target, enum hipFlushGPUDirectRDMAWritesScope scope)
Blocks until remote writes are visible to the specified scope.
hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t *linktype, uint32_t *hopcount)
Returns the link type and hop count between two devices.
hipError_t hipDeviceGetTexture1DLinearMaxWidth(size_t *max_width, const hipChannelFormatDesc *desc, int device)
Gets the maximum width for 1D linear textures on the specified device.
hipError_t hipSetDeviceFlags(unsigned flags)
The current device behavior is changed according to the flags passed.
hipError_t hipDeviceGetAttribute(int *pi, hipDeviceAttribute_t attr, int deviceId)
Query for a specific device attribute.
hipError_t hipGetDevice(int *deviceId)
Return the default device id for the calling host thread.
hipError_t hipGetDeviceCount(int *count)
Return number of compute-capable devices.
hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)
Gets the current memory pool for the specified device.
hipError_t hipDeviceReset(void)
The state of current device is discarded and updated to a fresh state.
hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)
Gets resource limits of current device.
hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)
The bank width of shared memory on current device is set.
hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)
Sets resource limits of current device.
hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition.
hipError_t hipIpcCloseMemHandle(void *devPtr)
Close memory mapped with hipIpcOpenMemHandle.
hipError_t hipSetValidDevices(int *device_arr, int len)
Set a list of devices that can be used.
hipError_t hipGetDevicePropertiesR0600(hipDeviceProp_tR0600 *prop, int deviceId)
hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)
Opens an interprocess event handles.
hipError_t hipDeviceSynchronize(void)
Waits on all active streams on current device.
hipError_t hipChooseDeviceR0600(int *device, const hipDeviceProp_tR0600 *prop)
hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)
Gets an interprocess memory handle for an existing device memory allocation.
hipError_t hipInit(unsigned int flags)
Explicitly initializes the HIP runtime.
hipError_t hipDeviceComputeCapability(int *major, int *minor, hipDevice_t device)
Returns the compute capability of the device.
hipError_t hipDeviceGetName(char *name, int len, hipDevice_t device)
Returns an identifer string for the device.
hipError_t hipDeviceGetByPCIBusId(int *device, const char *pciBusId)
Returns a handle to a compute device.
hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)
Returns an UUID for the device.[BETA].
hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)
Returns the total amount of memory on the device.
hipError_t hipDeviceGetPCIBusId(char *pciBusId, int len, int device)
Returns a PCI Bus Id string for the device, overloaded to take int device ID.
hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)
Returns a handle to a compute device.
hipError_t hipDeviceGetLuid(char *luid, unsigned int *deviceNodeMask, hipDevice_t device)
Returns an LUID and device node mask for the device.
hipError_t hipRuntimeGetVersion(int *runtimeVersion)
Returns the approximate HIP Runtime version.
hipError_t hipDeviceGetP2PAttribute(int *value, hipDeviceP2PAttr attr, int srcDevice, int dstDevice)
Returns a value for attribute of link between two devices.
hipError_t hipDriverGetVersion(int *driverVersion)
Returns the approximate HIP driver version.
hipMemcpyKind
Definition driver_types.h:357
hipPointer_attribute
Definition driver_types.h:700
struct hipArray * hipArray_t
Definition driver_types.h:59
void * hipDeviceptr_t
Definition driver_types.h:30
hipFunction_attribute
Definition driver_types.h:673
const struct hipArray * hipArray_const_t
Definition driver_types.h:60
hipArray_Format
Definition driver_types.h:64
hipResourceType
Definition driver_types.h:143
@ hipMemcpyDeviceToHost
Device-to-Host Copy.
Definition driver_types.h:360
@ hipMemcpyHostToDevice
Host-to-Device Copy.
Definition driver_types.h:359
Definition driver_types.h:87
Definition driver_types.h:77
Definition driver_types.h:408
Definition driver_types.h:297
Definition driver_types.h:342
Definition driver_types.h:175
Definition driver_types.h:99
Definition driver_types.h:43
Definition driver_types.h:556
Definition driver_types.h:518
Definition driver_types.h:495
Definition driver_types.h:378
Definition driver_types.h:450
Definition driver_types.h:602
Definition driver_types.h:395
Definition driver_types.h:610
Definition driver_types.h:544
Definition driver_types.h:121
Definition driver_types.h:369
Definition driver_types.h:270
Definition driver_types.h:329
const char * hipGetErrorString(hipError_t hipError)
Return handy text string message to explain the error which occurred.
hipError_t hipPeekAtLastError(void)
Return last error returned by any HIP runtime API call.
hipError_t hipDrvGetErrorString(hipError_t hipError, const char **errorString)
Return handy text string message to explain the error which occurred.
hipError_t hipGetLastError(void)
Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...
hipError_t hipExtGetLastError(void)
Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...
hipError_t hipDrvGetErrorName(hipError_t hipError, const char **errorString)
Return hip error as text string form.
const char * hipGetErrorName(hipError_t hip_error)
Return hip error as text string form.
hipError_t hipEventSynchronize(hipEvent_t event)
Wait for an event to complete.
hipError_t hipEventQuery(hipEvent_t event)
Query event status.
hipError_t hipEventCreate(hipEvent_t *event)
hipError_t hipEventDestroy(hipEvent_t event)
Destroy the specified event.
hipError_t hipEventRecordWithFlags(hipEvent_t event, hipStream_t stream, unsigned int flags)
Record an event in the specified stream.
hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)
Record an event in the specified stream.
hipError_t hipEventElapsedTime(float *ms, hipEvent_t start, hipEvent_t stop)
Return the elapsed time between two events.
hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)
Create an event with the specified flags.
hipError_t hipDeviceGetExecutionCtx(hipExecutionCtx_t *ctx, int device)
Returns the default execution context for a device.
hipError_t hipExecutionCtxStreamCreate(hipStream_t *stream, hipExecutionCtx_t greenctx, unsigned int flags, int priority)
Creates a stream on an execution context with specified flags and priority.
hipError_t hipGreenCtxCreate(hipExecutionCtx_t *ctx, hipDevResourceDesc_t desc, int device, unsigned int flags)
Creates a green context from a resource descriptor.
hipError_t hipExecutionCtxGetDevice(int *device, hipExecutionCtx_t ctx)
Returns the device associated with an execution context.
hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event)
Makes an execution context wait on an event.
hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx)
Blocks until all work on an execution context has completed.
hipError_t hipDevResourceGenerateDesc(hipDevResourceDesc_t *phDesc, hipDevResource *resources, unsigned int nbResources)
Generates a resource descriptor from one or more device resources.
hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event)
Records an event on an execution context.
hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx)
Destroys an execution context.
hipError_t hipDevSmResourceSplitByCount(hipDevResource *result, unsigned int *nbGroups, const hipDevResource *input, hipDevResource *remainder, unsigned int flags, unsigned int minCount)
Splits SM resources into groups containing the specified number of SMs.
hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource *resource, hipDevResourceType type)
Gets device resource of a given type for a device.
hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource *resource, hipDevResourceType type)
Returns the device resource of a given type for an execution context.
hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource *resource, hipDevResourceType type)
Returns the device resource of a given type for a stream.
hipError_t hipDevSmResourceSplit(hipDevResource *result, unsigned int nbGroups, const hipDevResource *input, hipDevResource *remainder, unsigned int flags, hipDevSmResourceGroupParams *groupParams)
Splits SM resources into structured groups.
hipError_t hipExecutionCtxGetId(hipExecutionCtx_t ctx, unsigned long long *ctxId)
Returns a unique identifier for an execution context.
hipError_t hipFuncGetAttributes(struct hipFuncAttributes *attr, const void *func)
Find out attributes for a given function.
hipError_t hipLaunchKernelExC(const hipLaunchConfig_t *config, const void *fPtr, void **args)
Launches a HIP kernel using a generic function pointer and the specified configuration.
hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams *launchParamsList, int numDevices, unsigned int flags)
Launches kernels on multiple devices and guarantees all specified kernels are dispatched on respectiv...
hipError_t hipKernelGetFunction(hipFunction_t *pFunc, hipKernel_t kernel)
Function will be extracted for specific kernel.
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...
hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)
Set shared memory configuation for a specific function.
hipError_t hipFuncGetAttribute(int *value, hipFunction_attribute attrib, hipFunction_t hfunc)
Find out a specific attribute for a given function.
hipError_t hipKernelSetAttributeForDevice(hipKernel_t kernel, hipFuncAttribute attr, int value, int device)
Set a device-wide attribute for a kernel on a specific device.
hipError_t hipFuncSetAttribute(const void *func, hipFuncAttribute attr, int value)
Set attribute for a specific function.
hipError_t hipDrvLaunchKernelEx(const HIP_LAUNCH_CONFIG *config, hipFunction_t f, void **params, void **extra)
Launches a HIP kernel using the driver API with the specified configuration.
hipError_t hipKernelSetAttribute(hipFunction_attribute attrib, int value, hipKernel_t kernel, hipDevice_t dev)
Set attribute for a specific kernel.
hipError_t hipKernelSetCacheConfig(hipKernel_t kernel, hipFuncCache_t config, hipDevice_t device)
Sets the preferred carveout setting for the specific kernel on a device.
hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)
Set Cache configuration for a specific function.
hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)
Destroys an external memory object.
hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc)
Imports an external semaphore.
hipError_t hipImportExternalMemory(hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc)
Imports an external memory object.
hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)
Destroys an external semaphore object and releases any references to the underlying resource....
hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream)
Waits on a set of external semaphore objects.
hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream)
Signals a set of external semaphore objects.
hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t *mipmap, hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc)
Maps a mipmapped array onto an external memory object.
hipError_t hipExternalMemoryGetMappedBuffer(void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc)
Maps a buffer onto an imported memory object.
hipStreamBatchMemOpType operation
Definition hip_runtime_api.h:1175
unsigned hasSharedInt64Atomics
64-bit integer atomics for shared memory.
Definition hip_runtime_api.h:63
int ECCEnabled
Device has ECC support enabled.
Definition hip_runtime_api.h:323
hipDeviceptr_t address
Definition hip_runtime_api.h:1186
int ipcEventSupported
Device supports IPC events.
Definition hip_runtime_api.h:380
hipGraphNodeType type
Definition hip_runtime_api.h:2159
int computePreemptionSupported
Is compute preemption supported on the device.
Definition hip_runtime_api.h:352
unsigned int flags
Definition hip_runtime_api.h:1515
unsigned int flags
Definition hip_runtime_api.h:1554
int maxTexture1DLinear
Maximum size for 1D textures bound to linear memory.
Definition hip_runtime_api.h:302
int reserved0[3]
Definition hip_runtime_api.h:2160
int priority
Definition hip_runtime_api.h:1822
unsigned int gridDimX
Width(X) of grid in blocks.
Definition hip_runtime_api.h:1484
unsigned int blockDimX
X dimension of each thread block.
Definition hip_runtime_api.h:1487
void * win32HandleMetaData
Metadata for Win32 handles.
Definition hip_runtime_api.h:2008
int timelineSemaphoreInteropSupported
Indicates external timeline semaphore support.
Definition hip_runtime_api.h:370
int device
Definition hip_runtime_api.h:441
hipMemAllocationType type
Memory allocation type.
Definition hip_runtime_api.h:2002
int pciBusID
PCI Bus ID.
Definition hip_runtime_api.h:324
unsigned int flags
flags for future use, must be zero now.
Definition hip_runtime_api.h:2113
unsigned hasSharedInt32Atomics
32-bit integer atomics for shared memory.
Definition hip_runtime_api.h:57
int maxTexture1D
Maximum number of elements in 1D images.
Definition hip_runtime_api.h:300
hipAccessProperty hitProp
hipAccessProperty set for hit
Definition hip_runtime_api.h:1708
void * hostPointer
Definition hip_runtime_api.h:443
hipDeviceptr_t address
Definition hip_runtime_api.h:1176
hipAccessProperty missProp
hipAccessProperty set for miss
Definition hip_runtime_api.h:1710
int memoryBusWidth
Global memory bus width in bits.
Definition hip_runtime_api.h:331
int maxTexture2DMipmap[2]
Maximum number of elements in 2D array mipmap of images.
Definition hip_runtime_api.h:304
hipDevWorkqueueConfigScope sharingScope
Definition hip_runtime_api.h:803
int clockRate
Max clock frequency of the multiProcessors in khz.
Definition hip_runtime_api.h:277
hipExtent extent
Definition hip_runtime_api.h:1527
size_t maxSize
Maximum pool size. When set to 0, defaults to a system dependent value.
Definition hip_runtime_api.h:1413
char pad[64]
64 byte padding
Definition hip_runtime_api.h:1817
unsigned int flags
Definition hip_runtime_api.h:797
unsigned int flags
Definition hip_runtime_api.h:826
unsigned hasFloatAtomicAdd
32-bit float atomic add in global and shared memory.
Definition hip_runtime_api.h:59
int maxThreadsPerMultiProcessor
Maximum resident threads per multi-processor.
Definition hip_runtime_api.h:337
int l2CacheSize
L2 cache size.
Definition hip_runtime_api.h:332
int deferredMappingHipArraySupported
Definition hip_runtime_api.h:378
size_t size
Definition hip_runtime_api.h:2262
int asyncEngineCount
Number of async engines.
Definition hip_runtime_api.h:328
void * dst
Definition hip_runtime_api.h:1675
int accessPolicyMaxWindowSize
Max value of access policy window.
Definition hip_runtime_api.h:364
enum hipMemoryType type
Definition hip_runtime_api.h:440
unsigned int flags
Definition hip_runtime_api.h:1196
size_t totalConstMem
Definition hip_runtime_api.h:278
int memoryPoolsSupported
Indicates if device supports hipMallocAsync and hipMemPool APIs.
Definition hip_runtime_api.h:371
dim3 blockDim
Block dimensions.
Definition hip_runtime_api.h:2234
dim3 gridDim
Definition hip_runtime_api.h:1670
const hipExternalSemaphoreSignalParams * paramsArray
Total number of handles and parameters contained in extSemArray and paramsArray.
Definition hip_runtime_api.h:2023
void * address
Base address (must be cache-line aligned)
Definition hip_runtime_api.h:1766
struct hipDevResource_st * nextResource
Definition hip_runtime_api.h:819
hipHostFn_t fn
Definition hip_runtime_api.h:1663
int unifiedFunctionPointers
Indicates device supports unified function pointers.
Definition hip_runtime_api.h:382
unsigned hasDoubles
Double-precision floating point.
Definition hip_runtime_api.h:66
int maxTexture2DGather[2]
Maximum 2D tex dimensions if gather has to be performed.
Definition hip_runtime_api.h:306
hipStreamBatchMemOpType operation
Definition hip_runtime_api.h:1173
int cacheModeCA
Definition hip_runtime_api.h:867
size_t memPitch
Definition hip_runtime_api.h:272
hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS]
Prefetch regions.
Definition hip_runtime_api.h:1792
hipMemAccessFlags flags
Accessibility flags to set.
Definition hip_runtime_api.h:1373
unsigned int numRegions
Number of valid regions (1-max)
Definition hip_runtime_api.h:1790
hipGraph_t graph
Definition hip_runtime_api.h:2130
int gpuDirectRDMAWritesOrdering
value of hipGPUDirectRDMAWritesOrdering
Definition hip_runtime_api.h:375
unsigned int value
Definition hip_runtime_api.h:1679
unsigned hasWarpVote
Warp vote instructions (__any, __all).
Definition hip_runtime_api.h:69
unsigned int smCount
Definition hip_runtime_api.h:794
hipUUID uuid
UUID of a device.
Definition hip_runtime_api.h:265
unsigned int numLevels
Definition hip_runtime_api.h:1529
unsigned int sharedMemBytes
Definition hip_runtime_api.h:1672
union hipArrayMapInfo::@38 subresource
unsigned int gridDimZ
Grid depth in blocks.
Definition hip_runtime_api.h:2247
unsigned char remote
Definition hip_runtime_api.h:1719
size_t sharedMemPerBlock
Size of shared memory per block (in bytes).
Definition hip_runtime_api.h:269
float hitRatio
hitRatio specifies percentage of lines assigned hitProp
Definition hip_runtime_api.h:1709
unsigned int gpuDirectRDMAFlushWritesOptions
Definition hip_runtime_api.h:373
unsigned hasWarpShuffle
Warp shuffle operations. (__shfl_*).
Definition hip_runtime_api.h:71
size_t surfaceAlignment
Alignment requirement for surface.
Definition hip_runtime_api.h:321
size_t width
Width of each row in bytes (must be a multiple of cache line size)
Definition hip_runtime_api.h:1768
int reserved[63]
CUDA Reserved.
Definition hip_runtime_api.h:383
int maxTexture2DLayered[3]
Maximum number of elements in 2D array images.
Definition hip_runtime_api.h:312
unsigned char reserved[56]
Reserved for future use, must be 0.
Definition hip_runtime_api.h:1414
hipArraySparseSubresourceType subresourceType
Sparse subresource type.
Definition hip_runtime_api.h:2085
int streamPrioritiesSupported
Device supports stream priority.
Definition hip_runtime_api.h:338
unsigned char to_port
Currently no node types define non-zero ports. This field must be set to zero.
Definition hip_runtime_api.h:2212
unsigned int numExtSems
Definition hip_runtime_api.h:2037
hipGraphInstantiateResult result_out
Definition hip_runtime_api.h:1992
unsigned int wqConcurrencyLimit
Definition hip_runtime_api.h:802
hipFunction_t function
Kernel to launch.
Definition hip_runtime_api.h:1483
unsigned int sharedMemBytes
Dynamic shared-memory size in bytes per block.
Definition hip_runtime_api.h:2251
const hipExtDynDataPrefetchConfig * dynDataPrefetch
Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.
Definition hip_runtime_api.h:1851
dim3 blockDim
Definition hip_runtime_api.h:1667
int cooperativeMultiDeviceLaunch
Definition hip_runtime_api.h:356
int hostRegisterSupported
Device supports hipHostRegister.
Definition hip_runtime_api.h:366
unsigned int flags
Definition hip_runtime_api.h:1528
dim3 gridDim
Grid dimensions.
Definition hip_runtime_api.h:2233
unsigned int numAttrs
Number of attributes.
Definition hip_runtime_api.h:2238
unsigned int smCoscheduledAlignment
Definition hip_runtime_api.h:796
hipDeviceptr_t alias
Not valid for AMD backend. Initial value is unimportant.
Definition hip_runtime_api.h:1182
int binaryVersion
Definition hip_runtime_api.h:866
unsigned int flags
Definition hip_runtime_api.h:1572
void * userData
Definition hip_runtime_api.h:1664
hipLaunchMemSyncDomain memSyncDomain
Value of launch attribute hipLaunchAttributeMemSyncDomain.
Definition hip_runtime_api.h:1830
size_t alignment
Definition hip_runtime_api.h:2261
int pageableMemoryAccess
Definition hip_runtime_api.h:348
char name[256]
Device name.
Definition hip_runtime_api.h:264
unsigned char reserved[64]
Definition hip_runtime_api.h:1420
size_t textureAlignment
Alignment requirement for textures.
Definition hip_runtime_api.h:289
hipStreamBatchMemOpType operation
Definition hip_runtime_api.h:1195
unsigned int flags
Definition hip_runtime_api.h:1200
hipExternalSemaphoreHandleType type
Definition hip_runtime_api.h:1545
int globalL1CacheSupported
Indicates globals are cached in L1.
Definition hip_runtime_api.h:339
size_t constSizeBytes
Definition hip_runtime_api.h:868
const hipMemAccessDesc * accessDescs
The number of memory access descriptors.
Definition hip_runtime_api.h:1686
int hostNativeAtomicSupported
Link between host and device supports native atomics.
Definition hip_runtime_api.h:346
hipResourceType resourceType
Resource type.
Definition hip_runtime_api.h:2080
int maxSurfaceCubemapLayered[2]
Maximum cubemap layered surface size.
Definition hip_runtime_api.h:320
int isManaged
Definition hip_runtime_api.h:444
unsigned long long size
Definition hip_runtime_api.h:1514
int maxTextureCubemapLayered[2]
Maximum cubemaps layered texture dims.
Definition hip_runtime_api.h:313
size_t sharedMemPerBlockOptin
Per device m ax shared mem per block usable by special opt in.
Definition hip_runtime_api.h:358
size_t sharedMemPerMultiprocessor
Amount of shared memory available per multiprocessor.
Definition hip_runtime_api.h:341
int singleToDoublePrecisionPerfRatio
Deprecated. CUDA only.
Definition hip_runtime_api.h:347
hipMemOperationType memOperationType
Memory operation type.
Definition hip_runtime_api.h:2106
unsigned int blockDimY
Thread block dimension in Y.
Definition hip_runtime_api.h:2249
int maxSurface2D[2]
Maximum 2D surface size.
Definition hip_runtime_api.h:315
int memoryClockRate
Max global memory clock frequency in khz.
Definition hip_runtime_api.h:330
hipEvent_t event
Event to wait on.
Definition hip_runtime_api.h:2138
int maxTexture2DLinear[3]
Maximum 2D tex dimensions if tex are bound to pitched memory.
Definition hip_runtime_api.h:305
int sparseHipArraySupported
Indicates if device supports sparse hip arrays.
Definition hip_runtime_api.h:367
unsigned int reserved[2]
Reserved for future use, must be zero now.
Definition hip_runtime_api.h:2114
unsigned int minSmPartitionSize
Definition hip_runtime_api.h:795
hipMemLocation location
Location on which the accessibility has to change.
Definition hip_runtime_api.h:1372
int clockInstructionRate
Definition hip_runtime_api.h:390
hipMemLocation location
Location where allocations should reside.
Definition hip_runtime_api.h:1408
int localL1CacheSupported
Locals are cahced in L1.
Definition hip_runtime_api.h:340
int regsPerMultiprocessor
registers available per multiprocessor
Definition hip_runtime_api.h:342
int regsPerBlock
Registers per block.
Definition hip_runtime_api.h:270
hipStream_t stream
Stream identifier.
Definition hip_runtime_api.h:2236
size_t bytesize
The size of the requested allocation in bytes.
Definition hip_runtime_api.h:1689
int reserved[3]
Must be zero.
Definition hip_runtime_api.h:2122
unsigned int preferredCoscheduledSmCount
Definition hip_runtime_api.h:825
const hipExternalSemaphoreWaitParams * paramsArray
Total number of handles and parameters contained in extSemArray and paramsArray.
Definition hip_runtime_api.h:2035
int maxTexture2D[2]
Maximum dimensions (width, height) of 2D images, in image elements.
Definition hip_runtime_api.h:303
int preferredShmemCarveout
Definition hip_runtime_api.h:873
int cooperativeLaunch
HIP device supports cooperative launch.
Definition hip_runtime_api.h:355
int maxTexture3D[3]
Definition hip_runtime_api.h:307
hipMemAllocationHandleType handleTypes
Handle types that will be supported by allocations from the pool.
Definition hip_runtime_api.h:1407
int directManagedMemAccessFromHost
Definition hip_runtime_api.h:361
hipStream_t hStream
HIP stream identifier.
Definition hip_runtime_api.h:2252
hipStreamBatchMemOpParams * paramArray
Definition hip_runtime_api.h:1235
hipLaunchAttribute * attrs
Attribute list.
Definition hip_runtime_api.h:2253
int cooperativeMultiDeviceUnmatchedFunc
Definition hip_runtime_api.h:395
hipMemAllocationType allocType
Allocation type. Currently must be specified as hipMemAllocationTypePinned.
Definition hip_runtime_api.h:1405
int deviceOverlap
Deprecated. Use asyncEngineCount instead.
Definition hip_runtime_api.h:291
int pageableMemoryAccessUsesHostPageTables
Definition hip_runtime_api.h:359
int cooperative
Definition hip_runtime_api.h:1820
hipExternalSemaphore_t * extSemArray
< Array containing external semaphore handles.
Definition hip_runtime_api.h:2033
void ** kernelParams
Definition hip_runtime_api.h:1671
unsigned int * hdpRegFlushCntl
Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:394
unsigned hasGlobalInt32Atomics
32-bit integer atomics for global memory.
Definition hip_runtime_api.h:55
hipAccessPolicyWindow accessPolicyWindow
Value of launch attribute hipLaunchAttributeAccessPolicyWindow.
Definition hip_runtime_api.h:1819
size_t dynamicSmemBytes
Dynamic shared-memory size per thread block.
Definition hip_runtime_api.h:2235
int maxThreadsDim[3]
Max number of threads in each dimension (XYZ) of a block.
Definition hip_runtime_api.h:275
unsigned hasGlobalFloatAtomicExch
32-bit float atomic exch for global memory.
Definition hip_runtime_api.h:56
int unifiedAddressing
Does device and host share unified address space.
Definition hip_runtime_api.h:329
unsigned hasDynamicParallelism
Dynamic parallelism.
Definition hip_runtime_api.h:81
hipStream_t hStream
Stream identifier.
Definition hip_runtime_api.h:1491
hipMemHandleType memHandleType
Memory handle type.
Definition hip_runtime_api.h:2107
unsigned char reserved[5]
These bytes are unused and must be zeroed.
Definition hip_runtime_api.h:2210
unsigned long long offset
Definition hip_runtime_api.h:1525
struct hipLaunchAttributeValue::@33 clusterDim
Specifies the desired cluster dimensions for a kernel launch.
size_t sharedMem
Shared memory.
Definition hip_runtime_api.h:1476
hipEvent_t event
The event to be recorded when node executes.
Definition hip_runtime_api.h:2145
int multiGpuBoardGroupID
Unique identifier for a group of devices on same multiboard GPU.
Definition hip_runtime_api.h:345
hipStream_t uploadStream
Definition hip_runtime_api.h:1994
int isMultiGpuBoard
1 if device is on a multi-GPU board, 0 if not.
Definition hip_runtime_api.h:344
hipMemPoolProps poolProps
Definition hip_runtime_api.h:1684
unsigned int smCount
Definition hip_runtime_api.h:823
size_t sharedSizeBytes
Definition hip_runtime_api.h:875
size_t accessDescCount
Definition hip_runtime_api.h:1687
int maxDynamicSharedSizeBytes
Definition hip_runtime_api.h:870
unsigned int blockDimY
Y dimension of each thread block.
Definition hip_runtime_api.h:1488
int canUseHostPointerForRegisteredMem
Definition hip_runtime_api.h:353
unsigned char type
This should be populated with a value from hipGraphDependencyType.
Definition hip_runtime_api.h:2213
unsigned hasSurfaceFuncs
Surface functions.
Definition hip_runtime_api.h:79
int maxTexture1DLayered[2]
Maximum number of elements in 1D array images.
Definition hip_runtime_api.h:311
hipGraphNode_t errNode_out
Definition hip_runtime_api.h:1990
int pciDomainID
PCI Domain ID.
Definition hip_runtime_api.h:326
hipExternalSemaphore_t * extSemArray
< Array containing external semaphore handles.
Definition hip_runtime_api.h:2021
unsigned int coscheduledSmCount
Definition hip_runtime_api.h:824
size_t maxSharedMemoryPerMultiProcessor
Maximum Shared Memory Per CU. HIP Only.
Definition hip_runtime_api.h:389
int device
Definition hip_runtime_api.h:801
hipMemLocation location
Memory location.
Definition hip_runtime_api.h:2007
hipExtDynDataPrefetchTemporal temporal
Cache retention policy for prefetched data.
Definition hip_runtime_api.h:1791
int maxTextureCubemap
Maximum cubemap texture dims.
Definition hip_runtime_api.h:310
unsigned int blockDimZ
Thread block dimension in Z.
Definition hip_runtime_api.h:2250
unsigned has3dGrid
Grid and group dims are 3D (rather than 2D).
Definition hip_runtime_api.h:80
unsigned int numExtSems
Definition hip_runtime_api.h:2025
hipExternalMemoryHandleType type
Definition hip_runtime_api.h:1505
int ptxVersion
Definition hip_runtime_api.h:874
void ** extra
Definition hip_runtime_api.h:1668
unsigned long long flags
Definition hip_runtime_api.h:1991
unsigned int count
Definition hip_runtime_api.h:1234
unsigned int numAttrs
Number of attributes.
Definition hip_runtime_api.h:2254
unsigned hasFunnelShift
Funnel two words into one with shift&mask caps.
Definition hip_runtime_api.h:72
int hipReserved[32]
Reserved for adding new entries for HIP/CUDA.
Definition hip_runtime_api.h:385
void * dptr
Returned device address of the allocation.
Definition hip_runtime_api.h:1690
hipDeviceptr_t alias
Not valid for AMD backend. Initial value is unimportant.
Definition hip_runtime_api.h:1192
unsigned int elementSize
Definition hip_runtime_api.h:1676
int cooperativeMultiDeviceUnmatchedGridDim
Definition hip_runtime_api.h:398
unsigned int flags
Definition hip_runtime_api.h:1593
int gpuDirectRDMASupported
Indicates device support of RDMA APIs.
Definition hip_runtime_api.h:372
union hipArrayMapInfo::@37 resource
unsigned int gridDimX
Grid width in blocks.
Definition hip_runtime_api.h:2245
int minor
Definition hip_runtime_api.h:284
char gcnArchName[256]
AMD GCN Arch Name. HIP Only.
Definition hip_runtime_api.h:388
void * devicePointer
Definition hip_runtime_api.h:442
char luid[8]
8-byte unique identifier. Only valid on windows
Definition hip_runtime_api.h:266
hipLaunchAttribute * attrs
Attributes list.
Definition hip_runtime_api.h:2237
int kernelExecTimeoutEnabled
Run time limit for kernels executed on the device.
Definition hip_runtime_api.h:296
void * func
Definition hip_runtime_api.h:1669
unsigned int memoryPoolSupportedHandleTypes
Bitmask of handle types support with mempool based IPC.
Definition hip_runtime_api.h:377
unsigned int * hdpMemFlushCntl
Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:393
int concurrentManagedAccess
Definition hip_runtime_api.h:350
int integrated
APU vs dGPU.
Definition hip_runtime_api.h:297
int canMapHostMemory
Check whether HIP can map host memory.
Definition hip_runtime_api.h:298
unsigned hasThreadFenceSystem
__threadfence_system.
Definition hip_runtime_api.h:75
int flags
Must be zero.
Definition hip_runtime_api.h:2121
size_t reservedSharedMemPerBlock
Shared memory reserved by driver per block.
Definition hip_runtime_api.h:365
hipDevResourceType type
Definition hip_runtime_api.h:811
int maxSurfaceCubemap
Maximum cubemap surface size.
Definition hip_runtime_api.h:319
int maxSurface3D[3]
Maximum 3D surface size.
Definition hip_runtime_api.h:316
void ** args
Arguments.
Definition hip_runtime_api.h:1475
int asicRevision
Revision of the GPU in this device.
Definition hip_runtime_api.h:408
unsigned char from_port
Definition hip_runtime_api.h:2203
dim3 blockDim
Block dimensions.
Definition hip_runtime_api.h:1474
hipLaunchAttributeID id
Identifier of the launch attribute.
Definition hip_runtime_api.h:2221
unsigned int deviceBitMask
Device ordinal bit mask.
Definition hip_runtime_api.h:2112
unsigned int gridDimY
Height(Y) of grid in blocks.
Definition hip_runtime_api.h:1485
size_t totalGlobalMem
Size of global memory region (in bytes).
Definition hip_runtime_api.h:268
size_t width
Definition hip_runtime_api.h:1680
int cooperativeMultiDeviceUnmatchedBlockDim
Definition hip_runtime_api.h:401
unsigned int gridDimZ
Depth(Z) of grid in blocks.
Definition hip_runtime_api.h:1486
unsigned allocationFlags
Definition hip_runtime_api.h:445
hipStreamBatchMemOpType operation
Definition hip_runtime_api.h:1185
unsigned int sharedMemBytes
Shared memory.
Definition hip_runtime_api.h:1490
unsigned int flags
Definition hip_runtime_api.h:1236
int maxSurface1DLayered[2]
Maximum 1D layered surface size.
Definition hip_runtime_api.h:317
unsigned hasGlobalInt64Atomics
64-bit integer atomics for global memory.
Definition hip_runtime_api.h:62
int persistingL2CacheMaxSize
Definition hip_runtime_api.h:333
int maxSurface1D
Maximum 1D surface size.
Definition hip_runtime_api.h:314
unsigned int flags
Definition hip_runtime_api.h:1191
int concurrentKernels
Device can possibly execute multiple kernels concurrently.
Definition hip_runtime_api.h:322
int isLargeBar
1: if it is a large PCI bar device, else 0
Definition hip_runtime_api.h:407
int clusterLaunch
Device supports cluster launch.
Definition hip_runtime_api.h:381
int numRegs
Definition hip_runtime_api.h:872
int maxTexture1DMipmap
Maximum 1D mipmap texture size.
Definition hip_runtime_api.h:301
int multiProcessorCount
Definition hip_runtime_api.h:292
struct hipMemAllocationProp::@36 allocFlags
long long reserved2
Definition hip_runtime_api.h:2176
unsigned hasSyncThreadsExt
__syncthreads_count, syncthreads_and, syncthreads_or.
Definition hip_runtime_api.h:76
unsigned int flags
Definition hip_runtime_api.h:1521
unsigned char reserved[HIP_RESOURCE_ABI_BYTES]
Definition hip_runtime_api.h:807
int maxTexture3DAlt[3]
Maximum alternate 3D texture dims.
Definition hip_runtime_api.h:309
void * dptr
the pointer to be freed
Definition hip_runtime_api.h:2152
int maxGridSize[3]
Max grid dimensions (XYZ).
Definition hip_runtime_api.h:276
void * base_ptr
Starting address of the access policy window.
Definition hip_runtime_api.h:1707
int pciDeviceID
PCI Device ID.
Definition hip_runtime_api.h:325
int maxBlocksPerMultiProcessor
Max number of blocks on CU.
Definition hip_runtime_api.h:363
hipStreamBatchMemOpType operation
Definition hip_runtime_api.h:1199
int computeMode
Compute mode.
Definition hip_runtime_api.h:299
hipSynchronizationPolicy syncPolicy
Definition hip_runtime_api.h:1825
void * win32SecurityAttributes
Definition hip_runtime_api.h:1412
unsigned int blockDimZ
Z dimension of each thread block.
Definition hip_runtime_api.h:1489
size_t height
Number of rows to prefetch.
Definition hip_runtime_api.h:1769
hipClusterSchedulingPolicy clusterSchedulingPolicyPreference
Definition hip_runtime_api.h:1849
int maxSurface2DLayered[3]
Maximum 2D layared surface size.
Definition hip_runtime_api.h:318
int major
Definition hip_runtime_api.h:280
union hipArrayMapInfo::@39 memHandle
unsigned char default_
Definition hip_runtime_api.h:1718
hipCtx_t ctx
Definition hip_runtime_api.h:1233
dim3 gridDim
Grid dimensions.
Definition hip_runtime_api.h:1473
void * func
Device function symbol.
Definition hip_runtime_api.h:1472
hipMemcpy3DParms copyParams
Params set for the memory copy.
Definition hip_runtime_api.h:2123
unsigned int flags
Definition hip_runtime_api.h:1181
unsigned hasWarpBallot
Warp ballot instructions (__ballot).
Definition hip_runtime_api.h:70
unsigned int gridDimY
Grid height in blocks.
Definition hip_runtime_api.h:2246
unsigned long long offset
Definition hip_runtime_api.h:1519
int warpSize
Warp size.
Definition hip_runtime_api.h:271
int tccDriver
1:If device is Tesla device using TCC driver, else 0
Definition hip_runtime_api.h:327
unsigned int luidDeviceNodeMask
LUID node mask.
Definition hip_runtime_api.h:267
size_t pitch
Definition hip_runtime_api.h:1678
hipChannelFormatDesc formatDesc
Definition hip_runtime_api.h:1526
size_t height
Definition hip_runtime_api.h:1677
void ** kernelParams
Kernel parameters.
Definition hip_runtime_api.h:1492
int hostRegisterReadOnlySupported
Definition hip_runtime_api.h:368
size_t localSizeBytes
Definition hip_runtime_api.h:869
unsigned long long size
Definition hip_runtime_api.h:1520
unsigned int blockDimX
Thread block dimension in X.
Definition hip_runtime_api.h:2248
int cooperativeMultiDeviceUnmatchedSharedMem
Definition hip_runtime_api.h:404
unsigned long long offset
Offset within the memory.
Definition hip_runtime_api.h:2111
hipStream_t stream
Stream identifier.
Definition hip_runtime_api.h:1477
int maxThreadsPerBlock
Definition hip_runtime_api.h:871
size_t stride
Stride between row starts in bytes.
Definition hip_runtime_api.h:1767
int maxThreadsPerBlock
Max work items per work group or workgroup max size.
Definition hip_runtime_api.h:274
size_t num_bytes
Size in bytes of the window policy.
Definition hip_runtime_api.h:1711
hipDeviceArch_t arch
Architectural feature flags. New for HIP.
Definition hip_runtime_api.h:392
hipLaunchMemSyncDomainMap memSyncDomainMap
Value of launch attribute hipLaunchAttributeMemSyncDomainMap.
Definition hip_runtime_api.h:1828
int managedMemory
Device supports allocating managed memory on this system.
Definition hip_runtime_api.h:343
unsigned hasSharedFloatAtomicExch
32-bit float atomic exch for shared memory.
Definition hip_runtime_api.h:58
size_t texturePitchAlignment
Pitch alignment requirement for texture references bound to.
Definition hip_runtime_api.h:290
hipLimit_t
Definition hip_runtime_api.h:885
hipMemRangeHandleType
Definition hip_runtime_api.h:2268
struct ihipExecutionCtx_t * hipExecutionCtx_t
Definition hip_runtime_api.h:770
hipMemAllocationHandleType
Definition hip_runtime_api.h:1392
hipGraphicsResource * hipGraphicsResource_t
Definition hip_runtime_api.h:1618
enum __HIP_NODISCARD hipError_t UINT32_BASE hipError_t
struct ihipCtx_t * hipCtx_t
Definition hip_runtime_api.h:769
#define __dparm(x)
Definition hip_runtime_api.h:751
struct ihipStream_t * hipStream_t
Definition hip_runtime_api.h:843
hipGraphInstantiateResult
Definition hip_runtime_api.h:1974
int hipDevice_t
Definition hip_runtime_api.h:831
hipAccessProperty
Definition hip_runtime_api.h:1696
hipFlushGPUDirectRDMAWritesScope
Definition hip_runtime_api.h:719
struct ihipLinkState_t * hipLinkState_t
Definition hip_runtime_api.h:857
hipGraphDependencyType
Definition hip_runtime_api.h:2196
hipMemRangeAttribute
Definition hip_runtime_api.h:1285
#define hipMemAttachSingle
Definition hip_runtime_api.h:1041
hipMemoryAdvise
Definition hip_runtime_api.h:1252
#define hipArrayDefault
Definition hip_runtime_api.h:1102
hipSharedMemConfig
Definition hip_runtime_api.h:1449
#define hipKernelNodeAttrValue
Definition hip_runtime_api.h:1877
hipComputeMode
Definition hip_runtime_api.h:679
struct ihipEvent_t * hipEvent_t
Definition hip_runtime_api.h:877
hipStreamCaptureMode
Definition hip_runtime_api.h:1906
hipStreamBatchMemOpType
Definition hip_runtime_api.h:1127
hipDriverProcAddressQueryResult
Definition hip_runtime_api.h:673
#define HIP_DEPRECATED_MSG
Definition hip_runtime_api.h:743
hipLaunchAttributeID
Definition hip_runtime_api.h:1798
struct ihipKernel_t * hipKernel_t
Definition hip_runtime_api.h:859
hipSynchronizationPolicy
Definition hip_runtime_api.h:1734
hipGraphNodeType
Definition hip_runtime_api.h:1642
hipExternalMemoryHandleType
Definition hip_runtime_api.h:1494
#define hipMemAttachGlobal
Definition hip_runtime_api.h:1035
struct ihipLibrary_t * hipLibrary_t
Definition hip_runtime_api.h:858
hipFuncAttribute
Definition hip_runtime_api.h:1426
hipExternalSemaphoreHandleType
Definition hip_runtime_api.h:1532
hipLaunchMemSyncDomain
Definition hip_runtime_api.h:1725
struct ihipDevResourceDesc_t * hipDevResourceDesc_t
Definition hip_runtime_api.h:771
hipDeviceP2PAttr
Definition hip_runtime_api.h:832
hipGraphDebugDotFlags
Definition hip_runtime_api.h:1952
hipDevSmResourceGroup_flags
Definition hip_runtime_api.h:778
hipUserObjectRetainFlags
Definition hip_runtime_api.h:1937
#define hipStreamAttrID
Definition hip_runtime_api.h:1857
#define hipHostAllocDefault
Definition hip_runtime_api.h:977
void(* hipHostFn_t)(void *userData)
Definition hip_runtime_api.h:1661
#define hipOccupancyDefault
Definition hip_runtime_api.h:1107
hipStreamUpdateCaptureDependenciesFlags
Definition hip_runtime_api.h:1918
struct ihipGraph * hipGraph_t
Definition hip_runtime_api.h:1623
hipMemHandleType
Definition hip_runtime_api.h:2056
hipFlushGPUDirectRDMAWritesOptions
Definition hip_runtime_api.h:692
hipFuncCache_t
Definition hip_runtime_api.h:1440
hipUserObjectFlags
Definition hip_runtime_api.h:1933
#define __HIP_NODISCARD
Definition hip_runtime_api.h:96
hipDevWorkqueueConfigScope
Definition hip_runtime_api.h:786
hipGraphMemAttributeType
Definition hip_runtime_api.h:1923
hipMemPoolAttr
Definition hip_runtime_api.h:1300
hipDriverEntryPointQueryResult
Definition hip_runtime_api.h:838
hipMemRangeFlags
Definition hip_runtime_api.h:2276
hipDevSmResourceSplitByCount_flags
Definition hip_runtime_api.h:782
void __hipGetPCH(const char **pch, unsigned int *size)
#define HIP_RESOURCE_ABI_BYTES
Definition hip_runtime_api.h:791
#define UINT32_BASE
Definition hip_runtime_api.h:102
struct ihipModule_t * hipModule_t
Definition hip_runtime_api.h:855
struct hipUserObject * hipUserObject_t
Definition hip_runtime_api.h:1636
hipMemOperationType
Definition hip_runtime_api.h:2063
void * hipExternalSemaphore_t
Definition hip_runtime_api.h:1557
hipGraphicsRegisterFlags
Definition hip_runtime_api.h:1606
#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS
Definition hip_runtime_api.h:1777
#define hipStreamAttrValue
Definition hip_runtime_api.h:1864
hipMemRangeCoherencyMode
Definition hip_runtime_api.h:1273
hipMemAccessFlags
Definition hip_runtime_api.h:1360
hipMemAllocationGranularity_flags
Definition hip_runtime_api.h:2048
hipExtDynDataPrefetchTemporal
Temporal locality hint for dynamic data prefetch.
Definition hip_runtime_api.h:1752
struct hipGraphExec * hipGraphExec_t
Definition hip_runtime_api.h:1631
hipGraphExecUpdateResult
Definition hip_runtime_api.h:1891
struct ihipModuleSymbol_t * hipFunction_t
Definition hip_runtime_api.h:856
#define hipKernelNodeAttrID
Definition hip_runtime_api.h:1869
void * hipExternalMemory_t
Definition hip_runtime_api.h:1531
hipStreamCaptureStatus
Definition hip_runtime_api.h:1911
hipDeviceAttribute_t
Definition hip_runtime_api.h:453
hipGPUDirectRDMAWritesOrdering
Definition hip_runtime_api.h:699
hipDeviceProp_t hipDeviceProp_tR0600
Definition hip_runtime_api.h:412
#define hipHostMallocDefault
Definition hip_runtime_api.h:981
#define HIP_DEPRECATED(msg)
Definition hip_runtime_api.h:740
struct _hipGraphicsResource hipGraphicsResource
Definition hip_runtime_api.h:1616
hipMemAllocationType
Definition hip_runtime_api.h:1378
struct hipGraphNode * hipGraphNode_t
Definition hip_runtime_api.h:1627
struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t
Definition hip_runtime_api.h:2043
hipClusterSchedulingPolicy
Definition hip_runtime_api.h:1742
hipMemoryType
Definition hip_runtime_api.h:422
hipGraphInstantiateFlags
Definition hip_runtime_api.h:1941
#define HIP_IPC_HANDLE_SIZE
Definition hip_runtime_api.h:845
struct ihipMemPoolHandle_t * hipMemPool_t
Definition hip_runtime_api.h:863
hipDevResourceType
Definition hip_runtime_api.h:772
hipArraySparseSubresourceType
Definition hip_runtime_api.h:2071
hipFlushGPUDirectRDMAWritesTarget
Definition hip_runtime_api.h:708
@ hipExtLimitScratchMin
Definition hip_runtime_api.h:896
@ hipLimitMallocHeapSize
Definition hip_runtime_api.h:891
@ hipLimitStackSize
Definition hip_runtime_api.h:886
@ hipLimitPersistingL2CacheSize
Definition hip_runtime_api.h:893
@ hipLimitRange
Supported limit range.
Definition hip_runtime_api.h:904
@ hipLimitPrintfFifoSize
Definition hip_runtime_api.h:889
@ hipExtLimitScratchMax
Definition hip_runtime_api.h:898
@ hipExtLimitScratchCurrent
Definition hip_runtime_api.h:900
@ hipMemRangeHandleTypeMax
Definition hip_runtime_api.h:2270
@ hipMemRangeHandleTypeDmaBufFd
Definition hip_runtime_api.h:2269
@ hipMemHandleTypeWin32
Allows a Win32 NT handle for exporting. (HANDLE)
Definition hip_runtime_api.h:1396
@ hipMemHandleTypeWin32Kmt
Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)
Definition hip_runtime_api.h:1397
@ hipMemHandleTypeNone
Does not allow any export mechanism.
Definition hip_runtime_api.h:1393
@ hipMemHandleTypePosixFileDescriptor
Allows a file descriptor for exporting. Permitted only on POSIX systems.
Definition hip_runtime_api.h:1394
@ hipMemHandleTypeFabric
Allows a fabric handle to be used for exporting.
Definition hip_runtime_api.h:1398
@ hipGraphInstantiateNodeOperationNotSupported
Definition hip_runtime_api.h:1980
@ hipGraphInstantiateMultipleDevicesNotSupported
Definition hip_runtime_api.h:1982
@ hipGraphInstantiateError
Definition hip_runtime_api.h:1976
@ hipGraphInstantiateInvalidStructure
Definition hip_runtime_api.h:1978
@ hipGraphInstantiateSuccess
Definition hip_runtime_api.h:1975
@ hipAccessPropertyNormal
Normal cache persistence.
Definition hip_runtime_api.h:1697
@ hipAccessPropertyPersisting
Persisting access is more likely to persist in cache.
Definition hip_runtime_api.h:1699
@ hipAccessPropertyStreaming
Streaming access is less likely to persist from cache.
Definition hip_runtime_api.h:1698
@ hipFlushGPUDirectRDMAWritesToAllDevices
Visible to all HIP devices.
Definition hip_runtime_api.h:721
@ hipFlushGPUDirectRDMAWritesToOwner
Visible to the device owning the memory.
Definition hip_runtime_api.h:720
@ hipGraphDependencyTypeDefault
Definition hip_runtime_api.h:2197
@ hipGraphDependencyTypeProgrammatic
Definition hip_runtime_api.h:2198
@ hipMemRangeAttributeLastPrefetchLocation
Definition hip_runtime_api.h:1291
@ hipMemRangeAttributePreferredLocation
The preferred location of the range.
Definition hip_runtime_api.h:1288
@ hipMemRangeAttributeAccessedBy
Definition hip_runtime_api.h:1289
@ hipMemRangeAttributeReadMostly
Definition hip_runtime_api.h:1286
@ hipMemRangeAttributeCoherencyMode
Definition hip_runtime_api.h:1293
@ hipMemAdviseUnsetAccessedBy
Definition hip_runtime_api.h:1261
@ hipMemAdviseUnsetCoarseGrain
Restores cache coherency policy back to fine-grain.
Definition hip_runtime_api.h:1268
@ hipMemAdviseSetCoarseGrain
Definition hip_runtime_api.h:1263
@ hipMemAdviseUnsetPreferredLocation
Clear the preferred location for the data.
Definition hip_runtime_api.h:1258
@ hipMemAdviseSetAccessedBy
Definition hip_runtime_api.h:1259
@ hipMemAdviseSetPreferredLocation
Definition hip_runtime_api.h:1256
@ hipMemAdviseSetReadMostly
Definition hip_runtime_api.h:1253
@ hipMemAdviseUnsetReadMostly
Undo the effect of hipMemAdviseSetReadMostly.
Definition hip_runtime_api.h:1255
@ hipSharedMemBankSizeFourByte
Definition hip_runtime_api.h:1451
@ hipSharedMemBankSizeEightByte
Definition hip_runtime_api.h:1453
@ hipSharedMemBankSizeDefault
The compiler selects a device-specific value for the banking.
Definition hip_runtime_api.h:1450
@ hipComputeModeProhibited
Definition hip_runtime_api.h:682
@ hipComputeModeExclusive
Definition hip_runtime_api.h:681
@ hipComputeModeDefault
Definition hip_runtime_api.h:680
@ hipComputeModeExclusiveProcess
Definition hip_runtime_api.h:683
@ hipStreamCaptureModeRelaxed
Definition hip_runtime_api.h:1909
@ hipStreamCaptureModeThreadLocal
Definition hip_runtime_api.h:1908
@ hipStreamCaptureModeGlobal
Definition hip_runtime_api.h:1907
@ hipStreamMemOpWriteValue64
Definition hip_runtime_api.h:1131
@ hipStreamMemOpBarrier
Currently not supported.
Definition hip_runtime_api.h:1132
@ hipStreamMemOpWriteValue32
Definition hip_runtime_api.h:1129
@ hipStreamMemOpWaitValue32
Definition hip_runtime_api.h:1128
@ hipStreamMemOpWaitValue64
Definition hip_runtime_api.h:1130
@ hipStreamMemOpFlushRemoteWrites
Currently not supported.
Definition hip_runtime_api.h:1133
@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND
Definition hip_runtime_api.h:675
@ HIP_GET_PROC_ADDRESS_SUCCESS
Definition hip_runtime_api.h:674
@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT
Definition hip_runtime_api.h:676
@ hipLaunchAttributePriority
Valid for graph node, streams, launches.
Definition hip_runtime_api.h:1805
@ hipLaunchAttributeMax
Definition hip_runtime_api.h:1809
@ hipLaunchAttributeClusterDimension
Valid for graph nodes, launches.
Definition hip_runtime_api.h:1803
@ hipLaunchAttributeMemSyncDomain
Valid for streams, graph nodes, launches.
Definition hip_runtime_api.h:1807
@ hipLaunchAttributeMemSyncDomainMap
Valid for streams, graph nodes, launches.
Definition hip_runtime_api.h:1806
@ hipLaunchAttributeIgnore
Ignored entry.
Definition hip_runtime_api.h:1799
@ hipLaunchAttributeSynchronizationPolicy
Valid for streams.
Definition hip_runtime_api.h:1802
@ hipLaunchAttributeExtDynDataPrefetch
Valid for launches. Prefetch data into L2 before kernel execution.
Definition hip_runtime_api.h:1808
@ hipLaunchAttributeClusterSchedulingPolicyPreference
Valid for graph nodes, launches.
Definition hip_runtime_api.h:1804
@ hipLaunchAttributeAccessPolicyWindow
Valid for Streams, graph nodes, launches.
Definition hip_runtime_api.h:1800
@ hipLaunchAttributeCooperative
Valid for graph nodes, launches.
Definition hip_runtime_api.h:1801
@ hipSyncPolicyYield
Definition hip_runtime_api.h:1737
@ hipSyncPolicyBlockingSync
Definition hip_runtime_api.h:1738
@ hipSyncPolicyAuto
Definition hip_runtime_api.h:1735
@ hipSyncPolicySpin
Definition hip_runtime_api.h:1736
@ hipGraphNodeTypeBatchMemOp
BatchMemOp node.
Definition hip_runtime_api.h:1657
@ hipGraphNodeTypeGraph
Node which executes an embedded graph.
Definition hip_runtime_api.h:1647
@ hipGraphNodeTypeMemset
Memset node.
Definition hip_runtime_api.h:1645
@ hipGraphNodeTypeEventRecord
External event record node.
Definition hip_runtime_api.h:1650
@ hipGraphNodeTypeExtSemaphoreSignal
External Semaphore signal node.
Definition hip_runtime_api.h:1651
@ hipGraphNodeTypeMemcpy
Memcpy node.
Definition hip_runtime_api.h:1644
@ hipGraphNodeTypeWaitEvent
External event wait node.
Definition hip_runtime_api.h:1649
@ hipGraphNodeTypeCount
Definition hip_runtime_api.h:1658
@ hipGraphNodeTypeKernel
GPU kernel node.
Definition hip_runtime_api.h:1643
@ hipGraphNodeTypeHost
Host (executable) node.
Definition hip_runtime_api.h:1646
@ hipGraphNodeTypeMemAlloc
Memory alloc node.
Definition hip_runtime_api.h:1653
@ hipGraphNodeTypeMemFree
Memory free node.
Definition hip_runtime_api.h:1654
@ hipGraphNodeTypeMemcpyFromSymbol
MemcpyFromSymbol node.
Definition hip_runtime_api.h:1655
@ hipGraphNodeTypeMemcpyToSymbol
MemcpyToSymbol node.
Definition hip_runtime_api.h:1656
@ hipGraphNodeTypeEmpty
Empty (no-op) node.
Definition hip_runtime_api.h:1648
@ hipGraphNodeTypeExtSemaphoreWait
External Semaphore wait node.
Definition hip_runtime_api.h:1652
@ hipExternalMemoryHandleTypeD3D11Resource
Definition hip_runtime_api.h:1500
@ hipExternalMemoryHandleTypeD3D12Resource
Definition hip_runtime_api.h:1499
@ hipExternalMemoryHandleTypeNvSciBuf
Definition hip_runtime_api.h:1502
@ hipExternalMemoryHandleTypeOpaqueFd
Definition hip_runtime_api.h:1495
@ hipExternalMemoryHandleTypeD3D12Heap
Definition hip_runtime_api.h:1498
@ hipExternalMemoryHandleTypeOpaqueWin32Kmt
Definition hip_runtime_api.h:1497
@ hipExternalMemoryHandleTypeOpaqueWin32
Definition hip_runtime_api.h:1496
@ hipExternalMemoryHandleTypeD3D11ResourceKmt
Definition hip_runtime_api.h:1501
@ hipFuncAttributeClusterSchedulingPolicyPreference
The block scheduling policy of a function.
Definition hip_runtime_api.h:1434
@ hipFuncAttributePreferredSharedMemoryCarveout
Sets the percentage of total shared memory allocated as the shared memory carveout.
Definition hip_runtime_api.h:1428
@ hipFuncAttributeRequiredClusterWidth
The required cluster width in blocks.
Definition hip_runtime_api.h:1430
@ hipFuncAttributeMaxDynamicSharedMemorySize
The maximum number of bytes requested for dynamically allocated shared memory.
Definition hip_runtime_api.h:1427
@ hipFuncAttributeMax
Definition hip_runtime_api.h:1435
@ hipFuncAttributeRequiredClusterDepth
The required cluster depth in blocks.
Definition hip_runtime_api.h:1432
@ hipFuncAttributeRequiredClusterHeight
The required cluster height in blocks.
Definition hip_runtime_api.h:1431
@ hipFuncAttributeClusterDimMustBeSet
The kernel must launch with a valid cluster size specified.
Definition hip_runtime_api.h:1429
@ hipFuncAttributeNonPortableClusterSizeAllowed
Is the function allowed to launch with non-portable cluster size.
Definition hip_runtime_api.h:1433
@ hipExternalSemaphoreHandleTypeNvSciSync
Definition hip_runtime_api.h:1538
@ hipExternalSemaphoreHandleTypeKeyedMutexKmt
Definition hip_runtime_api.h:1540
@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt
Definition hip_runtime_api.h:1535
@ hipExternalSemaphoreHandleTypeKeyedMutex
Definition hip_runtime_api.h:1539
@ hipExternalSemaphoreHandleTypeD3D11Fence
Definition hip_runtime_api.h:1537
@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32
Definition hip_runtime_api.h:1542
@ hipExternalSemaphoreHandleTypeOpaqueFd
Definition hip_runtime_api.h:1533
@ hipExternalSemaphoreHandleTypeOpaqueWin32
Definition hip_runtime_api.h:1534
@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd
Definition hip_runtime_api.h:1541
@ hipExternalSemaphoreHandleTypeD3D12Fence
Definition hip_runtime_api.h:1536
@ hipLaunchMemSyncDomainRemote
Definition hip_runtime_api.h:1727
@ hipLaunchMemSyncDomainDefault
Definition hip_runtime_api.h:1726
@ hipDevP2PAttrAccessSupported
Definition hip_runtime_api.h:834
@ hipDevP2PAttrHipArrayAccessSupported
Definition hip_runtime_api.h:836
@ hipDevP2PAttrNativeAtomicSupported
Definition hip_runtime_api.h:835
@ hipDevP2PAttrPerformanceRank
Definition hip_runtime_api.h:833
@ hipGraphDebugDotFlagsKernelNodeAttributes
Definition hip_runtime_api.h:1965
@ hipGraphDebugDotFlagsMemsetNodeParams
Definition hip_runtime_api.h:1957
@ hipGraphDebugDotFlagsKernelNodeParams
Definition hip_runtime_api.h:1955
@ hipGraphDebugDotFlagsExtSemasWaitNodeParams
Definition hip_runtime_api.h:1963
@ hipGraphDebugDotFlagsHandles
Definition hip_runtime_api.h:1967
@ hipGraphDebugDotFlagsExtSemasSignalNodeParams
Definition hip_runtime_api.h:1961
@ hipGraphDebugDotFlagsHostNodeParams
Definition hip_runtime_api.h:1958
@ hipGraphDebugDotFlagsEventNodeParams
Definition hip_runtime_api.h:1959
@ hipGraphDebugDotFlagsVerbose
Definition hip_runtime_api.h:1953
@ hipGraphDebugDotFlagsMemcpyNodeParams
Definition hip_runtime_api.h:1956
@ hipDevSmResourceGroupBackfill
Definition hip_runtime_api.h:780
@ hipDevSmResourceGroupDefault
Definition hip_runtime_api.h:779
@ hipGraphUserObjectMove
Add new reference or retain.
Definition hip_runtime_api.h:1938
@ hipStreamAddCaptureDependencies
Add new nodes to the dependency set.
Definition hip_runtime_api.h:1919
@ hipStreamSetCaptureDependencies
Replace the dependency set with the new nodes.
Definition hip_runtime_api.h:1920
@ hipMemHandleTypeGeneric
Generic handle type.
Definition hip_runtime_api.h:2057
@ hipFlushGPUDirectRDMAWritesOptionHost
Definition hip_runtime_api.h:693
@ hipFlushGPUDirectRDMAWritesOptionMemOps
Definition hip_runtime_api.h:695
@ hipFuncCachePreferNone
no preference for shared memory or L1 (default)
Definition hip_runtime_api.h:1441
@ hipFuncCachePreferEqual
prefer equal size L1 cache and shared memory
Definition hip_runtime_api.h:1444
@ hipFuncCachePreferL1
prefer larger L1 cache and smaller shared memory
Definition hip_runtime_api.h:1443
@ hipFuncCachePreferShared
prefer larger shared memory and smaller L1 cache
Definition hip_runtime_api.h:1442
@ hipUserObjectNoDestructorSync
Destructor execution is not synchronized.
Definition hip_runtime_api.h:1934
@ hipDevWorkqueueConfigScopeDeviceCtx
Definition hip_runtime_api.h:787
@ hipDevWorkqueueConfigScopeGreenCtxBalanced
Definition hip_runtime_api.h:788
@ hipGraphMemAttrReservedMemHigh
Definition hip_runtime_api.h:1930
@ hipGraphMemAttrUsedMemCurrent
Amount of memory, in bytes, currently associated with graphs.
Definition hip_runtime_api.h:1924
@ hipGraphMemAttrUsedMemHigh
Definition hip_runtime_api.h:1926
@ hipGraphMemAttrReservedMemCurrent
Definition hip_runtime_api.h:1928
@ hipMemPoolAttrUsedMemCurrent
Definition hip_runtime_api.h:1347
@ hipMemPoolAttrReservedMemHigh
Definition hip_runtime_api.h:1342
@ hipMemPoolAttrReservedMemCurrent
Definition hip_runtime_api.h:1336
@ hipMemPoolAttrReleaseThreshold
Definition hip_runtime_api.h:1331
@ hipMemPoolAttrUsedMemHigh
Definition hip_runtime_api.h:1353
@ hipMemPoolReuseAllowInternalDependencies
Definition hip_runtime_api.h:1322
@ hipMemPoolReuseFollowEventDependencies
Definition hip_runtime_api.h:1309
@ hipMemPoolReuseAllowOpportunistic
Definition hip_runtime_api.h:1315
@ hipDriverEntryPointSuccess
Definition hip_runtime_api.h:839
@ hipDriverEntryPointSymbolNotFound
Definition hip_runtime_api.h:840
@ hipDriverEntryPointVersionNotSufficent
Definition hip_runtime_api.h:841
@ hipMemRangeFlagsMax
Definition hip_runtime_api.h:2278
@ hipMemRangeFlagDmaBufMappingTypePcie
Definition hip_runtime_api.h:2277
@ hipDevSmResourceSplitMaxPotentialClusterSize
Definition hip_runtime_api.h:784
@ hipDevSmResourceSplitIgnoreSmCoscheduling
Definition hip_runtime_api.h:783
@ hipMemOperationTypeMap
Map operation.
Definition hip_runtime_api.h:2064
@ hipMemOperationTypeUnmap
Unmap operation.
Definition hip_runtime_api.h:2065
@ hipGraphicsRegisterFlagsReadOnly
HIP will not write to this registered resource, read only.
Definition hip_runtime_api.h:1608
@ hipGraphicsRegisterFlagsTextureGather
HIP will perform texture gather operations on this registered resource, read and write or read only.
Definition hip_runtime_api.h:1612
@ hipGraphicsRegisterFlagsWriteDiscard
HIP will only write and will not read from this registered resource, write only.
Definition hip_runtime_api.h:1609
@ hipGraphicsRegisterFlagsNone
Definition hip_runtime_api.h:1607
@ hipGraphicsRegisterFlagsSurfaceLoadStore
HIP will bind this resource to a surface, read and write.
Definition hip_runtime_api.h:1611
@ hipMemRangeCoherencyModeFineGrain
Definition hip_runtime_api.h:1274
@ hipMemRangeCoherencyModeIndeterminate
Definition hip_runtime_api.h:1278
@ hipMemRangeCoherencyModeCoarseGrain
Definition hip_runtime_api.h:1276
@ hipMemAccessFlagsProtRead
Set the address range read accessible.
Definition hip_runtime_api.h:1362
@ hipMemAccessFlagsProtNone
Default, make the address range not accessible.
Definition hip_runtime_api.h:1361
@ hipMemAccessFlagsProtReadWrite
Set the address range read-write accessible.
Definition hip_runtime_api.h:1363
@ hipMemAllocationGranularityMinimum
Minimum granularity.
Definition hip_runtime_api.h:2049
@ hipMemAllocationGranularityRecommended
Recommended granularity for performance.
Definition hip_runtime_api.h:2050
@ hipExtDynDataPrefetchTemporalRegular
Regular temporal locality.
Definition hip_runtime_api.h:1753
@ hipExtDynDataPrefetchTemporalHigh
High temporal locality (prefer caching)
Definition hip_runtime_api.h:1754
@ hipGraphExecUpdateErrorNotSupported
The update failed because something about the node is not supported.
Definition hip_runtime_api.h:1901
@ hipGraphExecUpdateErrorNodeTypeChanged
The update failed because a node type changed.
Definition hip_runtime_api.h:1896
@ hipGraphExecUpdateErrorTopologyChanged
The update failed because the topology changed.
Definition hip_runtime_api.h:1895
@ hipGraphExecUpdateErrorUnsupportedFunctionChange
Definition hip_runtime_api.h:1903
@ hipGraphExecUpdateError
Definition hip_runtime_api.h:1893
@ hipGraphExecUpdateErrorFunctionChanged
The update failed because the function of a kernel node changed.
Definition hip_runtime_api.h:1897
@ hipGraphExecUpdateSuccess
The update succeeded.
Definition hip_runtime_api.h:1892
@ hipGraphExecUpdateErrorParametersChanged
The update failed because the parameters changed in a way that is not supported.
Definition hip_runtime_api.h:1899
@ hipStreamCaptureStatusInvalidated
Definition hip_runtime_api.h:1914
@ hipStreamCaptureStatusNone
Stream is not capturing.
Definition hip_runtime_api.h:1912
@ hipStreamCaptureStatusActive
Stream is actively capturing.
Definition hip_runtime_api.h:1913
@ hipDeviceAttributeDirectManagedMemAccessFromHost
Definition hip_runtime_api.h:478
@ hipDeviceAttributeSurfaceAlignment
Alignment requirement for surfaces.
Definition hip_runtime_api.h:568
@ hipDeviceAttributeMaxGridDimX
Max grid size in width.
Definition hip_runtime_api.h:499
@ hipDeviceAttributeMaxSurfaceCubemapLayered
Definition hip_runtime_api.h:508
@ hipDeviceAttributeMaxSurface3D
Maximum dimension (width, height, depth) of 3D surface.
Definition hip_runtime_api.h:506
@ hipDeviceAttributeMaxPitch
Maximum pitch in bytes allowed by memory copies.
Definition hip_runtime_api.h:533
@ hipDeviceAttributeTccDriver
Cuda only. Whether device is a Tesla device using TCC driver.
Definition hip_runtime_api.h:569
@ hipDeviceAttributeHostNativeAtomicSupported
Definition hip_runtime_api.h:481
@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables
Definition hip_runtime_api.h:546
@ hipDeviceAttributeUnused5
Previously hipDeviceAttributeGcnArchName.
Definition hip_runtime_api.h:615
@ hipDeviceAttributeMaxBlockDimY
Max block size in height.
Definition hip_runtime_api.h:497
@ hipDeviceAttributeMaxSurfaceCubemap
Cuda only. Maximum dimensions of Cubemap surface.
Definition hip_runtime_api.h:507
@ hipDeviceAttributePageableMemoryAccess
Definition hip_runtime_api.h:544
@ hipDeviceAttributeClockRate
Peak clock frequency in kilohertz.
Definition hip_runtime_api.h:466
@ hipDeviceAttributeCudaCompatibleEnd
Definition hip_runtime_api.h:606
@ hipDeviceAttributeMaxTexture1DMipmap
Maximum size of 1D mipmapped texture.
Definition hip_runtime_api.h:515
@ hipDeviceAttributeComputeCapabilityMajor
Major compute capability version number.
Definition hip_runtime_api.h:493
@ hipDeviceAttributeGlobalL1CacheSupported
Device supports caching globals in L1.
Definition hip_runtime_api.h:480
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem
Definition hip_runtime_api.h:627
@ hipDeviceAttributeAccessPolicyMaxWindowSize
Definition hip_runtime_api.h:458
@ hipDeviceAttributeMaxTexture3DHeight
Maximum dimension height of 3D texture.
Definition hip_runtime_api.h:525
@ hipDeviceAttributeComputeCapabilityMinor
Minor compute capability version number.
Definition hip_runtime_api.h:536
@ hipDeviceAttributeNumberOfXccs
Definition hip_runtime_api.h:639
@ hipDeviceAttributeMaxTextureCubemap
Maximum dimensions of Cubemap texture.
Definition hip_runtime_api.h:528
@ hipDeviceAttributeGPUDirectRDMASupported
Definition hip_runtime_api.h:594
@ hipDeviceAttributeDeviceOverlap
Definition hip_runtime_api.h:476
@ hipDeviceAttributeMaxTexture2DLinear
Definition hip_runtime_api.h:521
@ hipDeviceAttributeHostAllocDmaBufSupported
Device supports host-allocated DMABuf buffer sharing.
Definition hip_runtime_api.h:593
@ hipDeviceAttributeMaxSurface2D
Maximum dimension (width, height) of 2D surface.
Definition hip_runtime_api.h:504
@ hipDeviceAttributeGPUDirectRDMAFlushWritesOptions
Definition hip_runtime_api.h:597
@ hipDeviceAttributeMaxSurface1DLayered
Cuda only. Maximum dimensions of 1D layered surface.
Definition hip_runtime_api.h:503
@ hipDeviceAttributeHdpRegFlushCntl
Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:617
@ hipDeviceAttributeMaxAvailableVgprsPerThread
Definition hip_runtime_api.h:646
@ hipDeviceAttributeComputeMode
Compute mode that device is currently in.
Definition hip_runtime_api.h:467
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc
Definition hip_runtime_api.h:618
@ hipDeviceAttributeAsicRevision
Revision of the GPU in this device.
Definition hip_runtime_api.h:631
@ hipDeviceAttributeUnused4
Previously hipDeviceAttributeGcnArch.
Definition hip_runtime_api.h:614
@ hipDeviceAttributeCooperativeMultiDeviceLaunch
Definition hip_runtime_api.h:474
@ hipDeviceAttributeMaxTexture2DHeight
Maximum dimension hight of 2D texture.
Definition hip_runtime_api.h:517
@ hipDeviceAttributePersistingL2CacheMaxSize
Maximum l2 persisting lines capacity in bytes.
Definition hip_runtime_api.h:553
@ hipDeviceAttributeEccEnabled
Whether ECC support is enabled.
Definition hip_runtime_api.h:456
@ hipDeviceAttributeDmaBufSupported
Device supports DMABuf buffer sharing.
Definition hip_runtime_api.h:588
@ hipDeviceAttributeExpertSchedMode
Definition hip_runtime_api.h:650
@ hipDeviceAttributeCanUseHostPointerForRegisteredMem
Definition hip_runtime_api.h:463
@ hipDeviceAttributePciBusId
PCI Bus ID.
Definition hip_runtime_api.h:548
@ hipDeviceAttributeL2CacheSize
Definition hip_runtime_api.h:486
@ hipDeviceAttributeKernelExecTimeout
Run time limit for kernels executed on the device.
Definition hip_runtime_api.h:485
@ hipDeviceAttributeMaxThreadsDim
Maximum dimension of a block.
Definition hip_runtime_api.h:530
@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio
Definition hip_runtime_api.h:565
@ hipDeviceAttributeMaxGridDimY
Max grid size in height.
Definition hip_runtime_api.h:500
@ hipDeviceAttributeMultiprocessorCount
Definition hip_runtime_api.h:539
@ hipDeviceAttributeAmdSpecificBegin
Definition hip_runtime_api.h:607
@ hipDeviceAttributeMaxRegistersPerMultiprocessor
32-bit registers available per block.
Definition hip_runtime_api.h:557
@ hipDeviceAttributeIsMultiGpuBoard
Multiple GPU devices.
Definition hip_runtime_api.h:484
@ hipDeviceAttributeSharedMemPerBlockOptin
Definition hip_runtime_api.h:562
@ hipDeviceAttributeMaxSurface2DLayered
Cuda only. Maximum dimensions of 2D layered surface.
Definition hip_runtime_api.h:505
@ hipDeviceAttributeAmdSpecificEnd
Definition hip_runtime_api.h:655
@ hipDeviceAttributeMemoryClockRate
Peak memory clock frequency in kilohertz.
Definition hip_runtime_api.h:535
@ hipDeviceAttributeMaxGridDimZ
Max grid size in depth.
Definition hip_runtime_api.h:501
@ hipDeviceAttributeHdpMemFlushCntl
Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.
Definition hip_runtime_api.h:616
@ hipDeviceAttributeUnused2
Previously hipDeviceAttributeUuid.
Definition hip_runtime_api.h:577
@ hipDeviceAttributeFineGrainSupport
'1' if Device supports fine grain, '0' otherwise
Definition hip_runtime_api.h:637
@ hipDeviceAttributeCooperativeLaunch
Support cooperative launch.
Definition hip_runtime_api.h:473
@ hipDeviceAttributeUnifiedAddressing
Definition hip_runtime_api.h:575
@ hipDeviceAttributeAsyncEngineCount
Asynchronous engines number.
Definition hip_runtime_api.h:460
@ hipDeviceAttributeMultiGpuBoardGroupID
Definition hip_runtime_api.h:537
@ hipDeviceAttributeStreamPrioritiesSupported
Whether to support stream priorities.
Definition hip_runtime_api.h:567
@ hipDeviceAttributeMaxSharedMemoryPerBlock
Definition hip_runtime_api.h:560
@ hipDeviceAttributeLocalL1CacheSupported
caching locals in L1 is supported
Definition hip_runtime_api.h:488
@ hipDeviceAttributeCanUseStreamWaitValue
Definition hip_runtime_api.h:632
@ hipDeviceAttributeMaxRegistersPerBlock
Definition hip_runtime_api.h:554
@ hipDeviceAttributeMaxThreadsPerBlock
Maximum number of threads per block.
Definition hip_runtime_api.h:531
@ hipDeviceAttributePciDomainId
PCI Domain Id.
Definition hip_runtime_api.h:550
@ hipDeviceAttributeMemoryBusWidth
Global memory bus width in bits.
Definition hip_runtime_api.h:534
@ hipDeviceAttributeMemoryPoolSupportedHandleTypes
Definition hip_runtime_api.h:584
@ hipDeviceAttributeComputePreemptionSupported
Device supports Compute Preemption.
Definition hip_runtime_api.h:468
@ hipDeviceAttributeMaxSurface1D
Maximum size of 1D surface.
Definition hip_runtime_api.h:502
@ hipDeviceAttributeUnused1
Previously hipDeviceAttributeName.
Definition hip_runtime_api.h:543
@ hipDeviceAttributeMaxTexture3DAlt
Maximum dimensions of alternate 3D texture.
Definition hip_runtime_api.h:527
@ hipDeviceAttributeMaxTexture1DLinear
Definition hip_runtime_api.h:512
@ hipDeviceAttributeMaxTexture2DGather
Definition hip_runtime_api.h:518
@ hipDeviceAttributeWallClockRate
Constant frequency of wall clock in kilohertz.
Definition hip_runtime_api.h:638
@ hipDeviceAttributePciDeviceId
PCI Device ID. Returns pcie slot id.
Definition hip_runtime_api.h:549
@ hipDeviceAttributeCanMapHostMemory
Definition hip_runtime_api.h:461
@ hipDeviceAttributeMaxTexture1DWidth
Maximum size of 1D texture.
Definition hip_runtime_api.h:510
@ hipDeviceAttributeConcurrentManagedAccess
Definition hip_runtime_api.h:471
@ hipDeviceAttributeVendorSpecificBegin
Definition hip_runtime_api.h:656
@ hipDeviceAttributeManagedMemory
Device supports allocating managed memory on this system.
Definition hip_runtime_api.h:494
@ hipDeviceAttributeHostNumaId
Definition hip_runtime_api.h:586
@ hipDeviceAttributeIntegrated
Device is integrated GPU.
Definition hip_runtime_api.h:483
@ hipDeviceAttributeMaxTexture2DLayered
Maximum dimensions of 2D layered texture.
Definition hip_runtime_api.h:520
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim
Definition hip_runtime_api.h:621
@ hipDeviceAttributeMaxTexture3DDepth
Maximum dimension depth of 3D texture.
Definition hip_runtime_api.h:526
@ hipDeviceAttributePciChipId
GPU Manufacturer device id.
Definition hip_runtime_api.h:649
@ hipDeviceAttributeImageSupport
'1' if Device supports image, '0' otherwise.
Definition hip_runtime_api.h:634
@ hipDeviceAttributeTotalGlobalMem
Global memory available on devicice.
Definition hip_runtime_api.h:574
@ hipDeviceAttributeMaxBlocksPerMultiProcessor
Max block size per multiprocessor.
Definition hip_runtime_api.h:495
@ hipDeviceAttributeHandleTypeFabricSupported
Device supports exporting memory to a fabric handle.
Definition hip_runtime_api.h:592
@ hipDeviceAttributeGPUDirectRDMAWritesOrdering
Definition hip_runtime_api.h:601
@ hipDeviceAttributeIsLargeBar
Whether it is LargeBar.
Definition hip_runtime_api.h:630
@ hipDeviceAttributeMaxTexture2DWidth
Maximum dimension width of 2D texture.
Definition hip_runtime_api.h:516
@ hipDeviceAttributeMaxBlockDimX
Max block size in width.
Definition hip_runtime_api.h:496
@ hipDeviceAttributeMaxTexture3DWidth
Maximum dimension width of 3D texture.
Definition hip_runtime_api.h:524
@ hipDeviceAttributeUnused3
Previously hipDeviceAttributeArch.
Definition hip_runtime_api.h:612
@ hipDeviceAttributeTotalConstantMemory
Constant memory size in bytes.
Definition hip_runtime_api.h:573
@ hipDeviceAttributeTextureAlignment
Alignment requirement for textures.
Definition hip_runtime_api.h:570
@ hipDeviceAttributeMaxTexture1DLayered
Maximum dimensions of 1D layered texture.
Definition hip_runtime_api.h:511
@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor
Maximum Shared Memory PerMultiprocessor.
Definition hip_runtime_api.h:613
@ hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported
Definition hip_runtime_api.h:589
@ hipDeviceAttributeReservedSharedMemPerBlock
Definition hip_runtime_api.h:558
@ hipDeviceAttributeCudaCompatibleBegin
Definition hip_runtime_api.h:454
@ hipDeviceAttributeConcurrentKernels
Definition hip_runtime_api.h:469
@ hipDeviceAttributeLuid
Definition hip_runtime_api.h:489
@ hipDeviceAttributePciDomainID
PCI Domain ID, for backward compatibility.
Definition hip_runtime_api.h:551
@ hipDeviceAttributeMaxThreadsPerMultiProcessor
Maximum resident threads per multiprocessor.
Definition hip_runtime_api.h:532
@ hipDeviceAttributeTexturePitchAlignment
Definition hip_runtime_api.h:571
@ hipDeviceAttributePhysicalMultiProcessorCount
Definition hip_runtime_api.h:635
@ hipDeviceAttributeHostRegisterSupported
Definition hip_runtime_api.h:582
@ hipDeviceAttributeSharedMemPerMultiprocessor
Shared memory available per multiprocessor.
Definition hip_runtime_api.h:564
@ hipDeviceAttributeLuidDeviceNodeMask
Definition hip_runtime_api.h:491
@ hipDeviceAttributeMaxTextureCubemapLayered
Maximum dimensions of Cubemap layered texture.
Definition hip_runtime_api.h:529
@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim
Definition hip_runtime_api.h:624
@ hipDeviceAttributeVirtualMemoryManagementSupported
Definition hip_runtime_api.h:580
@ hipDeviceAttributeMemoryPoolsSupported
Device supports HIP Stream Ordered Memory Allocator.
Definition hip_runtime_api.h:579
@ hipDeviceAttributeClockInstructionRate
Definition hip_runtime_api.h:609
@ hipDeviceAttributeMaxTexture2DMipmap
Maximum dimensions of 2D mipmapped texture.
Definition hip_runtime_api.h:523
@ hipDeviceAttributeMaxDynDataPrefetchRegions
Definition hip_runtime_api.h:652
@ hipDeviceAttributeMaxBlockDimZ
Max block size in depth.
Definition hip_runtime_api.h:498
@ hipDeviceAttributeWarpSize
Warp size in threads.
Definition hip_runtime_api.h:578
@ hipGPUDirectRDMAWritesOrderingOwner
Definition hip_runtime_api.h:701
@ hipGPUDirectRDMAWritesOrderingNone
Definition hip_runtime_api.h:700
@ hipGPUDirectRDMAWritesOrderingAllDevices
Definition hip_runtime_api.h:702
@ hipMemAllocationTypeManaged
Definition hip_runtime_api.h:1384
@ hipMemAllocationTypeMax
Definition hip_runtime_api.h:1386
@ hipMemAllocationTypePinned
Definition hip_runtime_api.h:1383
@ hipMemAllocationTypeUncached
Allocation is uncached memory.
Definition hip_runtime_api.h:1385
@ hipMemAllocationTypeInvalid
Definition hip_runtime_api.h:1379
@ hipClusterSchedulingPolicyDefault
the default scheduling policy
Definition hip_runtime_api.h:1743
@ hipClusterSchedulingPolicyLoadBalancing
Dynamically balance block assignment to optimize resource usage.
Definition hip_runtime_api.h:1745
@ hipClusterSchedulingPolicySpread
distribute blocks evenly across cluster's CUs
Definition hip_runtime_api.h:1744
@ hipMemoryTypeDevice
Definition hip_runtime_api.h:425
@ hipMemoryTypeHost
Memory is physically located on host.
Definition hip_runtime_api.h:424
@ hipMemoryTypeUnregistered
Unregistered memory.
Definition hip_runtime_api.h:423
@ hipMemoryTypeArray
Definition hip_runtime_api.h:430
@ hipMemoryTypeManaged
Definition hip_runtime_api.h:427
@ hipMemoryTypeUnified
unified address space
Definition hip_runtime_api.h:432
@ hipGraphInstantiateFlagAutoFreeOnLaunch
Automatically free memory allocated in a graph before relaunching.
Definition hip_runtime_api.h:1942
@ hipGraphInstantiateFlagUseNodePriority
Definition hip_runtime_api.h:1947
@ hipGraphInstantiateFlagUpload
Automatically upload the graph after instantiation.
Definition hip_runtime_api.h:1944
@ hipGraphInstantiateFlagDeviceLaunch
Instantiate the graph to be launched from the device.
Definition hip_runtime_api.h:1945
@ hipDevResourceTypeWorkqueue
Definition hip_runtime_api.h:776
@ hipDevResourceTypeSm
Definition hip_runtime_api.h:774
@ hipDevResourceTypeInvalid
Definition hip_runtime_api.h:773
@ hipDevResourceTypeWorkqueueConfig
Definition hip_runtime_api.h:775
@ hipArraySparseSubresourceTypeSparseLevel
Sparse level.
Definition hip_runtime_api.h:2072
@ hipArraySparseSubresourceTypeMiptail
Miptail.
Definition hip_runtime_api.h:2073
@ hipFlushGPUDirectRDMAWritesTargetCurrentDevice
Memory of the current HIP device.
Definition hip_runtime_api.h:709
Definition hip_runtime_api.h:2244
Definition hip_runtime_api.h:1706
Definition hip_runtime_api.h:2079
Definition hip_runtime_api.h:2260
Structure representing node parameters for batch memory operations in HIP graphs.
Definition hip_runtime_api.h:1232
Definition hip_runtime_api.h:2129
Definition hip_runtime_api.h:810
Definition hip_runtime_api.h:793
Definition hip_runtime_api.h:822
Definition hip_runtime_api.h:800
Definition hip_runtime_api.h:806
Definition hip_runtime_api.h:53
Definition hip_runtime_api.h:263
Definition hip_runtime_api.h:2144
Definition hip_runtime_api.h:2137
Configuration for dynamic data prefetch.
Definition hip_runtime_api.h:1789
Describes one 2D memory region to prefetch into L2 cache.
Definition hip_runtime_api.h:1765
Definition hip_runtime_api.h:1518
Definition hip_runtime_api.h:1504
Definition hip_runtime_api.h:1524
Definition hip_runtime_api.h:1544
Definition hip_runtime_api.h:2019
Definition hip_runtime_api.h:1558
Definition hip_runtime_api.h:2031
Definition hip_runtime_api.h:1578
Definition hip_runtime_api.h:865
Definition hip_runtime_api.h:1482
Definition hip_runtime_api.h:2201
Definition hip_runtime_api.h:1989
Definition hip_runtime_api.h:2158
Definition hip_runtime_api.h:1662
Definition hip_runtime_api.h:849
Definition hip_runtime_api.h:846
Definition hip_runtime_api.h:1666
Definition hip_runtime_api.h:2220
Definition hip_runtime_api.h:2232
Definition hip_runtime_api.h:1717
Definition hip_runtime_api.h:1471
Definition hip_runtime_api.h:1371
Definition hip_runtime_api.h:1683
Definition hip_runtime_api.h:2001
Definition hip_runtime_api.h:852
Definition hip_runtime_api.h:2151
Definition hip_runtime_api.h:1403
Definition hip_runtime_api.h:1419
Definition hip_runtime_api.h:2120
Definition hip_runtime_api.h:1674
Definition hip_runtime_api.h:439
Definition hip_runtime_api.h:84
Definition hip_runtime_api.h:1816
Union representing batch memory operation parameters for HIP streams.
Definition hip_runtime_api.h:1172
hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)
Sets a kernel node's parameters.
hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)
Returns parameters for memory free node.
hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipMemsetParams *memsetParams, hipCtx_t ctx)
Sets the parameters for a memset node in the given graphExec.
hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t *pDependencies, size_t *pNumDependencies)
Returns a node's dependencies.
hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)
Creates a graph.
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.
hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)
Gets a memcpy node's parameters.
hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)
Set the mem attribute for graphs.
hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)
Sets a memcpy node's parameters.
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.
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.
hipError_t hipGraphNodeFindInClone(hipGraphNode_t *pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph)
Finds a cloned version of a node.
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.
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.
hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)
Get stream's capture state.
hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int *isEnabled)
Query whether a node in the given graphExec is enabled.
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.
hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)
Updates node parameters in the external semaphore signal node.
hipError_t hipGraphDestroyNode(hipGraphNode_t node)
Remove a node from the graph.
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.
hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count)
Release user object from graphs.
hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx)
Creates a memcpy node and adds it to a graph.
hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)
Removes dependency edges from a graph.
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.
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.
hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)
Destroys an executable graph.
hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreSignalNodeParams *nodeParams)
Creates a external semaphor signal node and adds it to a graph.
hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)
Updates node parameters in the external semaphore wait node in the given graphExec.
hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams *pNodeParams)
Sets the parameters for a host node in the given graphExec.
hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph)
Updates node parameters in the child graph node in the given graphExec.
hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus, unsigned long long *pId)
Get capture status of a stream.
hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)
Adds dependency edges to a graph.
hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, hipDeviceptr_t dptr)
Creates a memory free node and adds it to a graph.
hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)
Sets the parameters for a kernel node in the given graphExec.
hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t *pDependentNodes, size_t *pNumDependentNodes)
Returns a node's dependent nodes.
hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)
Get the mem attribute for graphs.
hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)
Returns a host node's parameters.
hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t *pGraphExec, hipGraph_t graph, unsigned long long flags)
Creates an executable graph from a graph.
hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)
Returns external semaphore signal node params.
hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)
Uploads an executable graph to a stream.
hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const hipMemsetParams *memsetParams, hipCtx_t ctx)
Creates a memset node and adds it to a graph.
hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)
Updates node parameters in the external semaphore signal node in the given graphExec.
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.
hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)
Release number of references to resource.
hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)
Gets kernel node's parameters.
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.
hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)
Copies attributes from source node to destination node.
hipError_t hipGraphAddMemFreeNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dev_ptr)
Creates a memory free node and adds it to a graph.
hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)
Sets a memcpy node's parameters.
hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)
Gets a memcpy node's parameters.
hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)
Updates parameters of a graph's node.
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.
hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx)
Sets the parameters for a memcpy node in the given graphExec.
hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)
Begins graph capture on a stream.
hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)
Ends capture on a stream, returning the captured graph.
hipError_t hipGraphExecGetFlags(hipGraphExec_t graphExec, unsigned long long *flags)
Return the flags of an executable graph.
hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count)
Retain number of references to resource.
hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)
Returns a node's type.
hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int isEnabled)
Enables or disables the specified node in the given graphExec.
hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)
Sets the parameters of a memcpy node in the given graphExec.
hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams *nodeParams)
Updates parameters of an executable graph's node.
hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)
Sets a host node's parameters.
hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)
Returns parameters for memory allocation node.
hipError_t hipGraphInstantiateWithParams(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphInstantiateParams *instantiateParams)
Creates an executable graph from a graph.
hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)
Sets the event for an event record node in the given graphExec.
hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)
Updates node parameters in the external semaphore wait node.
hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)
Gets a memset node's parameters.
hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)
Gets a handle to the embedded graph of a child graph node.
hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue *value)
Gets a node's attribute.
hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)
Swaps the stream capture mode of a thread.
hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)
Launches an executable graph in the specified stream.
hipError_t hipGraphDebugDotPrint(hipGraph_t graph, const char *path, unsigned int flags)
Write a DOT file describing graph structure.
hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams *pNodeParams)
Sets the parameters for a memset node in the given graphExec.
hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t *from, hipGraphNode_t *to, size_t *numEdges)
Returns a graph's dependency edges.
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.
hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)
Sets the event for an event record node in the given graphExec.
hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus *captureStatus_out, unsigned long long *id_out, hipGraph_t *graph_out, const hipGraphNode_t **dependencies_out, size_t *numDependencies_out)
Get stream's capture state.
hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph, const hipGraphNode_t *dependencies, const hipGraphEdgeData *dependencyData, size_t numDependencies, hipStreamCaptureMode mode)
Begins graph capture on a stream to an existing graph.
hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreWaitNodeParams *nodeParams)
Creates a external semaphor wait node and adds it to a graph.
hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)
Sets an event wait node's event.
hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)
Sets an event record node's event.
hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)
Returns the event associated with an event wait node.
hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue *value)
Sets a node's attribute.
hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)
Sets a memset node's parameters.
hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)
Returns the event associated with an event record node.
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.
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.
hipError_t hipGraphDestroy(hipGraph_t graph)
Destroys a graph.
hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count, unsigned int flags)
Retain user object for graphs.
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.
hipError_t hipGraphAddMemAllocNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipMemAllocNodeParams *pNodeParams)
Creates a memory allocation node and adds it to a graph.
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.
hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraphNodeParams *nodeParams)
Creates a kernel execution node and adds it to a graph.
hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t *nodes, size_t *numNodes)
Returns a graph's nodes.
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.
hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t *dependencies, size_t numDependencies, unsigned int flags)
Update the set of dependencies in a capturing stream.
hipError_t hipGraphInstantiate(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize)
Creates an executable graph from a graph.
hipError_t hipDeviceGraphMemTrim(int device)
Free unused memory reserved for graphs on a specific device and return it back to the OS.
hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)
Returns external semaphore wait node params.
hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)
Clones a graph.
hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t *pRootNodes, size_t *pNumRootNodes)
Returns a graph's root nodes.
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.
hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)
Unregisters a graphics resource.
hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)
Unmaps graphics resources.
hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t *array, hipGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel)
Get an array through which to access a subresource of a mapped graphics resource.
hipError_t hipGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, hipGraphicsResource_t resource)
Gets device accessible address of a graphics resource.
hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)
Maps a graphics resource for access.
hipLibraryOption
Definition linker_types.h:108
hipJitOption
Definition linker_types.h:31
hipJitInputType
Definition linker_types.h:76
hipError_t hipHostFree(void *ptr)
Free memory allocated by the HIP-Clang hip host memory allocation API This API performs an implicit h...
hipError_t hipMallocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
hipError_t hipMemcpyToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind)
Copies data between host and device [Deprecated].
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 [Deprecated].
hipError_t hipMemAllocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
hipError_t hipMemcpyAtoA(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray, size_t srcOffset, size_t ByteCount)
Copies from one 1D array to another.
hipError_t hipHostAlloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory.
hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, hipStream_t stream)
Perform Batch of 3D copies.
hipError_t hipMemcpy2DArrayToArray(hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst, hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, hipMemcpyKind kind)
Copies data between host and device.
hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream)
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...
hipError_t hipMemcpyAtoHAsync(void *dstHost, hipArray_t srcArray, size_t srcOffset, size_t ByteCount, hipStream_t stream)
Copies from one 1D array to host memory.
hipError_t hipFreeHost(void *ptr)
Frees page-locked memory This API performs an implicit hipDeviceSynchronize() call....
hipError_t hipMemset2DAsync(void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream)
Fills asynchronously the memory area pointed to by dst with the constant value.
hipError_t hipMemGetInfo(size_t *free, size_t *total)
Query memory info.
hipError_t hipExtMallocWithFlags(void **ptr, size_t sizeBytes, unsigned int flags)
Allocate memory on the default accelerator.
hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)
Copies data between host and device.
hipError_t hipMalloc3DArray(hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags)
Allocate an array on the device.
hipError_t hipArrayCreate(hipArray_t *pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray)
Create an array memory pointer on the device.
hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent)
Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
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...
hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset, size_t ByteCount)
Copies from one 1D array to device memory.
hipError_t hipMalloc(void **ptr, size_t size)
Allocate memory on the default accelerator.
hipError_t hipHostUnregister(void *hostPtr)
Un-register host pointer.
hipError_t hipHostGetFlags(unsigned int *flagsPtr, void *hostPtr)
Return flags associated with host pointer.
hipError_t hipMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream)
Copies data from the given symbol on the device asynchronously.
hipError_t hipMemsetD2D32(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height)
Fills 2D memory range of 'width' 32-bit values synchronously to the specified int value....
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...
hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream)
Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
hipError_t hipMemcpyFromSymbol(void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind)
Copies data from the given symbol on the device.
hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)
Copies data between host and device asynchronously.
hipError_t hipMemsetD2D32Async(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height, hipStream_t stream)
Fills 2D memory range of 'width' 32-bit values asynchronously to the specified int value....
hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)
Gets a 3D array descriptor.
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)
Copies data between host and device asynchronously.
hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)
Gets a 1D or 2D array descriptor.
hipError_t hipFree(void *ptr)
Free memory allocated by the HIP-Clang hip memory allocation API. This API performs an implicit hipDe...
hipError_t hipMemcpyHtoAAsync(hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, hipStream_t stream)
Copies from host memory to a 1D array.
hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream)
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...
hipError_t hipGetProcAddress(const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus)
Gets the pointer of requested HIP driver function.
hipError_t hipPointerGetAttributes(hipPointerAttribute_t *attributes, const void *ptr)
Returns attributes for the specified pointer.
hipError_t hipMallocPitch(void **ptr, size_t *pitch, size_t width, size_t height)
hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p)
Performs 3D memory copies between devices This API is asynchronous with respect to host.
hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Device.
hipError_t hipMallocArray(hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags)
Allocate an array on the device.
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.
hipError_t hipExtMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t *sizesDst, hipExtMemcpyWait *waits, hipExtMemcpySignal *signals, size_t count, hipExtMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, hipStream_t stream)
Perform Batch of 1D copies with extended operation support.[BETA].
hipError_t hipHostGetDevicePointer(void **devPtr, void *hstPtr, unsigned int flags)
Get Device pointer from Host Pointer allocated through hipHostMalloc.
hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice, size_t ByteCount)
Copies from device memory to a 1D array.
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)
Copies data between host and device asynchronously.
hipError_t hipMemsetD2D16Async(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height, hipStream_t stream)
Fills 2D memory range of 'width' 16-bit values asynchronously to the specified short value....
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.
hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms *p, hipStream_t stream)
Copies data between host and device asynchronously.
hipError_t hipMemcpy3DWithAttributesAsync(struct hipMemcpy3DBatchOp *op, unsigned long long flags, hipStream_t stream)
Performs 3D memory copy with attributes asynchronously.
hipError_t hipArray3DCreate(hipArray_t *array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray)
Create a 3D array memory pointer on the device.
hipError_t hipArrayGetInfo(hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array)
Gets info about the specified array.
hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)
Copies data between host and device.
hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)
Copies memory for 2D arrays.
hipError_t hipMemcpyHtoA(hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t count)
Copies data between host and device.
hipError_t hipMemcpyToSymbolAsync(const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream)
Copies data to the given symbol on the device asynchronously.
hipError_t hipHostMalloc(void **ptr, size_t size, unsigned int flags)
Allocates device accessible page locked (pinned) host memory.
hipError_t hipMemsetD2D8(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height)
Fills 2D memory range of 'width' 8-bit values synchronously to the specified char value....
hipError_t hipMemcpy2DToArrayAsync(hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream)
Copies data between host and device.
hipError_t hipHostRegister(void *hostPtr, size_t sizeBytes, unsigned int flags)
Register host memory so it can be accessed from the current device.
hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements *memoryRequirements, hipMipmappedArray_t mipmap, hipDevice_t device)
Returns the memory requirements of a HIP mipmapped array.
hipError_t hipMemsetD2D16(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height)
Fills 2D memory range of 'width' 16-bit values synchronously to the specified short value....
hipError_t hipMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, hipMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, hipStream_t stream)
Perform Batch of 1D copies.
hipError_t hipMemcpyAtoH(void *dst, hipArray_t srcArray, size_t srcOffset, size_t count)
Copies data between host and device.
hipError_t hipMemcpyToSymbol(const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind)
Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side...
hipError_t hipMemcpy(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind)
Copy data from src to dst.
hipError_t hipMemcpyWithAttributesAsync(void *dst, const void *src, size_t size, hipMemcpyAttributes *attr, hipStream_t stream)
Performs asynchronous memory copy operation with the specified attributes.
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...
hipError_t hipMemGetAddressRange(hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr)
Get information on memory allocations.
hipError_t hipMemcpy2DToArray(hipArray_t 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.
hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)
Copies memory for 2D arrays.
hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr)
Returns information about the specified pointer.[BETA].
hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)
Create a 3D memory pointer on the device.
hipError_t hipPointerSetAttribute(const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr)
Sets information on the specified pointer.[BETA].
hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Device asynchronously.
hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)
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...
hipError_t hipMemcpyAsync(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)
Copies data from src to dst asynchronously.
hipError_t hipMemcpyDtoHAsync(void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Host asynchronously.
hipError_t hipFreeArray(hipArray_t array)
Frees an array on the device.
hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, const void *src, size_t sizeBytes)
Copy data from Host to Device.
hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count, hipStream_t stream)
Fills the memory area pointed to by dev with the constant integer value for specified number of times...
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.
hipError_t hipGetSymbolSize(size_t *size, const void *symbol)
Gets the size of the given symbol on the device.
hipError_t hipMemcpyDtoH(void *dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Host.
hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, const void *src, size_t sizeBytes, hipStream_t stream)
Copy data from Host to Device asynchronously.
hipError_t hipMemsetAsync(void *dst, int value, size_t sizeBytes, hipStream_t stream)
Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value val...
hipError_t hipMemcpyWithStream(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)
Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multip...
hipError_t hipGetSymbolAddress(void **devPtr, const void *symbol)
Gets device pointer associated with symbol on the device.
hipError_t hipPointerGetAttribute(void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr)
Returns information about the specified pointer.[BETA].
hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height, hipStream_t stream)
Fills 2D memory range of 'width' 8-bit values asynchronously to the specified char value....
hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms *p, hipStream_t stream)
Performs 3D memory copies between devices asynchronously.
hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)
Get allocated memory size via memory pointer.
hipError_t hipArrayDestroy(hipArray_t array)
Destroy an array memory pointer on the device.
hipError_t hipMemPrefetchAsync(const void *dev_ptr, size_t count, int device, hipStream_t stream)
Prefetches memory to the specified destination device using HIP.
hipError_t hipMemPrefetchBatchAsync(void **dev_ptrs, size_t *sizes, size_t count, hipMemLocation *prefetch_locs, size_t *prefetch_loc_idxs, size_t num_prefetch_locs, unsigned long long flags, hipStream_t stream)
Prefetches a batch of memory ranges to the specified locations using HIP.
hipError_t hipMemPrefetchAsync_v2(const void *dev_ptr, size_t count, hipMemLocation location, unsigned int flags, hipStream_t stream)
Prefetches memory to the specified destination device using HIP.
hipError_t hipDrvMemDiscardBatchAsync(hipDeviceptr_t *dptrs, size_t *sizes, size_t count, unsigned long long flags, hipStream_t stream)
Discards a batch of memory ranges asynchronously (driver API variant).
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.
hipError_t hipMemDiscardAndPrefetchBatchAsync(void **dptrs, size_t *sizes, size_t count, hipMemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream)
Discards and prefetches a batch of memory ranges asynchronously.
hipError_t hipDrvMemDiscardAndPrefetchBatchAsync(hipDeviceptr_t *dptrs, size_t *sizes, size_t count, hipMemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream)
Discards and prefetches a batch of memory ranges asynchronously (driver API variant).
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.
hipError_t hipMallocManaged(void **dev_ptr, size_t size, unsigned int flags)
Allocates memory that will be automatically managed by HIP.
hipError_t hipStreamAttachMemAsync(hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags)
Attach memory to a stream asynchronously in HIP.
hipError_t hipMemDiscardBatchAsync(void **dev_ptrs, size_t *sizes, size_t count, unsigned long long flags, hipStream_t stream)
Discards a batch of memory ranges asynchronously.
hipError_t hipMemAdvise_v2(const void *dev_ptr, size_t count, hipMemoryAdvise advice, hipMemLocation location)
hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags)
Launches kernels on multiple devices where thread blocks can cooperate and synchronize as they execut...
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...
hipError_t hipModuleLaunchCooperativeKernel(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)
launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelP...
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...
hipError_t hipModuleEnumerateFunctions(hipFunction_t *functions, unsigned int numFunctions, hipModule_t mod)
Returns the function handles within a module.
hipError_t hipModuleGetTexRef(textureReference **texRef, hipModule_t hmod, const char *name)
returns the handle of the texture reference with the name from the module.
hipError_t hipLibraryGetModule(hipModule_t *pMod, hipLibrary_t library)
Get the module handle backing a library.
hipError_t hipLinkComplete(hipLinkState_t state, void **hipBinOut, size_t *sizeOut)
Completes the linking of the given program.
hipError_t hipModuleGetFunctionCount(unsigned int *count, hipModule_t mod)
Returns the number of functions within a module.
hipError_t hipModuleLoad(hipModule_t *module, const char *fname)
Loads code object from file into a module the currrent context.
hipError_t hipModuleGetGlobal(hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name)
Returns a global pointer from a module.
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....
hipError_t hipLibraryUnload(hipLibrary_t library)
Unload HIP Library.
hipError_t hipLinkAddFile(hipLinkState_t state, hipJitInputType type, const char *path, unsigned int numOptions, hipJitOption *options, void **optionValues)
Adds a file with bitcode to be linked with options.
hipError_t hipGetFuncBySymbol(hipFunction_t *functionPtr, const void *symbolPtr)
Gets pointer to device entry function that matches entry function symbolPtr.
hipError_t hipLinkDestroy(hipLinkState_t state)
Deletes the linker instance.
hipError_t hipLibraryLoadFromFile(hipLibrary_t *library, const char *fileName, hipJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, hipLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions)
Load hip Library from file.
hipError_t hipMemGetHandleForAddressRange(void *handle, hipDeviceptr_t dptr, size_t size, hipMemRangeHandleType handleType, unsigned long long flags)
Returns a handle for the address range requested.
hipError_t hipLibraryEnumerateKernels(hipKernel_t *kernels, unsigned int numKernels, hipLibrary_t library)
Retrieve kernel handles within a library.
hipError_t hipLibraryGetKernel(hipKernel_t *pKernel, hipLibrary_t library, const char *name)
Get Kernel object from library.
hipError_t hipKernelGetName(const char **name, hipKernel_t kernel)
Returns a Kernel Name.
hipError_t hipModuleGetFunction(hipFunction_t *function, hipModule_t module, const char *kname)
Function with kname will be extracted if present in module.
hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption *options, void **optionValues, hipLinkState_t *stateOut)
Creates a linker instance with options.
hipError_t hipLibraryGetGlobal(void **dptr, size_t *bytes, hipLibrary_t library, const char *name)
Get device pointer to a __device__ global variable defined in a library.
hipError_t hipGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult *driverStatus)
Gets function pointer of a requested HIP API.
hipError_t hipModuleLoadData(hipModule_t *module, const void *image)
builds module from code object data which resides in host memory.
hipError_t hipLibraryGetKernelCount(unsigned int *count, hipLibrary_t library)
Get Kernel count in library.
hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t *paramOffset, size_t *paramSize)
Returns the offset and size of a kernel parameter.
hipError_t hipKernelGetAttribute(int *pi, hipFunction_attribute attrib, hipKernel_t kernel, hipDevice_t dev)
Returns information about a kernel.
hipError_t hipModuleLoadFatBinary(hipModule_t *module, const void *fatbin)
Loads fatbin object.
hipError_t hipLibraryLoadData(hipLibrary_t *library, const void *code, hipJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, hipLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions)
Load hip Library from inmemory object.
hipError_t hipModuleUnload(hipModule_t module)
Frees the module.
hipError_t hipKernelGetLibrary(hipLibrary_t *library, hipKernel_t kernel)
Returns a Library Handle.
hipError_t hipLibraryGetManaged(void **dptr, size_t *bytes, hipLibrary_t library, const char *name)
Get host pointer to a __managed__ variable defined in a library.
hipError_t hipLinkAddData(hipLinkState_t state, hipJitInputType type, void *data, size_t size, const char *name, unsigned int numOptions, hipJitOption *options, void **optionValues)
Adds bitcode data to be linked with options.
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)
Returns occupancy for a device function.
hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *f, int numBlocks, int blockSize)
Returns dynamic shared memory available per block when launching numBlocks blocks on SM.
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
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.
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
hipError_t hipOccupancyMaxActiveClusters(int *numClusters, const void *f, const hipLaunchConfig_t *config)
determines the amount of active kernel clusters can co-exist at the same time in a device
hipError_t hipOccupancyMaxPotentialClusterSize(int *clusterSize, const void *f, const hipLaunchConfig_t *config)
returns the maximum cluster size (in number of blocks) that can run on the device
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)
Returns occupancy for a device function.
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
hipError_t hipDeviceCanAccessPeer(int *canAccessPeer, int deviceId, int peerDeviceId)
Determines if a device can access a peer device's memory.
hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)
Enables direct access to memory allocations on a peer device.
hipError_t hipMemcpyPeer(void *dst, int dstDeviceId, const void *src, int srcDeviceId, size_t sizeBytes)
Copies memory between two devices.
hipError_t hipMemcpyPeerAsync(void *dst, int dstDeviceId, const void *src, int srcDevice, size_t sizeBytes, hipStream_t stream)
Copies memory between two devices asynchronously.
hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)
Disables direct access to memory allocations on a peer device.
hipError_t hipProfilerStart()
Start recording of profiling information [Deprecated] When using this API, start the profiler with pr...
hipError_t hipProfilerStop()
Stop recording of profiling information [Deprecated] When using this API, start the profiler with pro...
hipError_t hipStreamGetId(hipStream_t stream, unsigned long long *streamId)
Queries the Id of a stream.
hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)
Returns numerical values that correspond to the least and greatest stream priority.
hipError_t hipStreamDestroy(hipStream_t stream)
Destroys the specified stream.
hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)
Returns flags associated with this stream.
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...
hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src)
Copies attributes from source stream to destination stream.
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition hip_runtime_api.h:3477
hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)
Gets the device associated with the stream.
hipError_t hipStreamQuery(hipStream_t stream)
Returns hipSuccess if all of the operations in the specified stream have completed,...
hipError_t hipStreamSynchronize(hipStream_t stream)
Waits for all commands in the stream to complete.
hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr, const hipStreamAttrValue *value)
Sets stream attribute. Updated attribute is applied to work submitted to the stream.
hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags)
Makes the specified compute stream wait for the specified event.
hipError_t hipStreamCreateWithPriority(hipStream_t *stream, unsigned int flags, int priority)
Creates an asynchronous stream with the specified priority.
hipError_t hipExtStreamCreateWithCUMask(hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask)
Creates an asynchronous stream with the specified CU mask.
hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)
Queries the priority of a stream.
hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask)
Gets CU mask associated with an asynchronous stream.
hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr, hipStreamAttrValue *value_out)
queries stream attribute.
hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)
Creates an asynchronous stream with flag.
hipError_t hipStreamCreate(hipStream_t *stream)
Creates an asynchronous stream.
hipError_t hipStreamWriteValue64(hipStream_t stream, void *ptr, uint64_t value, unsigned int flags)
Enqueues a write command to the stream.[BETA].
hipError_t hipStreamWriteValue32(hipStream_t stream, void *ptr, uint32_t value, unsigned int flags)
Enqueues a write command to the stream.[BETA].
hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipBatchMemOpNodeParams *nodeParams)
Sets the parameters for a batch mem op node in the given graphExec.[BETA].
hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const hipBatchMemOpNodeParams *nodeParams)
Creates a batch memory operation node and adds it to a graph.[BETA].
hipError_t hipStreamWaitValue64(hipStream_t stream, void *ptr, uint64_t value, unsigned int flags, uint64_t mask)
Enqueues a wait command to the stream.[BETA].
hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)
Returns a batch mem op node's parameters.[BETA].
hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count, hipStreamBatchMemOpParams *paramArray, unsigned int flags)
Enqueues an array of stream memory operations in the stream.[BETA].
hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)
Sets the batch mem op node's parameters.[BETA].
hipError_t hipStreamWaitValue32(hipStream_t stream, void *ptr, uint32_t value, unsigned int flags, uint32_t mask)
Enqueues a wait command to the stream.[BETA].
hipError_t hipMemPoolImportPointer(void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data)
Import a memory pool allocation from another process.
hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags)
Imports a memory pool from a shared handle.
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.
hipError_t hipMemGetDefaultMemPool(hipMemPool_t *memPool, hipMemLocation *location, hipMemAllocationType type)
Returns the default memory pool for a given location and allocation type.
hipError_t hipMemSetMemPool(hipMemLocation *location, hipMemAllocationType type, hipMemPool_t pool)
Sets memory pool for memory location and allocation type.
hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)
Frees memory with stream ordered semantics.
hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)
Releases freed memory back to the OS.
hipError_t hipMemPoolCreate(hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props)
Creates a memory pool.
hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count)
Controls visibility of the specified pool between devices.
hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)
Destroys the specified memory pool.
hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)
Sets attributes of a memory pool.
hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)
Gets attributes of a memory pool.
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.
hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)
Export data to share a memory pool allocation between processes.
hipError_t hipMallocAsync(void **dev_ptr, size_t size, hipStream_t stream)
Allocates memory with stream ordered semantics.
hipError_t hipMemPoolGetAccess(hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location)
Returns the accessibility of a pool from a device.
hipError_t hipMemGetMemPool(hipMemPool_t *pool, hipMemLocation *location, hipMemAllocationType type)
Retrieves memory pool for a given memory location and allocation type.
hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)
Destroy a surface object.
hipError_t hipExtEnableLogging()
Enable HIP runtime logging.
hipError_t hipCreateSurfaceObject(hipSurfaceObject_t *pSurfObject, const hipResourceDesc *pResDesc)
Create a surface object.
hipError_t hipExtDisableLogging()
Disable HIP runtime logging.
hipError_t hipExtSetLoggingParams(size_t log_level, size_t log_size, size_t log_mask)
Set HIP runtime logging parameters.
hipError_t hipTexRefGetFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)
Gets filter mode for a texture reference [Deprecated].
hipError_t hipBindTextureToMipmappedArray(const textureReference *tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc *desc)
Binds a mipmapped array to a texture [Deprecated].
hipError_t hipTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, const textureReference *texRef)
Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated].
hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode *pam, const textureReference *texRef, int dim)
Gets the address mode for a texture reference [Deprecated].
hipError_t hipTexRefGetFlags(unsigned int *pFlags, const textureReference *texRef)
Gets flags for a texture reference [Deprecated].
hipError_t hipTexRefSetAddress(size_t *ByteOffset, textureReference *texRef, hipDeviceptr_t dptr, size_t bytes)
Sets an bound address for a texture reference [Deprecated].
hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)
Set filter mode for a texture reference [Deprecated].
hipError_t hipTexRefSetMipmappedArray(textureReference *texRef, struct hipMipmappedArray *mipmappedArray, unsigned int Flags)
Binds mipmapped array to a texture reference [Deprecated].
hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)
Gets the mipmap filter mode for a texture reference [Deprecated].
hipError_t hipGetTextureAlignmentOffset(size_t *offset, const textureReference *texref)
Get the offset of the alignment in a texture [Deprecated].
hipError_t hipBindTexture2D(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t width, size_t height, size_t pitch)
Binds a 2D memory area to a texture [Deprecated].
hipError_t hipTexRefGetMaxAnisotropy(int *pmaxAnsio, const textureReference *texRef)
Gets the maximum anisotropy for a texture reference [Deprecated].
hipError_t hipBindTexture(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t size)
Binds a memory area to a texture [Deprecated].
hipError_t hipUnbindTexture(const textureReference *tex)
Unbinds a texture [Deprecated].
hipError_t hipTexRefGetBorderColor(float *pBorderColor, const textureReference *texRef)
Gets the border color used by a texture reference [Deprecated].
hipError_t hipTexRefSetFormat(textureReference *texRef, hipArray_Format fmt, int NumPackedComponents)
Set format for a texture reference [Deprecated].
hipError_t hipTexRefGetAddress(hipDeviceptr_t *dev_ptr, const textureReference *texRef)
Gets the address for a texture reference [Deprecated].
hipError_t hipTexRefGetArray(hipArray_t *pArray, const textureReference *texRef)
Gets the array bound to a texture reference [Deprecated].
hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)
Set flags for a texture reference [Deprecated].
hipError_t hipTexRefSetAddressMode(textureReference *texRef, int dim, enum hipTextureAddressMode am)
Sets address mode for a texture reference [Deprecated].
hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t *pArray, const textureReference *texRef)
Gets the mipmapped array bound to a texture reference [Deprecated].
hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)
Sets the maximum anisotropy for a texture reference [Deprecated].
hipError_t hipTexRefSetMipmapLevelClamp(textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp)
Sets mipmap level clamp for a texture reference [Deprecated].
hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)
Sets border color for a texture reference [Deprecated].
hipError_t hipTexRefSetArray(textureReference *tex, hipArray_const_t array, unsigned int flags)
Binds an array as a texture reference [Deprecated].
hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)
Sets mipmap level bias for a texture reference [Deprecated].
hipError_t hipTexRefGetMipmapLevelBias(float *pbias, const textureReference *texRef)
Gets the mipmap level bias for a texture reference [Deprecated].
hipError_t hipBindTextureToArray(const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc)
Binds a memory area to a texture [Deprecated].
hipError_t hipGetTextureReference(const textureReference **texref, const void *symbol)
Gets the texture reference related with the symbol [Deprecated].
hipError_t hipTexRefSetAddress2D(textureReference *texRef, const HIP_ARRAY_DESCRIPTOR *desc, hipDeviceptr_t dptr, size_t Pitch)
Set a bind an address as a 2D texture reference [Deprecated].
hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)
Sets mipmap filter mode for a texture reference [Deprecated].
hipError_t hipTexRefGetFormat(hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef)
Gets texture format for a texture reference [Deprecated].
hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)
Frees a mipmapped array on the device.
hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)
Gets a mipmap level of a HIP mipmapped array.
hipError_t hipMipmappedArrayGetLevel(hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level)
Get a mipmapped array on a mipmapped level.
hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)
Destroy a mipmapped array.
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.
hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)
Gets resource descriptor for the texture object.
hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)
Gets resource view descriptor for the texture object.
hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)
Gets texture descriptor of a texture object.
hipError_t hipCreateTextureObject(hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc)
Creates a texture object.
hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)
Destroys a texture object.
hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels)
Create a mipmapped array.
hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)
Gets the channel descriptor in an array.
hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)
Gets resource descriptor of a texture object.
hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)
Gets resource view descriptor of a texture object.
hipError_t hipMallocMipmappedArray(hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags)
Allocate a mipmapped array on the device.
hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)
Destroys a texture object.
hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)
Gets texture descriptor for the texture object.
hipError_t hipMemAddressFree(void *devPtr, size_t size)
Frees an address range reservation made via hipMemAddressReserve.
hipError_t hipMemExportToShareableHandle(void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags)
Exports an allocation to a requested shareable handle type.
hipError_t hipMemGetAccess(unsigned long long *flags, const hipMemLocation *location, void *ptr)
Get the access flags set for the given location and ptr.
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.
hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)
Release a memory handle representing a memory allocation which was previously allocated through hipMe...
hipError_t hipMemUnmap(void *ptr, size_t size)
Unmap memory allocation of a given address range.
hipError_t hipMemGetAllocationGranularity(size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option)
Calculates either the minimal or recommended granularity.
hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)
Returns the allocation handle of the backing memory allocation given the address.
hipError_t hipMemCreate(hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags)
Creates a memory handle for the allocation described by the properties and given size.
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.
hipError_t hipMemAddressReserve(void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags)
Reserves an address range.
hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)
Retrieve the property structure of the given handle.
hipError_t hipMemMapArrayAsync(hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream)
Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType)
Imports an allocation from a requested shareable handle type.
Definition hip_deprecated.h:13
hipErrorStreamDetached
The stream is detached.
Definition hip_runtime_api.h:225
hipErrorIllegalAddress
Definition hip_runtime_api.h:172
hipErrorMemoryAllocation
Memory allocation error.
Definition hip_runtime_api.h:118
hipErrorNotFound
Not found.
Definition hip_runtime_api.h:167
hipErrorProfilerDisabled
Definition hip_runtime_api.h:123
hipErrorInvalidDevicePointer
Invalid Device Pointer.
Definition hip_runtime_api.h:130
@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES
Definition hip_runtime_api.h:41
@ HIP_ERROR_INVALID_VALUE
Definition hip_runtime_api.h:39
@ HIP_SUCCESS
Definition hip_runtime_api.h:38
@ HIP_ERROR_NOT_INITIALIZED
Definition hip_runtime_api.h:40
hipErrorRuntimeMemory
Definition hip_runtime_api.h:228
hipErrorInvalidImage
Invalid image.
Definition hip_runtime_api.h:138
hipErrorPeerAccessUnsupported
Definition hip_runtime_api.h:155
hipErrorArrayIsMapped
Definition hip_runtime_api.h:145
hipErrorStreamCaptureIsolation
Definition hip_runtime_api.h:203
hipErrorInvalidKernelFile
In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.
Definition hip_runtime_api.h:156
hipErrorNotMapped
Definition hip_runtime_api.h:149
hipErrorInvalidClusterSize
calculations
Definition hip_runtime_api.h:232
hipErrorGraphExecUpdateFailure
Definition hip_runtime_api.h:216
hipErrorNotInitialized
Invalid not initialized.
Definition hip_runtime_api.h:119
hipErrorInvalidResourceHandle
Resource handle (hipEvent_t or hipStream_t) invalid.
Definition hip_runtime_api.h:165
hipErrorSharedObjectInitFailed
Failed to initialize shared object.
Definition hip_runtime_api.h:161
hipErrorInvalidPitchValue
Invalid pitch value.
Definition hip_runtime_api.h:128
hipErrorNoBinaryForGpu
Definition hip_runtime_api.h:147
hipErrorInvalidContext
Produced when input context is invalid.
Definition hip_runtime_api.h:139
hipErrorStreamCaptureUnsupported
Definition hip_runtime_api.h:194
hipErrorPeerAccessNotEnabled
Peer access was never enabled from the current device.
Definition hip_runtime_api.h:177
hipErrorOperatingSystem
Not the correct operating system.
Definition hip_runtime_api.h:162
hipErrorStreamCaptureUnjoined
Definition hip_runtime_api.h:201
hipErrorInitializationError
Definition hip_runtime_api.h:121
hipErrorNotMappedAsPointer
Definition hip_runtime_api.h:151
hipErrorPriorLaunchFailure
Definition hip_runtime_api.h:134
hipErrorContextIsDestroyed
The context is already destroyed.
Definition hip_runtime_api.h:179
hipErrorInvalidValue
Definition hip_runtime_api.h:114
hipErrorLaunchTimeOut
Timeout for the launch.
Definition hip_runtime_api.h:174
hipErrorUnmapFailed
Definition hip_runtime_api.h:144
hipErrorSetOnActiveProcess
The process is active.
Definition hip_runtime_api.h:178
hipErrorFileNotFound
the file is not found.
Definition hip_runtime_api.h:159
hipErrorLaunchFailure
An exception occurred on the device while executing a kernel.
Definition hip_runtime_api.h:185
hipErrorInvalidDevice
DeviceID must be in range from 0 to compute-devices.
Definition hip_runtime_api.h:137
hipErrorUnsupportedLimit
Unsupported limit.
Definition hip_runtime_api.h:153
hipErrorMapBufferObjectFailed
Produced when the IPC memory attach failed from ROCr.
Definition hip_runtime_api.h:143
hipErrorHostMemoryAlreadyRegistered
Definition hip_runtime_api.h:181
hipErrorMissingConfiguration
Produced when a kernel launch configuration is missing.
Definition hip_runtime_api.h:133
hipErrorSharedObjectSymbolNotFound
Definition hip_runtime_api.h:160
hipErrorECCNotCorrectable
Definition hip_runtime_api.h:152
hipErrorStreamCaptureWrongThread
Definition hip_runtime_api.h:212
hipErrorAssert
Produced when the kernel calls assert.
Definition hip_runtime_api.h:180
hipErrorContextAlreadyInUse
The context is already in use.
Definition hip_runtime_api.h:154
hipErrorNotReady
Definition hip_runtime_api.h:168
hipErrorInvalidSource
Invalid source.
Definition hip_runtime_api.h:158
hipErrorLaunchOutOfResources
Out of resources error.
Definition hip_runtime_api.h:173
hipErrorNotPermitted
Definition hip_runtime_api.h:190
hipErrorInvalidDeviceFunction
Invalid device function.
Definition hip_runtime_api.h:135
hipErrorCooperativeLaunchTooLarge
Definition hip_runtime_api.h:186
hipErrorAlreadyMapped
Definition hip_runtime_api.h:146
hipErrorInvalidResourceType
Resource type is not valid for the operation.
Definition hip_runtime_api.h:222
hipErrorProfilerNotInitialized
Definition hip_runtime_api.h:124
hipErrorProfilerAlreadyStarted
Definition hip_runtime_api.h:125
hipErrorInvalidChannelDescriptor
Invalid channel descriptor.
Definition hip_runtime_api.h:220
hipErrorNoDevice
Call to hipGetDeviceCount returned 0 devices.
Definition hip_runtime_api.h:136
hipErrorMapFailed
Produced when a memory mapping operation failed.
Definition hip_runtime_api.h:141
hipErrorStreamCaptureInvalidated
Definition hip_runtime_api.h:196
hipErrorProfilerAlreadyStopped
Definition hip_runtime_api.h:126
hipErrorDeinitialized
Deinitialized.
Definition hip_runtime_api.h:122
hipErrorPeerAccessAlreadyEnabled
Definition hip_runtime_api.h:175
hipErrorNotMappedAsArray
Definition hip_runtime_api.h:150
hipErrorNotSupported
Produced when the hip API is not supported/implemented.
Definition hip_runtime_api.h:193
hipErrorInvalidConfiguration
Invalide configuration.
Definition hip_runtime_api.h:127
hipErrorStreamCaptureImplicit
Definition hip_runtime_api.h:207
hipErrorStreamCaptureMerge
Definition hip_runtime_api.h:198
hipErrorInvalidGraphicsContext
Definition hip_runtime_api.h:157
hipErrorIllegalState
Resource required is not in a valid state to perform operation.
Definition hip_runtime_api.h:166
hipErrorOutOfMemory
out of memory range.
Definition hip_runtime_api.h:116
hipErrorInvalidSymbol
Invalid symbol.
Definition hip_runtime_api.h:129
hipSuccess
Successful completion.
Definition hip_runtime_api.h:113
hipErrorUnknown
Unknown error.
Definition hip_runtime_api.h:226
hipErrorInvalidHandle
Invalide handle.
Definition hip_runtime_api.h:163
hipErrorStreamCaptureUnmatched
The capture was not initiated in this stream.
Definition hip_runtime_api.h:200
hipErrorCapturedEvent
Definition hip_runtime_api.h:210
hipErrorAlreadyAcquired
Definition hip_runtime_api.h:148
hipErrorInsufficientDriver
Definition hip_runtime_api.h:132
hipErrorHostMemoryNotRegistered
Definition hip_runtime_api.h:183
hipErrorInvalidTexture
Invalid texture.
Definition hip_runtime_api.h:221
hipErrorRuntimeOther
Definition hip_runtime_api.h:230
hipErrorContextAlreadyCurrent
Definition hip_runtime_api.h:140
hipErrorInvalidMemcpyDirection
Invalid memory copy direction.
Definition hip_runtime_api.h:131
hipErrorInvalidResourceConfiguration
Definition hip_runtime_api.h:223
Definition hip_runtime_api.h:759
hipError_t hip_init()
Definition hip_runtime_api.h:1459
uint32_t y
y
Definition hip_runtime_api.h:1461
uint32_t z
z
Definition hip_runtime_api.h:1462
uint32_t x
x
Definition hip_runtime_api.h:1460
constexpr dim3(uint32_t _x=1, uint32_t _y=1, uint32_t _z=1)
Definition hip_runtime_api.h:1464
Definition texture_types.h:131
Definition texture_types.h:79
Defines surface types for HIP runtime.
struct __hip_surface * hipSurfaceObject_t
Definition surface_types.h:28
struct __hip_texture * hipTextureObject_t
Definition texture_types.h:54
hipTextureAddressMode
Definition texture_types.h:59
hipTextureFilterMode
Definition texture_types.h:69
Definition texture_types.h:100