HIP: Heterogenous-computing Interface for Portability
hip_runtime_api.h
Go to the documentation of this file.
1 /*
2 Copyright (c) 2015 - present Advanced Micro Devices, Inc. All rights reserved.
3 
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10 
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13 
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 THE SOFTWARE.
21 */
22 
23 //#pragma once
24 #ifndef HIP_INCLUDE_HIP_HCC_DETAIL_HIP_RUNTIME_API_H
25 #define HIP_INCLUDE_HIP_HCC_DETAIL_HIP_RUNTIME_API_H
26 
31 #include <stdint.h>
32 #include <stddef.h>
33 
34 #ifndef GENERIC_GRID_LAUNCH
35 #define GENERIC_GRID_LAUNCH 1
36 #endif
37 
38 #ifndef __HIP_VDI__
39 #define __HIP_VDI__ 0
40 #endif
41 
43 #include <hip/hcc_detail/driver_types.h>
46 
47 #if !__HIP_VDI__ && defined(__cplusplus)
48 #include <hsa/hsa.h>
49 #include <hip/hcc_detail/program_state.hpp>
50 #endif
51 
52 #if defined(_MSC_VER)
53 #define DEPRECATED(msg) __declspec(deprecated(msg))
54 #else // !defined(_MSC_VER)
55 #define DEPRECATED(msg) __attribute__ ((deprecated(msg)))
56 #endif // !defined(_MSC_VER)
57 
58 #define DEPRECATED_MSG "This API is marked as deprecated and may not be supported in future releases.For more details please refer https://github.com/ROCm-Developer-Tools/HIP/tree/master/docs/markdown/hip_deprecated_api_list"
59 
60 #if defined(__HCC__) && (__hcc_workweek__ < 16155)
61 #error("This version of HIP requires a newer version of HCC.");
62 #endif
63 
64 #define HIP_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)
65 #define HIP_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)
66 #define HIP_LAUNCH_PARAM_END ((void*)0x03)
67 
68 #ifdef __cplusplus
69  #define __dparm(x) \
70  = x
71 #else
72  #define __dparm(x)
73 #endif
74 
75 #ifdef __GNUC__
76 #pragma GCC visibility push (default)
77 #endif
78 
79 #ifdef __cplusplus
80 
81 namespace hip_impl {
82 hipError_t hip_init();
83 } // namespace hip_impl
84 #endif
85 
86 // Structure definitions:
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90 
91 //---
92 // API-visible structures
93 typedef struct ihipCtx_t* hipCtx_t;
94 
95 // Note many APIs also use integer deviceIds as an alternative to the device pointer:
96 typedef int hipDevice_t;
97 
98 typedef struct ihipStream_t* hipStream_t;
99 
100 // TODO: IPC implementation
101 
102 #define hipIpcMemLazyEnablePeerAccess 0
103 
104 #define HIP_IPC_HANDLE_SIZE 64
105 
106 typedef struct hipIpcMemHandle_st {
107  char reserved[HIP_IPC_HANDLE_SIZE];
109 
110 // TODO: IPC event handle currently unsupported
111 struct ihipIpcEventHandle_t;
112 typedef struct ihipIpcEventHandle_t* hipIpcEventHandle_t;
113 
114 
115 // END TODO
116 
117 typedef struct ihipModule_t* hipModule_t;
118 
119 typedef struct ihipModuleSymbol_t* hipFunction_t;
120 
121 typedef struct hipFuncAttributes {
122  int binaryVersion;
123  int cacheModeCA;
124  size_t constSizeBytes;
125  size_t localSizeBytes;
126  int maxDynamicSharedSizeBytes;
127  int maxThreadsPerBlock;
128  int numRegs;
129  int preferredShmemCarveout;
130  int ptxVersion;
131  size_t sharedSizeBytes;
133 
134 typedef struct ihipEvent_t* hipEvent_t;
135 
136 enum hipLimit_t {
137  hipLimitMallocHeapSize = 0x02,
138 };
139 
144 #define hipStreamDefault \
146  0x00
147 #define hipStreamNonBlocking 0x01
148 
149 
151 #define hipEventDefault 0x0
152 #define hipEventBlockingSync \
153  0x1
154 #define hipEventDisableTiming \
155  0x2
156 #define hipEventInterprocess 0x4
157 #define hipEventReleaseToDevice \
158  0x40000000
159 #define hipEventReleaseToSystem \
162  0x80000000
163 
166 
168 #define hipHostMallocDefault 0x0
169 #define hipHostMallocPortable 0x1
170 #define hipHostMallocMapped \
171  0x2
172 #define hipHostMallocWriteCombined 0x4
174 #define hipHostMallocCoherent \
175  0x40000000
176 #define hipHostMallocNonCoherent \
178  0x80000000
179 
181 #define hipMemAttachGlobal 0x0
182 #define hipMemAttachHost 0x1
183 
184 #define hipDeviceMallocDefault 0x0
185 #define hipDeviceMallocFinegrained 0x1
186 
187 #define hipHostRegisterDefault 0x0
189 #define hipHostRegisterPortable 0x1
190 #define hipHostRegisterMapped \
191  0x2
192 #define hipHostRegisterIoMemory 0x4
194 #define hipExtHostRegisterCoarseGrained 0x8
195 
196 #define hipDeviceScheduleAuto 0x0
197 #define hipDeviceScheduleSpin \
198  0x1
199 #define hipDeviceScheduleYield \
201  0x2
202 #define hipDeviceScheduleBlockingSync 0x4
204 #define hipDeviceScheduleMask 0x7
205 
206 #define hipDeviceMapHost 0x8
207 #define hipDeviceLmemResizeToMax 0x16
208 
209 #define hipArrayDefault 0x00
210 #define hipArrayLayered 0x01
211 #define hipArraySurfaceLoadStore 0x02
212 #define hipArrayCubemap 0x04
213 #define hipArrayTextureGather 0x08
214 
215 /*
216  * @brief hipJitOption
217  * @enum
218  * @ingroup Enumerations
219  */
220 typedef enum hipJitOption {
221  hipJitOptionMaxRegisters = 0,
222  hipJitOptionThreadsPerBlock,
223  hipJitOptionWallTime,
224  hipJitOptionInfoLogBuffer,
225  hipJitOptionInfoLogBufferSizeBytes,
226  hipJitOptionErrorLogBuffer,
227  hipJitOptionErrorLogBufferSizeBytes,
228  hipJitOptionOptimizationLevel,
229  hipJitOptionTargetFromContext,
230  hipJitOptionTarget,
231  hipJitOptionFallbackStrategy,
232  hipJitOptionGenerateDebugInfo,
233  hipJitOptionLogVerbose,
234  hipJitOptionGenerateLineInfo,
235  hipJitOptionCacheMode,
236  hipJitOptionSm3xOpt,
237  hipJitOptionFastCompile,
238  hipJitOptionNumOptions
239 } hipJitOption;
240 
241 
245 typedef enum hipFuncCache_t {
251 
252 
256 typedef enum hipSharedMemConfig {
263 
264 
269 typedef struct dim3 {
270  uint32_t x;
271  uint32_t y;
272  uint32_t z;
273 #ifdef __cplusplus
274  __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1) : x(_x), y(_y), z(_z){};
275 #endif
276 } dim3;
277 
278 typedef struct hipLaunchParams_t {
279  void* func;
282  void **args;
283  size_t sharedMem;
284  hipStream_t stream;
286 
287 
288 // Doxygen end group GlobalDefs
292 //-------------------------------------------------------------------------------------------------
293 
294 
295 // The handle allows the async commands to use the stream even if the parent hipStream_t goes
296 // out-of-scope.
297 // typedef class ihipStream_t * hipStream_t;
298 
299 
300 /*
301  * Opaque structure allows the true event (pointed at by the handle) to remain "live" even if the
302  * surrounding hipEvent_t goes out-of-scope. This is handy for cases where the hipEvent_t goes
303  * out-of-scope but the true event is being written by some async queue or device */
304 // typedef struct hipEvent_t {
305 // struct ihipEvent_t *_handle;
306 //} hipEvent_t;
307 
308 
334 hipError_t hipDeviceSynchronize(void);
335 
336 
348 hipError_t hipDeviceReset(void);
349 
350 
382 hipError_t hipSetDevice(int deviceId);
383 
384 
398 hipError_t hipGetDevice(int* deviceId);
399 
400 
413 hipError_t hipGetDeviceCount(int* count);
414 
424 hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int deviceId);
425 
439 hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId);
440 
441 
452 hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);
453 
454 
465 hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);
466 
477 hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit);
478 
479 
490 hipError_t hipFuncSetCacheConfig(const void* func, hipFuncCache_t config);
491 
503 hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);
504 
505 
517 hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);
518 
543 hipError_t hipSetDeviceFlags(unsigned flags);
544 
553 hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop);
554 
567 hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype, uint32_t* hopcount);
568 
569 // end doxygen Device
592 hipError_t hipGetLastError(void);
593 
594 
605 hipError_t hipPeekAtLastError(void);
606 
607 
616 const char* hipGetErrorName(hipError_t hip_error);
617 
618 
629 const char* hipGetErrorString(hipError_t hipError);
630 
631 // end doxygen Error
664 hipError_t hipStreamCreate(hipStream_t* stream);
665 
666 
684 hipError_t hipStreamCreateWithFlags(hipStream_t* stream, unsigned int flags);
685 
686 
705 hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority);
706 
707 
722 hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority);
723 
724 
743 hipError_t hipStreamDestroy(hipStream_t stream);
744 
745 
761 hipError_t hipStreamQuery(hipStream_t stream);
762 
763 
783 hipError_t hipStreamSynchronize(hipStream_t stream);
784 
785 
805 hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags);
806 
807 
821 hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags);
822 
823 
837 hipError_t hipStreamGetPriority(hipStream_t stream, int* priority);
838 
839 
843 typedef void (*hipStreamCallback_t)(hipStream_t stream, hipError_t status, void* userData);
844 
860 hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void* userData,
861  unsigned int flags);
862 
863 
864 // end doxygen Stream
901 hipError_t hipEventCreateWithFlags(hipEvent_t* event, unsigned flags);
902 
903 
915 hipError_t hipEventCreate(hipEvent_t* event);
916 
917 
945 #ifdef __cplusplus
946 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream = NULL);
947 #else
948 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);
949 #endif
950 
967 hipError_t hipEventDestroy(hipEvent_t event);
968 
969 
987 hipError_t hipEventSynchronize(hipEvent_t event);
988 
989 
1018 hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop);
1019 
1020 
1036 hipError_t hipEventQuery(hipEvent_t event);
1037 
1038 
1039 // end doxygen Events
1070 hipError_t hipPointerGetAttributes(hipPointerAttribute_t* attributes, const void* ptr);
1071 
1085 hipError_t hipMalloc(void** ptr, size_t size);
1086 
1101 hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags);
1102 
1115 DEPRECATED("use hipHostMalloc instead")
1116 hipError_t hipMallocHost(void** ptr, size_t size);
1117 
1130 DEPRECATED("use hipHostMalloc instead")
1131 hipError_t hipMemAllocHost(void** ptr, size_t size);
1132 
1146 hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags);
1147 
1157 hipError_t hipMallocManaged(void** devPtr, size_t size, unsigned int flags __dparm(0));
1158 
1172 DEPRECATED("use hipHostMalloc instead")
1173 hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags);
1174 
1186 hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags);
1187 
1197 hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr);
1198 
1235 hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags);
1236 
1245 hipError_t hipHostUnregister(void* hostPtr);
1246 
1266 hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height);
1267 
1290 hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes);
1291 
1305 hipError_t hipFree(void* ptr);
1306 
1317 DEPRECATED("use hipHostFree instead")
1318 hipError_t hipFreeHost(void* ptr);
1319 
1333 hipError_t hipHostFree(void* ptr);
1334 
1362 hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);
1363 
1364 // TODO: Add description
1365 hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes,
1366  hipMemcpyKind kind, hipStream_t stream);
1384 hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void* src, size_t sizeBytes);
1385 
1403 hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes);
1404 
1422 hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes);
1423 
1441 hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void* src, size_t sizeBytes, hipStream_t stream);
1442 
1460 hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream);
1461 
1479 hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,
1480  hipStream_t stream);
1481 
1482 #if __HIP_VDI__
1483 hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,
1484  hipModule_t hmod, const char* name);
1485 
1486 hipError_t hipGetSymbolAddress(void** devPtr, const void* symbolName);
1487 hipError_t hipGetSymbolSize(size_t* size, const void* symbolName);
1488 hipError_t hipMemcpyToSymbol(const void* symbolName, const void* src,
1489  size_t sizeBytes, size_t offset __dparm(0),
1490  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));
1491 hipError_t hipMemcpyToSymbolAsync(const void* symbolName, const void* src,
1492  size_t sizeBytes, size_t offset,
1493  hipMemcpyKind kind, hipStream_t stream __dparm(0));
1494 hipError_t hipMemcpyFromSymbol(void* dst, const void* symbolName,
1495  size_t sizeBytes, size_t offset __dparm(0),
1496  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));
1497 hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbolName,
1498  size_t sizeBytes, size_t offset,
1499  hipMemcpyKind kind,
1500  hipStream_t stream __dparm(0));
1501 #else
1502 hipError_t hipModuleGetGlobal(void**, size_t*, hipModule_t, const char*);
1503 
1504 #ifdef __cplusplus //Start : Not supported in gcc
1505 namespace hip_impl {
1506 inline
1507 __attribute__((visibility("hidden")))
1508 hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
1509  const char* name);
1510 } // Namespace hip_impl.
1511 
1512 
1523 inline
1524 __attribute__((visibility("hidden")))
1525 hipError_t hipGetSymbolAddress(void** devPtr, const void* symbolName) {
1526  //HIP_INIT_API(hipGetSymbolAddress, devPtr, symbolName);
1527  hip_impl::hip_init();
1528  size_t size = 0;
1529  return hip_impl::read_agent_global_from_process(devPtr, &size, (const char*)symbolName);
1530 }
1531 
1532 
1543 inline
1544 __attribute__((visibility("hidden")))
1545 hipError_t hipGetSymbolSize(size_t* size, const void* symbolName) {
1546  // HIP_INIT_API(hipGetSymbolSize, size, symbolName);
1547  hip_impl::hip_init();
1548  void* devPtr = nullptr;
1549  return hip_impl::read_agent_global_from_process(&devPtr, size, (const char*)symbolName);
1550 }
1551 #endif // End : Not supported in gcc
1552 
1553 #if defined(__cplusplus)
1554 } // extern "C"
1555 #endif
1556 
1557 #ifdef __cplusplus
1558 namespace hip_impl {
1559 hipError_t hipMemcpyToSymbol(void*, const void*, size_t, size_t, hipMemcpyKind,
1560  const char*);
1561 } // Namespace hip_impl.
1562 #endif
1563 
1564 #if defined(__cplusplus)
1565 extern "C" {
1566 #endif
1567 
1591 #ifdef __cplusplus
1592 inline
1593 __attribute__((visibility("hidden")))
1594 hipError_t hipMemcpyToSymbol(const void* symbolName, const void* src,
1595  size_t sizeBytes, size_t offset __dparm(0),
1596  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {
1597  if (!symbolName) return hipErrorInvalidSymbol;
1598 
1599  hipDeviceptr_t dst = NULL;
1600  hipGetSymbolAddress(&dst, (const char*)symbolName);
1601 
1602  return hip_impl::hipMemcpyToSymbol(dst, src, sizeBytes, offset, kind,
1603  (const char*)symbolName);
1604 }
1605 #endif
1606 
1607 #if defined(__cplusplus)
1608 } // extern "C"
1609 #endif
1610 
1611 #ifdef __cplusplus
1612 namespace hip_impl {
1613 hipError_t hipMemcpyToSymbolAsync(void*, const void*, size_t, size_t,
1614  hipMemcpyKind, hipStream_t, const char*);
1615 hipError_t hipMemcpyFromSymbol(void*, const void*, size_t, size_t,
1616  hipMemcpyKind, const char*);
1617 hipError_t hipMemcpyFromSymbolAsync(void*, const void*, size_t, size_t,
1618  hipMemcpyKind, hipStream_t, const char*);
1619 } // Namespace hip_impl.
1620 #endif
1621 
1622 #if defined(__cplusplus)
1623 extern "C" {
1624 #endif
1625 
1652 #ifdef __cplusplus //Start : Not supported in gcc
1653 inline
1654 __attribute__((visibility("hidden")))
1655 hipError_t hipMemcpyToSymbolAsync(const void* symbolName, const void* src,
1656  size_t sizeBytes, size_t offset,
1657  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
1658  if (!symbolName) return hipErrorInvalidSymbol;
1659 
1660  hipDeviceptr_t dst = NULL;
1661  hipGetSymbolAddress(&dst, symbolName);
1662 
1663  return hip_impl::hipMemcpyToSymbolAsync(dst, src, sizeBytes, offset, kind,
1664  stream,
1665  (const char*)symbolName);
1666 }
1667 
1668 inline
1669 __attribute__((visibility("hidden")))
1670 hipError_t hipMemcpyFromSymbol(void* dst, const void* symbolName,
1671  size_t sizeBytes, size_t offset __dparm(0),
1672  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {
1673  if (!symbolName) return hipErrorInvalidSymbol;
1674 
1675  hipDeviceptr_t src = NULL;
1676  hipGetSymbolAddress(&src, symbolName);
1677 
1678  return hip_impl::hipMemcpyFromSymbol(dst, src, sizeBytes, offset, kind,
1679  (const char*)symbolName);
1680 }
1681 
1682 inline
1683 __attribute__((visibility("hidden")))
1684 hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbolName,
1685  size_t sizeBytes, size_t offset,
1686  hipMemcpyKind kind,
1687  hipStream_t stream __dparm(0)) {
1688  if (!symbolName) return hipErrorInvalidSymbol;
1689 
1690  hipDeviceptr_t src = NULL;
1691  hipGetSymbolAddress(&src, symbolName);
1692 
1693  return hip_impl::hipMemcpyFromSymbolAsync(dst, src, sizeBytes, offset, kind,
1694  stream,
1695  (const char*)symbolName);
1696 }
1697 #endif // End : Not supported in gcc
1698 
1699 #endif // __HIP_VDI__
1700 
1728 hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,
1729  hipStream_t stream __dparm(0));
1730 
1740 hipError_t hipMemset(void* dst, int value, size_t sizeBytes);
1741 
1751 hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count);
1752 
1768 hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0));
1769 
1779 hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count);
1780 
1796 hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0));
1797 
1807 hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count);
1808 
1824 hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0));
1825 
1841 hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count,
1842  hipStream_t stream __dparm(0));
1843 
1855 hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height);
1856 
1869 hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,hipStream_t stream __dparm(0));
1870 
1879 hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent );
1880 
1890 hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent ,hipStream_t stream __dparm(0));
1891 
1901 hipError_t hipMemGetInfo(size_t* free, size_t* total);
1902 
1903 
1904 hipError_t hipMemPtrGetInfo(void* ptr, size_t* size);
1905 
1906 
1919 hipError_t hipMallocArray(hipArray** array, const hipChannelFormatDesc* desc, size_t width,
1920  size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault));
1921 hipError_t hipArrayCreate(hipArray** pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray);
1922 
1923 hipError_t hipArray3DCreate(hipArray** array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);
1924 
1925 hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent);
1926 
1935 hipError_t hipFreeArray(hipArray* array);
1936 
1949 hipError_t hipMalloc3DArray(hipArray** array, const struct hipChannelFormatDesc* desc,
1950  struct hipExtent extent, unsigned int flags);
1967 hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
1968  size_t height, hipMemcpyKind kind);
1969 
1979 hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);
1980 
1991 hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D* pCopy, hipStream_t stream __dparm(0));
1992 
2010 hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
2011  size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));
2012 
2029 hipError_t hipMemcpy2DToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
2030  size_t spitch, size_t width, size_t height, hipMemcpyKind kind);
2031 
2048 hipError_t hipMemcpyToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
2049  size_t count, hipMemcpyKind kind);
2050 
2066 hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,
2067  size_t count, hipMemcpyKind kind);
2068 
2086 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);
2087 
2106 hipError_t hipMemcpy2DFromArrayAsync( void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));
2107 
2121 hipError_t hipMemcpyAtoH(void* dst, hipArray* srcArray, size_t srcOffset, size_t count);
2122 
2136 hipError_t hipMemcpyHtoA(hipArray* dstArray, size_t dstOffset, const void* srcHost, size_t count);
2137 
2148 hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);
2149 
2161 hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms* p, hipStream_t stream __dparm(0));
2162 
2163 // doxygen end Memory
2195 hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId);
2196 
2197 
2214 hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags);
2215 
2216 
2228 hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);
2229 
2242 hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr);
2243 
2244 #ifndef USE_PEER_NON_UNIFIED
2245 #define USE_PEER_NON_UNIFIED 1
2246 #endif
2247 
2248 #if USE_PEER_NON_UNIFIED == 1
2249 
2260 hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId,
2261  size_t sizeBytes);
2262 
2275 hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice,
2276  size_t sizeBytes, hipStream_t stream __dparm(0));
2277 #endif
2278 
2279 
2280 // doxygen end PeerToPeer
2299 // TODO-ctx - more description on error codes.
2300 hipError_t hipInit(unsigned int flags);
2301 
2302 
2322 DEPRECATED(DEPRECATED_MSG)
2323 hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);
2324 
2335 DEPRECATED(DEPRECATED_MSG)
2336 hipError_t hipCtxDestroy(hipCtx_t ctx);
2337 
2348 DEPRECATED(DEPRECATED_MSG)
2349 hipError_t hipCtxPopCurrent(hipCtx_t* ctx);
2350 
2361 DEPRECATED(DEPRECATED_MSG)
2362 hipError_t hipCtxPushCurrent(hipCtx_t ctx);
2363 
2374 DEPRECATED(DEPRECATED_MSG)
2375 hipError_t hipCtxSetCurrent(hipCtx_t ctx);
2376 
2387 DEPRECATED(DEPRECATED_MSG)
2388 hipError_t hipCtxGetCurrent(hipCtx_t* ctx);
2389 
2401 DEPRECATED(DEPRECATED_MSG)
2402 hipError_t hipCtxGetDevice(hipDevice_t* device);
2403 
2421 DEPRECATED(DEPRECATED_MSG)
2422 hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int* apiVersion);
2423 
2437 DEPRECATED(DEPRECATED_MSG)
2438 hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);
2439 
2453 DEPRECATED(DEPRECATED_MSG)
2454 hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);
2455 
2469 DEPRECATED(DEPRECATED_MSG)
2470 hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);
2471 
2485 DEPRECATED(DEPRECATED_MSG)
2486 hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);
2487 
2499 DEPRECATED(DEPRECATED_MSG)
2500 hipError_t hipCtxSynchronize(void);
2501 
2512 DEPRECATED(DEPRECATED_MSG)
2513 hipError_t hipCtxGetFlags(unsigned int* flags);
2514 
2534 DEPRECATED(DEPRECATED_MSG)
2535 hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags);
2536 
2553 DEPRECATED(DEPRECATED_MSG)
2554 hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);
2555 
2568 hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active);
2569 
2582 hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);
2583 
2595 hipError_t hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev);
2596 
2607 hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);
2608 
2620 hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags);
2621 
2622 // doxygen end Context Management
2634 hipError_t hipDeviceGet(hipDevice_t* device, int ordinal);
2635 
2644 hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device);
2645 
2654 hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device);
2655 
2664 hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device);
2665 
2666 
2674 hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId);
2675 
2676 
2684 hipError_t hipDeviceTotalMem(size_t* bytes, hipDevice_t device);
2685 
2701 hipError_t hipDriverGetVersion(int* driverVersion);
2702 
2715 hipError_t hipRuntimeGetVersion(int* runtimeVersion);
2716 
2728 hipError_t hipModuleLoad(hipModule_t* module, const char* fname);
2729 
2740 hipError_t hipModuleUnload(hipModule_t module);
2741 
2752 hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname);
2753 
2763 hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func);
2764 
2774 hipError_t hipFuncGetAttribute(int* value, hipFunction_attribute attrib, hipFunction_t hfunc);
2775 
2776 #if !__HIP_VDI__
2777 #if defined(__cplusplus)
2778 } // extern "C"
2779 #endif
2780 
2781 #ifdef __cplusplus
2782 namespace hip_impl {
2783  class agent_globals_impl;
2784  class agent_globals {
2785  public:
2786  agent_globals();
2787  ~agent_globals();
2788  agent_globals(const agent_globals&) = delete;
2789 
2790  hipError_t read_agent_global_from_module(hipDeviceptr_t* dptr, size_t* bytes,
2791  hipModule_t hmod, const char* name);
2792  hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
2793  const char* name);
2794  private:
2795  agent_globals_impl* impl;
2796  };
2797 
2798  inline
2799  __attribute__((visibility("hidden")))
2800  agent_globals& get_agent_globals() {
2801  static agent_globals ag;
2802  return ag;
2803  }
2804 
2805  extern "C"
2806  inline
2807  __attribute__((visibility("hidden")))
2808  hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
2809  const char* name) {
2810  return get_agent_globals().read_agent_global_from_process(dptr, bytes, name);
2811  }
2812 } // Namespace hip_impl.
2813 #endif
2814 
2815 #if defined(__cplusplus)
2816 extern "C" {
2817 #endif
2818 
2829 hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,
2830  hipModule_t hmod, const char* name);
2831 #endif // __HIP_VDI__
2832 
2833 hipError_t hipModuleGetTexRef(textureReference** texRef, hipModule_t hmod, const char* name);
2834 
2844 hipError_t hipModuleLoadData(hipModule_t* module, const void* image);
2845 
2858 hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions,
2859  hipJitOption* options, void** optionValues);
2860 
2885 hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY,
2886  unsigned int gridDimZ, unsigned int blockDimX,
2887  unsigned int blockDimY, unsigned int blockDimZ,
2888  unsigned int sharedMemBytes, hipStream_t stream,
2889  void** kernelParams, void** extra);
2890 
2891 
2892 #if __HIP_VDI__ && !defined(__HCC__)
2893 
2908 hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX,
2909  void** kernelParams, unsigned int sharedMemBytes,
2910  hipStream_t stream);
2911 
2922 hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
2923  int numDevices, unsigned int flags);
2924 
2925 #endif
2926 
2938 hipError_t hipOccupancyMaxPotentialBlockSize(uint32_t* gridSize, uint32_t* blockSize,
2939  hipFunction_t f, size_t dynSharedMemPerBlk,
2940  uint32_t blockSizeLimit);
2941 
2951  uint32_t* numBlocks, hipFunction_t f, uint32_t blockSize, size_t dynSharedMemPerBlk);
2952 
2963  uint32_t* numBlocks, hipFunction_t f, uint32_t blockSize, size_t dynSharedMemPerBlk, unsigned int flags);
2964 
2965 #if __HIP_VDI__ && !defined(__HCC__)
2966 
2977 hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,
2978  int numDevices, unsigned int flags);
2979 
2980 #endif
2981 
2982 // doxygen end Version Management
3000 // TODO - expand descriptions:
3006 DEPRECATED("use roctracer/rocTX instead")
3007 hipError_t hipProfilerStart();
3008 
3009 
3015 DEPRECATED("use roctracer/rocTX instead")
3016 hipError_t hipProfilerStop();
3017 
3018 
3023 // TODO: implement IPC apis
3024 
3050 hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr);
3051 
3088 hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);
3089 
3108 hipError_t hipIpcCloseMemHandle(void* devPtr);
3109 
3110 
3111 // hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr);
3112 // hipError_t hipIpcCloseMemHandle(void *devPtr);
3113 // // hipError_t hipIpcOpenEventHandle(hipEvent_t* event, hipIpcEventHandle_t handle);
3114 // hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);
3115 
3116 
3137 hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0));
3138 
3139 
3150 hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);
3151 
3152 
3161 hipError_t hipLaunchByPtr(const void* func);
3162 
3163 
3178 hipError_t __hipPushCallConfiguration(dim3 gridDim,
3179  dim3 blockDim,
3180  size_t sharedMem __dparm(0),
3181  hipStream_t stream __dparm(0));
3182 
3196 hipError_t __hipPopCallConfiguration(dim3 *gridDim,
3197  dim3 *blockDim,
3198  size_t *sharedMem,
3199  hipStream_t *stream);
3200 
3217 hipError_t hipLaunchKernel(const void* function_address,
3218  dim3 numBlocks,
3219  dim3 dimBlocks,
3220  void** args,
3221  size_t sharedMemBytes __dparm(0),
3222  hipStream_t stream __dparm(0));
3223 
3229 #ifdef __cplusplus
3230 } /* extern "c" */
3231 #endif
3232 
3233 #if defined(__cplusplus) && !defined(__HCC__) && defined(__clang__) && defined(__HIP__)
3234 template <typename F>
3236  uint32_t* numBlocks, F func, uint32_t blockSize, size_t dynSharedMemPerBlk) {
3237  return ::hipOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, (hipFunction_t)func, blockSize,
3238  dynSharedMemPerBlk);
3239 }
3240 template <typename F>
3242  uint32_t* numBlocks, F func, uint32_t blockSize, size_t dynSharedMemPerBlk, unsigned int flags) {
3244  numBlocks, (hipFunction_t)func, blockSize, dynSharedMemPerBlk, flags);
3245 }
3246 #endif // defined(__cplusplus) && !defined(__HCC__) && defined(__clang__) && defined(__HIP__)
3247 
3248 #if USE_PROF_API
3249 #include <hip/hcc_detail/hip_prof_str.h>
3250 #endif
3251 
3252 #ifdef __cplusplus
3253 extern "C" {
3254 #endif
3255 
3258 hipError_t hipRegisterApiCallback(uint32_t id, void* fun, void* arg);
3259 hipError_t hipRemoveApiCallback(uint32_t id);
3260 hipError_t hipRegisterActivityCallback(uint32_t id, void* fun, void* arg);
3261 hipError_t hipRemoveActivityCallback(uint32_t id);
3262 const char* hipApiName(uint32_t id);
3263 const char* hipKernelNameRef(const hipFunction_t f);
3264 #ifdef __cplusplus
3265 } /* extern "C" */
3266 #endif
3267 
3268 #ifdef __cplusplus
3269 
3270 class TlsData;
3271 
3272 hipError_t hipBindTexture(size_t* offset, textureReference* tex, const void* devPtr,
3273  const hipChannelFormatDesc* desc, size_t size = UINT_MAX);
3274 
3275 hipError_t ihipBindTextureImpl(TlsData *tls, int dim, enum hipTextureReadMode readMode, size_t* offset,
3276  const void* devPtr, const struct hipChannelFormatDesc* desc,
3277  size_t size, textureReference* tex);
3278 
3279 /*
3280  * @brief hipBindTexture Binds size bytes of the memory area pointed to by @p devPtr to the texture
3281  *reference tex.
3282  *
3283  * @p desc describes how the memory is interpreted when fetching values from the texture. The @p
3284  *offset parameter is an optional byte offset as with the low-level hipBindTexture() function. Any
3285  *memory previously bound to tex is unbound.
3286  *
3287  * @param[in] offset - Offset in bytes
3288  * @param[out] tex - texture to bind
3289  * @param[in] devPtr - Memory area on device
3290  * @param[in] desc - Channel format
3291  * @param[in] size - Size of the memory area pointed to by devPtr
3292  * @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknown
3293  **/
3294 template <class T, int dim, enum hipTextureReadMode readMode>
3295 hipError_t hipBindTexture(size_t* offset, struct texture<T, dim, readMode>& tex, const void* devPtr,
3296  const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) {
3297  return ihipBindTextureImpl(nullptr, dim, readMode, offset, devPtr, &desc, size, &tex);
3298 }
3299 
3300 /*
3301  * @brief hipBindTexture Binds size bytes of the memory area pointed to by @p devPtr to the texture
3302  *reference tex.
3303  *
3304  * @p desc describes how the memory is interpreted when fetching values from the texture. The @p
3305  *offset parameter is an optional byte offset as with the low-level hipBindTexture() function. Any
3306  *memory previously bound to tex is unbound.
3307  *
3308  * @param[in] offset - Offset in bytes
3309  * @param[in] tex - texture to bind
3310  * @param[in] devPtr - Memory area on device
3311  * @param[in] size - Size of the memory area pointed to by devPtr
3312  * @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknown
3313  **/
3314 template <class T, int dim, enum hipTextureReadMode readMode>
3315 hipError_t hipBindTexture(size_t* offset, struct texture<T, dim, readMode>& tex, const void* devPtr,
3316  size_t size = UINT_MAX) {
3317  return ihipBindTextureImpl(nullptr, dim, readMode, offset, devPtr, &(tex.channelDesc), size, &tex);
3318 }
3319 
3320 // C API
3321 hipError_t hipBindTexture2D(size_t* offset, textureReference* tex, const void* devPtr,
3322  const hipChannelFormatDesc* desc, size_t width, size_t height,
3323  size_t pitch);
3324 
3325 hipError_t ihipBindTexture2DImpl(int dim, enum hipTextureReadMode readMode, size_t* offset,
3326  const void* devPtr, const struct hipChannelFormatDesc* desc,
3327  size_t width, size_t height, textureReference* tex, size_t pitch);
3328 
3329 template <class T, int dim, enum hipTextureReadMode readMode>
3330 hipError_t hipBindTexture2D(size_t* offset, struct texture<T, dim, readMode>& tex,
3331  const void* devPtr, size_t width, size_t height, size_t pitch) {
3332  return ihipBindTexture2DImpl(dim, readMode, offset, devPtr, &(tex.channelDesc), width, height,
3333  &tex);
3334 }
3335 
3336 template <class T, int dim, enum hipTextureReadMode readMode>
3337 hipError_t hipBindTexture2D(size_t* offset, struct texture<T, dim, readMode>& tex,
3338  const void* devPtr, const struct hipChannelFormatDesc& desc,
3339  size_t width, size_t height, size_t pitch) {
3340  return ihipBindTexture2DImpl(dim, readMode, offset, devPtr, &desc, width, height, &tex);
3341 }
3342 
3343 // C API
3344 hipError_t hipBindTextureToArray(textureReference* tex, hipArray_const_t array,
3345  const hipChannelFormatDesc* desc);
3346 
3347 hipError_t ihipBindTextureToArrayImpl(TlsData *tls, int dim, enum hipTextureReadMode readMode,
3348  hipArray_const_t array,
3349  const struct hipChannelFormatDesc& desc,
3350  textureReference* tex);
3351 
3352 template <class T, int dim, enum hipTextureReadMode readMode>
3353 hipError_t hipBindTextureToArray(struct texture<T, dim, readMode>& tex, hipArray_const_t array) {
3354  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, tex.channelDesc, &tex);
3355 }
3356 
3357 template <class T, int dim, enum hipTextureReadMode readMode>
3358 hipError_t hipBindTextureToArray(struct texture<T, dim, readMode>& tex, hipArray_const_t array,
3359  const struct hipChannelFormatDesc& desc) {
3360  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, desc, &tex);
3361 }
3362 
3363 template <class T, int dim, enum hipTextureReadMode readMode>
3364 inline static hipError_t hipBindTextureToArray(struct texture<T, dim, readMode> *tex,
3365  hipArray_const_t array,
3366  const struct hipChannelFormatDesc* desc) {
3367  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, *desc, tex);
3368 }
3369 
3370 // C API
3371 hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,
3372  hipMipmappedArray_const_t mipmappedArray,
3373  const hipChannelFormatDesc* desc);
3374 
3375 template <class T, int dim, enum hipTextureReadMode readMode>
3376 hipError_t hipBindTextureToMipmappedArray(const texture<T, dim, readMode>& tex,
3377  hipMipmappedArray_const_t mipmappedArray) {
3378  return hipSuccess;
3379 }
3380 
3381 template <class T, int dim, enum hipTextureReadMode readMode>
3382 hipError_t hipBindTextureToMipmappedArray(const texture<T, dim, readMode>& tex,
3383  hipMipmappedArray_const_t mipmappedArray,
3384  const hipChannelFormatDesc& desc) {
3385  return hipSuccess;
3386 }
3387 
3388 #if __HIP_VDI__ && !defined(__HCC__)
3389 template <class T>
3390 inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim,
3391  void** kernelParams, unsigned int sharedMemBytes, hipStream_t stream) {
3392  return hipLaunchCooperativeKernel(reinterpret_cast<const void*>(f), gridDim,
3393  blockDim, kernelParams, sharedMemBytes, stream);
3394 }
3395 
3396 template <class T>
3397 inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
3398  unsigned int numDevices, unsigned int flags = 0) {
3399  return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);
3400 }
3401 
3402 
3403 template <class T>
3404 inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,
3405  unsigned int numDevices, unsigned int flags = 0) {
3406  return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);
3407 }
3408 
3409 #endif
3410 
3411 /*
3412  * @brief Unbinds the textuer bound to @p tex
3413  *
3414  * @param[in] tex - texture to unbind
3415  *
3416  * @return #hipSuccess
3417  **/
3418 hipError_t hipUnbindTexture(const textureReference* tex);
3419 
3420 extern hipError_t ihipUnbindTextureImpl(const hipTextureObject_t& textureObject);
3421 
3422 template <class T, int dim, enum hipTextureReadMode readMode>
3423 hipError_t hipUnbindTexture(struct texture<T, dim, readMode>& tex) {
3424  return ihipUnbindTextureImpl(tex.textureObject);
3425 }
3426 
3427 hipError_t hipGetChannelDesc(hipChannelFormatDesc* desc, hipArray_const_t array);
3428 hipError_t hipGetTextureAlignmentOffset(size_t* offset, const textureReference* texref);
3429 hipError_t hipGetTextureReference(const textureReference** texref, const void* symbol);
3430 
3431 hipError_t hipCreateTextureObject(hipTextureObject_t* pTexObject, const hipResourceDesc* pResDesc,
3432  const hipTextureDesc* pTexDesc,
3433  const hipResourceViewDesc* pResViewDesc);
3434 
3435 hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);
3436 
3437 hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,
3438  hipTextureObject_t textureObject);
3439 hipError_t hipGetTextureObjectResourceViewDesc(hipResourceViewDesc* pResViewDesc,
3440  hipTextureObject_t textureObject);
3441 hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,
3442  hipTextureObject_t textureObject);
3443 hipError_t hipTexRefSetArray(textureReference* tex, hipArray_const_t array, unsigned int flags);
3444 
3445 hipError_t hipTexRefGetArray(hipArray_t* array, textureReference tex);
3446 
3447 hipError_t hipTexRefSetAddressMode(textureReference* tex, int dim, hipTextureAddressMode am);
3448 
3449 hipError_t hipTexRefGetAddressMode(hipTextureAddressMode* am, textureReference tex, int dim);
3450 
3451 hipError_t hipTexRefSetFilterMode(textureReference* tex, hipTextureFilterMode fm);
3452 
3453 hipError_t hipTexRefSetFlags(textureReference* tex, unsigned int flags);
3454 
3455 hipError_t hipTexRefSetFormat(textureReference* tex, hipArray_Format fmt, int NumPackedComponents);
3456 
3457 hipError_t hipTexRefSetAddress(size_t* offset, textureReference* tex, hipDeviceptr_t devPtr,
3458  size_t size);
3459 
3460 hipError_t hipTexRefGetAddress(hipDeviceptr_t* dev_ptr, textureReference tex);
3461 
3462 hipError_t hipTexRefSetAddress2D(textureReference* tex, const HIP_ARRAY_DESCRIPTOR* desc,
3463  hipDeviceptr_t devPtr, size_t pitch);
3464 
3465 hipError_t hipCreateSurfaceObject(hipSurfaceObject_t* pSurfObject, const hipResourceDesc* pResDesc);
3466 
3467 hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);
3468 
3469 // doxygen end Texture
3475 #endif
3476 
3477 #ifdef __GNUC__
3478 #pragma GCC visibility pop
3479 #endif
3480 
3498 // end-group HCC_Specific
3504 // doxygen end HIP API
3509 #endif
hipError_t hipMemcpy2DFromArrayAsync(void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data between host and device asynchronously.
hipError_t hipHostFree(void *ptr)
Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDevi...
Definition: hip_memory.cpp:2311
prefer larger L1 cache and smaller shared memory
Definition: hip_runtime_api.h:248
hipError_t hipModuleGetFunction(hipFunction_t *function, hipModule_t module, const char *kname)
Function with kname will be extracted if present in module.
Definition: hip_module.cpp:1034
hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)
Disable direct access from current context&#39;s virtual address space to memory allocations physically l...
Definition: hip_peer.cpp:220
hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent)
Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value...
Definition: hip_memory.cpp:2206
hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)
Query the priority of a stream.
Definition: hip_stream.cpp:237
hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)
Set Cache configuration for a specific function.
Definition: hip_device.cpp:82
hipError_t hipDriverGetVersion(int *driverVersion)
Returns the approximate HIP driver version.
Definition: hip_context.cpp:85
hipError_t hipLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes __dparm(0), hipStream_t stream __dparm(0))
C compliant kernel launch API.
Definition: hip_runtime_api.h:278
hipError_t hipPeekAtLastError(void)
Return last error returned by any HIP runtime API call.
Definition: hip_error.cpp:41
hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)
Copies memory for 2D arrays.
Definition: hip_memory.cpp:2089
hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)
Set flags for the primary context.
Definition: hip_context.cpp:321
hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)
Retain the primary context on the GPU.
Definition: hip_context.cpp:296
struct dim3 dim3
hipError_t hipDeviceComputeCapability(int *major, int *minor, hipDevice_t device)
Returns the compute capability of the device.
Definition: hip_device.cpp:417
hipError_t hipDeviceGetByPCIBusId(int *device, const char *pciBusId)
Returns a handle to a compute device.
Definition: hip_device.cpp:475
hipError_t hipExtMallocWithFlags(void **ptr, size_t sizeBytes, unsigned int flags)
Allocate memory on the default accelerator.
Definition: hip_memory.cpp:717
hipError_t hipMemGetAddressRange(hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr)
Get information on memory allocations.
Definition: hip_memory.cpp:2352
TODO-doc.
hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...
hipError_t hipFreeHost(void *ptr)
Free memory allocated by the hcc hip host memory allocation API. [Deprecated].
Definition: hip_memory.cpp:2322
hipError_t hipMemcpyToArray(hipArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind)
Copies data between host and device.
Definition: hip_memory.cpp:1477
unsigned long long hipSurfaceObject_t
Definition: hip_surface_types.h:36
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...
Definition: hip_module.cpp:1202
Definition: driver_types.h:240
hipError_t hipMallocPitch(void **ptr, size_t *pitch, size_t width, size_t height)
Definition: hip_memory.cpp:838
hipError_t hipMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies data between host and device.
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...
Definition: hip_memory.cpp:2191
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.
Definition: hip_memory.cpp:1968
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...
Definition: hip_stream.cpp:257
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.
Definition: hip_memory.cpp:1494
uint32_t x
x
Definition: hip_runtime_api.h:270
hipError_t hipMemcpyAtoH(void *dst, hipArray *srcArray, size_t srcOffset, size_t count)
Copies data between host and device.
Definition: hip_memory.cpp:1527
hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)
Enable direct access from current device&#39;s virtual address space to memory allocations physically loc...
Definition: hip_peer.cpp:193
hipError_t hipCtxPopCurrent(hipCtx_t *ctx)
Pop the current/default context and return the popped context.
Definition: hip_context.cpp:133
const char * hipGetErrorString(hipError_t hipError)
Return handy text string message to explain the error which occurred.
Definition: hip_error.cpp:54
hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)
Returns bank width of shared memory for current device.
Definition: hip_device.cpp:123
Definition: hip_runtime_api.h:150
hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)
Returns numerical values that correspond to the least and greatest stream priority.
Definition: hip_stream.cpp:122
prefer equal size L1 cache and shared memory
Definition: hip_runtime_api.h:249
hipError_t hipHostGetDevicePointer(void **devPtr, void *hstPtr, unsigned int flags)
Get Device pointer from Host Pointer allocated through hipHostMalloc.
hipError_t hipFreeArray(hipArray *array)
Frees an array on the device.
Definition: hip_memory.cpp:2324
hipError_t hipStreamCreateWithPriority(hipStream_t *stream, unsigned int flags, int priority)
Create an asynchronous stream with the specified priority.
Definition: hip_stream.cpp:113
hipError_t hipMemsetAsync(void *dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value val...
hipError_t hipEventSynchronize(hipEvent_t event)
Wait for an event to complete.
Definition: hip_event.cpp:143
Definition: driver_types.h:181
hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void *src, size_t sizeBytes)
Copy data from Host to Device.
Definition: hip_memory.cpp:1357
hipError_t hipModuleUnload(hipModule_t module)
Frees the module.
Definition: hip_module.cpp:984
Definition: hip_module.cpp:108
hipError_t hipSetDeviceFlags(unsigned flags)
The current device behavior is changed according the flags passed.
hipError_t hipEventQuery(hipEvent_t event)
Query event status.
Definition: hip_event.cpp:222
hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)
Disable direct access from current device&#39;s virtual address space to memory allocations physically lo...
Definition: hip_peer.cpp:186
hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)
Get Shared memory bank configuration.
Definition: hip_context.cpp:241
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.
Definition: hip_memory.cpp:2099
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(uint32_t *numBlocks, hipFunction_t f, uint32_t blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.
Definition: hip_module.cpp:1423
Definition: hip_hcc_internal.h:186
hipError_t hipCtxCreate(hipCtx_t *ctx, unsigned int flags, hipDevice_t device)
Create a context and set it as current/ default context.
Definition: hip_context.cpp:52
#define hipArrayDefault
Default HIP array allocation flag.
Definition: hip_runtime_api.h:209
hipError_t hipMallocArray(hipArray **array, const hipChannelFormatDesc *desc, size_t width, size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault))
Allocate an array on the device.
hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)
Set Shared memory bank configuration.
Definition: hip_context.cpp:233
hipError_t hipCtxSetCurrent(hipCtx_t ctx)
Set the passed context as current/default.
Definition: hip_context.cpp:178
hipError_t __hipPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream)
Pop configuration of a kernel launch.
hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)
Gets an interprocess memory handle for an existing device memory allocation.
Definition: hip_memory.cpp:2373
Definition: hip_runtime_api.h:121
hipError_t hipMemset2DAsync(void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream __dparm(0))
Fills asynchronously the memory area pointed to by dst with the constant value.
Definition: driver_types.h:115
hipError_t hipHostMalloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory.
Definition: hip_memory.cpp:755
Definition: hip_hcc_internal.h:947
Definition: texture_types.h:74
hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)
Get Resource limits of current device.
Definition: hip_device.cpp:94
hipError_t hipModuleLoadData(hipModule_t *module, const void *image)
builds module from code object which resides in host memory. Image is pointer to that location...
Definition: hip_module.cpp:1183
Definition: driver_types.h:77
hipDeviceAttribute_t
Definition: hip_runtime_api.h:274
hipError_t hipEventDestroy(hipEvent_t event)
Destroy the specified event.
Definition: hip_event.cpp:131
hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)
Create an asynchronous stream.
Definition: hip_stream.cpp:97
hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0))
Configure a kernel launch.
hipError_t hipChooseDevice(int *device, const hipDeviceProp_t *prop)
Device which matches hipDeviceProp_t is returned.
Definition: hip_device.cpp:501
hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition.
Definition: hip_context.cpp:225
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...
Definition: hip_runtime_api.h:269
uint32_t y
y
Definition: hip_runtime_api.h:271
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition: hip_runtime_api.h:843
hipError_t hipModuleLoad(hipModule_t *module, const char *fname)
Loads code object from file into a hipModule_t.
Definition: hip_module.cpp:1188
hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)
Resets the primary context on the GPU.
Definition: hip_context.cpp:308
hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)
Create an event with the specified flags.
Definition: hip_event.cpp:91
#define __host__
Definition: host_defines.h:41
hipError_t hipHostAlloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory [Deprecated].
Definition: hip_memory.cpp:781
hipError_t hipMallocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
Definition: hip_memory.cpp:775
hipError_t hipEventElapsedTime(float *ms, hipEvent_t start, hipEvent_t stop)
Return the elapsed time between two events.
Definition: hip_event.cpp:174
hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)
Set L1/Shared cache partition.
Definition: hip_device.cpp:74
hipError_t hipDeviceCanAccessPeer(int *canAccessPeer, int deviceId, int peerDeviceId)
Determine if a device can access a peer&#39;s memory.
Definition: hip_peer.cpp:179
hipError_t hipGetDeviceCount(int *count)
Return number of compute-capable devices.
Definition: hip_device.cpp:69
Definition: driver_types.h:68
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...
Definition: hip_memory.cpp:2164
Definition: driver_types.h:253
hipError_t hipFuncGetAttribute(int *value, hipFunction_attribute attrib, hipFunction_t hfunc)
Find out a specific attribute for a given function.
Definition: hip_module.cpp:1102
hipError_t hipOccupancyMaxPotentialBlockSize(uint32_t *gridSize, uint32_t *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit)
determine the grid and block sizes to achieves maximum occupancy for a kernel
Definition: hip_module.cpp:1360
hipError_t hipStreamDestroy(hipStream_t stream)
Destroys the specified stream.
Definition: hip_stream.cpp:194
hipError_t hipHostGetFlags(unsigned int *flagsPtr, void *hostPtr)
Return flags associated with host pointer.
Definition: hip_memory.cpp:1120
hipError_t hipStreamSynchronize(hipStream_t stream)
Wait for all commands in stream to complete.
Definition: hip_stream.cpp:183
hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)
Definition: hip_memory.cpp:849
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...
Definition: hip_memory.cpp:2409
hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)
Set Cache configuration for a specific function.
Definition: hip_context.cpp:217
hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Device.
Definition: hip_memory.cpp:1373
hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream __dparm(0))
Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value...
Definition: hip_runtime_api.h:258
dim3 gridDim
Grid dimentions.
Definition: hip_runtime_api.h:280
no preference for shared memory or L1 (default)
Definition: hip_runtime_api.h:246
hipError_t hipMallocManaged(void **devPtr, size_t size, unsigned int flags __dparm(0))
Allocates memory that will be automatically managed by the Unified Memory system. ...
hipError_t hipCtxSynchronize(void)
Blocks until the default context has completed all preceding requested tasks.
Definition: hip_context.cpp:249
hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count, hipStream_t stream __dparm(0))
Fills the memory area pointed to by dev with the constant integer value for specified number of times...
hipError_t hipCtxGetCurrent(hipCtx_t *ctx)
Get the handle of the current/ default context.
Definition: hip_context.cpp:167
hipError_t hipMalloc3DArray(hipArray **array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags)
Allocate an array on the device.
Definition: hip_memory.cpp:1078
hipError_t hipMemcpyDtoHAsync(void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Host asynchronously.
Definition: hip_memory.cpp:1420
void * func
Device function symbol.
Definition: hip_runtime_api.h:279
hipError_t hipDeviceSynchronize(void)
Waits on all active streams on current device.
Definition: hip_device.cpp:142
hipError_t hipCtxPushCurrent(hipCtx_t ctx)
Push the context to be set as current/ default context.
Definition: hip_context.cpp:154
hipError_t hipMemcpyDtoH(void *dst, hipDeviceptr_t src, size_t sizeBytes)
Copy data from Device to Host.
Definition: hip_memory.cpp:1365
Defines the different newt vector types for HIP runtime.
hipError_t hipMemcpyAsync(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream __dparm(0))
Copies sizeBytes bytes from the memory area pointed to by src to the memory area pointed to by offset...
hipError_t hipDeviceGetName(char *name, int len, hipDevice_t device)
Returns an identifer string for the device.
Definition: hip_device.cpp:429
hipError_t hipGetDeviceProperties(hipDeviceProp_t *prop, int deviceId)
Returns device properties.
Definition: hip_device.cpp:364
hipError_t hipHostRegister(void *hostPtr, size_t sizeBytes, unsigned int flags)
Register host memory so it can be accessed from the current device.
Definition: hip_memory.cpp:1145
Definition: driver_types.h:61
hipError_t hipMalloc(void **ptr, size_t size)
Allocate memory on the default accelerator.
Definition: hip_memory.cpp:690
const char * hipGetErrorName(hipError_t hip_error)
Return name of the specified error code in text form.
Definition: hip_error.cpp:48
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.
Definition: hip_memory.cpp:2169
Definition: driver_types.h:233
dim3 blockDim
Block dimentions.
Definition: hip_runtime_api.h:281
hipFuncCache_t
Definition: hip_runtime_api.h:245
hipError_t hipGetLastError(void)
Return last error returned by any HIP runtime API call and resets the stored error code to #hipSucces...
Definition: hip_error.cpp:32
hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags)
Make the specified compute stream wait for an event.
Definition: hip_stream.cpp:130
hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)
Return flags associated with this stream.
Definition: hip_stream.cpp:222
Defines surface types for HIP runtime.
hipStream_t stream
Stream identifier.
Definition: hip_runtime_api.h:284
hipError_t hipMemGetInfo(size_t *free, size_t *total)
Query memory info. Return snapshot of free memory, and total allocatable memory on the device...
Definition: hip_memory.cpp:2218
hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0))
Push configuration of a kernel launch.
hipError_t hipCtxGetDevice(hipDevice_t *device)
Get the handle of the device associated with current/default context.
Definition: hip_context.cpp:191
hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)
Release the primary context on the GPU.
Definition: hip_context.cpp:285
hipError_t hipFree(void *ptr)
Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSy...
Definition: hip_memory.cpp:2259
uint32_t z
z
Definition: hip_runtime_api.h:272
hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)
Returns the approximate HIP api version.
Definition: hip_context.cpp:207
hipError_t hipDeviceReset(void)
The state of current device is discarded and updated to a fresh state.
Definition: hip_device.cpp:147
hipError_t hipInit(unsigned int flags)
Explicitly initializes the HIP runtime.
Definition: hip_context.cpp:39
hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)
Copies data between host and device.
Definition: hip_memory.cpp:1661
hipError_t hipRuntimeGetVersion(int *runtimeVersion)
Returns the approximate HIP Runtime version.
Definition: hip_context.cpp:97
hipError_t hipMemcpyHtoA(hipArray *dstArray, size_t dstOffset, const void *srcHost, size_t count)
Copies data between host and device.
Definition: hip_memory.cpp:1511
hipError_t hipSetupArgument(const void *arg, size_t size, size_t offset)
Set a kernel argument.
Definition: hip_clang.cpp:192
hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)
Copy data from Device to Device asynchronously.
Definition: hip_memory.cpp:1412
Definition: hip_runtime_api.h:83
hipError_t hipSetDevice(int deviceId)
Set default device to be used for subsequent hip API calls from this thread.
Definition: hip_device.cpp:131
hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)
Returns a handle to a compute device.
Definition: hip_context.cpp:70
hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)
Returns the total amount of memory on the device.
Definition: hip_device.cpp:463
hipError_t hipMemAllocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
Definition: hip_memory.cpp:778
hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)
Set Cache configuration for a specific function.
Definition: hip_device.cpp:107
The compiler selects a device-specific value for the banking.
Definition: hip_runtime_api.h:257
Definition: hip_runtime.h:202
hipError_t hipMemcpyPeerAsync(void *dst, int dstDeviceId, const void *src, int srcDevice, size_t sizeBytes, hipStream_t stream __dparm(0))
Copies memory from one device to memory on another device.
hipError_t hipCtxGetFlags(unsigned int *flags)
Return flags used for creating default context.
Definition: hip_context.cpp:254
hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t *linktype, uint32_t *hopcount)
Returns the link type and hop count between two devices.
Definition: hip_device.cpp:588
hipError_t hipCtxDestroy(hipCtx_t ctx)
Destroy a HIP context.
Definition: hip_context.cpp:109
hipError_t hipRegisterApiCallback(uint32_t id, void *fun, void *arg)
Definition: hip_intercept.cpp:33
hipSharedMemConfig
Definition: hip_runtime_api.h:256
Definition: driver_types.h:38
Definition: hip_hcc_internal.h:769
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(uint32_t *numBlocks, hipFunction_t f, uint32_t blockSize, size_t dynSharedMemPerBlk, unsigned int flags)
Returns occupancy for a device function.
Definition: hip_module.cpp:1432
hipError_t hipDeviceGetAttribute(int *pi, hipDeviceAttribute_t attr, int deviceId)
Query for a specific device attribute.
Definition: hip_device.cpp:337
hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void *src, size_t sizeBytes, hipStream_t stream)
Copy data from Host to Device asynchronously.
Definition: hip_memory.cpp:1405
hipError_t hipHostUnregister(void *hostPtr)
Un-register host pointer.
Definition: hip_memory.cpp:1220
Definition: hip_hcc_internal.h:593
hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0))
Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...
hipError_t hipMemcpyPeer(void *dst, int dstDeviceId, const void *src, int srcDeviceId, size_t sizeBytes)
Copies memory from one device to memory on another device.
Definition: hip_peer.cpp:200
hipError_t hipStreamCreate(hipStream_t *stream)
Create an asynchronous stream.
Definition: hip_stream.cpp:106
hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms *p, hipStream_t stream __dparm(0))
Copies data between host and device asynchronously.
hipError_t hipMemcpy(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind)
Copy data from src to dst.
Definition: hip_memory.cpp:1350
hipError_t hipEventCreate(hipEvent_t *event)
Definition: hip_event.cpp:97
Definition: driver_types.h:90
Definition: hip_runtime_api.h:106
hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int *flags, int *active)
Get the state of the primary context.
Definition: hip_context.cpp:263
hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)
Enables direct access to memory allocations in a peer context.
Definition: hip_peer.cpp:214
Definition: driver_types.h:209
hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)
The bank width of shared memory on current device is set.
Definition: hip_device.cpp:115
hipError_t hipGetDevice(int *deviceId)
Return the default device id for the calling host thread.
Definition: hip_device.cpp:32
hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream)
Record an event in the specified stream.
Definition: hip_event.cpp:104
hipError_t hipModuleGetGlobal(void **, size_t *, hipModule_t, const char *)
returns device memory pointer and size of the kernel present in the module with symbol name ...
Definition: hip_module.cpp:837
Definition: hip_hcc_internal.h:442
hipError_t hipDeviceGetPCIBusId(char *pciBusId, int len, int device)
Returns a PCI Bus Id string for the device, overloaded to take int device ID.
Definition: hip_device.cpp:443
prefer larger shared memory and smaller L1 cache
Definition: hip_runtime_api.h:247
hipError_t hipMemcpy2DToArray(hipArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind)
Copies data between host and device.
Definition: hip_memory.cpp:1427
void ** args
Arguments.
Definition: hip_runtime_api.h:282
hipError_t hipStreamQuery(hipStream_t stream)
Return #hipSuccess if all of the operations in the specified stream have completed, or #hipErrorNotReady if not.
Definition: hip_stream.cpp:160
hipError_t hipFuncGetAttributes(struct hipFuncAttributes *attr, const void *func)
Find out attributes for a given function.
Definition: hip_module.cpp:1084
Definition: hip_runtime_api.h:260
hipError_t hipIpcCloseMemHandle(void *devPtr)
Close memory mapped with hipIpcOpenMemHandle.
Definition: hip_memory.cpp:2454
hipError_t hipPointerGetAttributes(hipPointerAttribute_t *attributes, const void *ptr)
Return attributes for the specified pointer.
Definition: hip_memory.cpp:612
hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream __dparm(0))
Copies memory for 2D arrays.
size_t sharedMem
Shared memory.
Definition: hip_runtime_api.h:283
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...
Definition: hip_memory.cpp:2181
hipError_t hipProfilerStop()
Stop recording of profiling information. When using this API, start the profiler with profiling disab...
Definition: hip_hcc.cpp:2487
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...
Definition: hip_memory.cpp:2201
hipError_t hipProfilerStart()
Start recording of profiling information When using this API, start the profiler with profiling disab...
Definition: hip_hcc.cpp:2477
hipError_t hipLaunchByPtr(const void *func)
Launch a kernel.
Definition: hip_clang.cpp:210
Definition: texture_types.h:94