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_ROCclr__
39 #define __HIP_ROCclr__ 0
40 #endif
41 
43 #include <hip/hcc_detail/driver_types.h>
46 
47 #if !__HIP_ROCclr__ && 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/blob/master/docs/markdown/hip_deprecated_api_list.md"
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 #define hipIpcMemLazyEnablePeerAccess 0
101 
102 #define HIP_IPC_HANDLE_SIZE 64
103 
104 typedef struct hipIpcMemHandle_st {
105  char reserved[HIP_IPC_HANDLE_SIZE];
107 
108 #if __HIP_ROCclr__
109 // TODO: IPC event handle currently unsupported
110 struct ihipIpcEventHandle_t;
112 #else
113 typedef struct hipIpcEventHandle_st {
114  char reserved[HIP_IPC_HANDLE_SIZE];
115 } hipIpcEventHandle_t;
116 #endif
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 #define hipOccupancyDefault 0x00
216 
217 #define hipCooperativeLaunchMultiDeviceNoPreSync 0x01
218 #define hipCooperativeLaunchMultiDeviceNoPostSync 0x02
219 
220 /*
221  * @brief hipJitOption
222  * @enum
223  * @ingroup Enumerations
224  */
225 typedef enum hipJitOption {
226  hipJitOptionMaxRegisters = 0,
227  hipJitOptionThreadsPerBlock,
228  hipJitOptionWallTime,
229  hipJitOptionInfoLogBuffer,
230  hipJitOptionInfoLogBufferSizeBytes,
231  hipJitOptionErrorLogBuffer,
232  hipJitOptionErrorLogBufferSizeBytes,
233  hipJitOptionOptimizationLevel,
234  hipJitOptionTargetFromContext,
235  hipJitOptionTarget,
236  hipJitOptionFallbackStrategy,
237  hipJitOptionGenerateDebugInfo,
238  hipJitOptionLogVerbose,
239  hipJitOptionGenerateLineInfo,
240  hipJitOptionCacheMode,
241  hipJitOptionSm3xOpt,
242  hipJitOptionFastCompile,
243  hipJitOptionNumOptions
244 } hipJitOption;
245 
246 
250 typedef enum hipFuncCache_t {
256 
257 
261 typedef enum hipSharedMemConfig {
268 
273 typedef struct dim3 {
274  uint32_t x;
275  uint32_t y;
276  uint32_t z;
277 #ifdef __cplusplus
278  __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1) : x(_x), y(_y), z(_z){};
279 #endif
280 } dim3;
281 
282 typedef struct hipLaunchParams_t {
283  void* func;
286  void **args;
287  size_t sharedMem;
288  hipStream_t stream;
290 
291 
292 // Doxygen end group GlobalDefs
296 //-------------------------------------------------------------------------------------------------
297 
298 
299 // The handle allows the async commands to use the stream even if the parent hipStream_t goes
300 // out-of-scope.
301 // typedef class ihipStream_t * hipStream_t;
302 
303 
304 /*
305  * Opaque structure allows the true event (pointed at by the handle) to remain "live" even if the
306  * surrounding hipEvent_t goes out-of-scope. This is handy for cases where the hipEvent_t goes
307  * out-of-scope but the true event is being written by some async queue or device */
308 // typedef struct hipEvent_t {
309 // struct ihipEvent_t *_handle;
310 //} hipEvent_t;
311 
312 
338 hipError_t hipDeviceSynchronize(void);
339 
340 
352 hipError_t hipDeviceReset(void);
353 
354 
386 hipError_t hipSetDevice(int deviceId);
387 
388 
402 hipError_t hipGetDevice(int* deviceId);
403 
404 
417 hipError_t hipGetDeviceCount(int* count);
418 
428 hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int deviceId);
429 
443 hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId);
444 
445 
456 hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);
457 
458 
469 hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);
470 
481 hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit);
482 
483 
494 hipError_t hipFuncSetCacheConfig(const void* func, hipFuncCache_t config);
495 
507 hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);
508 
509 
521 hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);
522 
547 hipError_t hipSetDeviceFlags(unsigned flags);
548 
557 hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop);
558 
571 hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype, uint32_t* hopcount);
572 
573 // end doxygen Device
596 hipError_t hipGetLastError(void);
597 
598 
609 hipError_t hipPeekAtLastError(void);
610 
611 
620 const char* hipGetErrorName(hipError_t hip_error);
621 
622 
633 const char* hipGetErrorString(hipError_t hipError);
634 
635 // end doxygen Error
668 hipError_t hipStreamCreate(hipStream_t* stream);
669 
670 
688 hipError_t hipStreamCreateWithFlags(hipStream_t* stream, unsigned int flags);
689 
690 
709 hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority);
710 
711 
726 hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority);
727 
728 
747 hipError_t hipStreamDestroy(hipStream_t stream);
748 
749 
765 hipError_t hipStreamQuery(hipStream_t stream);
766 
767 
787 hipError_t hipStreamSynchronize(hipStream_t stream);
788 
789 
809 hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags);
810 
811 
825 hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags);
826 
827 
841 hipError_t hipStreamGetPriority(hipStream_t stream, int* priority);
842 
843 
847 typedef void (*hipStreamCallback_t)(hipStream_t stream, hipError_t status, void* userData);
848 
864 hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void* userData,
865  unsigned int flags);
866 
867 
868 // end doxygen Stream
905 hipError_t hipEventCreateWithFlags(hipEvent_t* event, unsigned flags);
906 
907 
919 hipError_t hipEventCreate(hipEvent_t* event);
920 
921 
949 #ifdef __cplusplus
950 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream = NULL);
951 #else
952 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);
953 #endif
954 
971 hipError_t hipEventDestroy(hipEvent_t event);
972 
973 
991 hipError_t hipEventSynchronize(hipEvent_t event);
992 
993 
1022 hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop);
1023 
1024 
1040 hipError_t hipEventQuery(hipEvent_t event);
1041 
1042 
1043 // end doxygen Events
1074 hipError_t hipPointerGetAttributes(hipPointerAttribute_t* attributes, const void* ptr);
1075 
1089 hipError_t hipMalloc(void** ptr, size_t size);
1090 
1105 hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags);
1106 
1119 DEPRECATED("use hipHostMalloc instead")
1120 hipError_t hipMallocHost(void** ptr, size_t size);
1121 
1134 DEPRECATED("use hipHostMalloc instead")
1135 hipError_t hipMemAllocHost(void** ptr, size_t size);
1136 
1150 hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags);
1151 
1161 hipError_t hipMallocManaged(void** devPtr, size_t size, unsigned int flags __dparm(0));
1162 
1176 DEPRECATED("use hipHostMalloc instead")
1177 hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags);
1178 
1190 hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags);
1191 
1201 hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr);
1202 
1239 hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags);
1240 
1249 hipError_t hipHostUnregister(void* hostPtr);
1250 
1270 hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height);
1271 
1294 hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes);
1295 
1309 hipError_t hipFree(void* ptr);
1310 
1321 DEPRECATED("use hipHostFree instead")
1322 hipError_t hipFreeHost(void* ptr);
1323 
1337 hipError_t hipHostFree(void* ptr);
1338 
1366 hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);
1367 
1368 // TODO: Add description
1369 hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes,
1370  hipMemcpyKind kind, hipStream_t stream);
1388 hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void* src, size_t sizeBytes);
1389 
1407 hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes);
1408 
1426 hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes);
1427 
1445 hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void* src, size_t sizeBytes, hipStream_t stream);
1446 
1464 hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream);
1465 
1483 hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,
1484  hipStream_t stream);
1485 
1486 #if __HIP_ROCclr__
1487 hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,
1488  hipModule_t hmod, const char* name);
1489 
1490 hipError_t hipGetSymbolAddress(void** devPtr, const void* symbol);
1491 hipError_t hipGetSymbolSize(size_t* size, const void* symbol);
1492 hipError_t hipMemcpyToSymbol(const void* symbol, const void* src,
1493  size_t sizeBytes, size_t offset __dparm(0),
1494  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));
1495 hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src,
1496  size_t sizeBytes, size_t offset,
1497  hipMemcpyKind kind, hipStream_t stream __dparm(0));
1498 hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol,
1499  size_t sizeBytes, size_t offset __dparm(0),
1500  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));
1501 hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol,
1502  size_t sizeBytes, size_t offset,
1503  hipMemcpyKind kind,
1504  hipStream_t stream __dparm(0));
1505 #else
1506 hipError_t hipModuleGetGlobal(void**, size_t*, hipModule_t, const char*);
1507 
1508 #ifdef __cplusplus //Start : Not supported in gcc
1509 namespace hip_impl {
1510 inline
1511 __attribute__((visibility("hidden")))
1512 hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
1513  const char* name);
1514 } // Namespace hip_impl.
1515 
1516 
1527 inline
1528 __attribute__((visibility("hidden")))
1529 hipError_t hipGetSymbolAddress(void** devPtr, const void* symbolName) {
1530  //HIP_INIT_API(hipGetSymbolAddress, devPtr, symbolName);
1531  hip_impl::hip_init();
1532  size_t size = 0;
1533  return hip_impl::read_agent_global_from_process(devPtr, &size, (const char*)symbolName);
1534 }
1535 
1536 
1547 inline
1548 __attribute__((visibility("hidden")))
1549 hipError_t hipGetSymbolSize(size_t* size, const void* symbolName) {
1550  // HIP_INIT_API(hipGetSymbolSize, size, symbolName);
1551  hip_impl::hip_init();
1552  void* devPtr = nullptr;
1553  return hip_impl::read_agent_global_from_process(&devPtr, size, (const char*)symbolName);
1554 }
1555 #endif // End : Not supported in gcc
1556 
1557 #if defined(__cplusplus)
1558 } // extern "C"
1559 #endif
1560 
1561 #ifdef __cplusplus
1562 namespace hip_impl {
1563 hipError_t hipMemcpyToSymbol(void*, const void*, size_t, size_t, hipMemcpyKind,
1564  const char*);
1565 } // Namespace hip_impl.
1566 #endif
1567 
1568 #if defined(__cplusplus)
1569 extern "C" {
1570 #endif
1571 
1595 #ifdef __cplusplus
1596 inline
1597 __attribute__((visibility("hidden")))
1598 hipError_t hipMemcpyToSymbol(const void* symbolName, const void* src,
1599  size_t sizeBytes, size_t offset __dparm(0),
1600  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {
1601  if (!symbolName) return hipErrorInvalidSymbol;
1602 
1603  hipDeviceptr_t dst = NULL;
1604  hipGetSymbolAddress(&dst, (const char*)symbolName);
1605 
1606  return hip_impl::hipMemcpyToSymbol(dst, src, sizeBytes, offset, kind,
1607  (const char*)symbolName);
1608 }
1609 #endif
1610 
1611 #if defined(__cplusplus)
1612 } // extern "C"
1613 #endif
1614 
1615 #ifdef __cplusplus
1616 namespace hip_impl {
1617 hipError_t hipMemcpyToSymbolAsync(void*, const void*, size_t, size_t,
1618  hipMemcpyKind, hipStream_t, const char*);
1619 hipError_t hipMemcpyFromSymbol(void*, const void*, size_t, size_t,
1620  hipMemcpyKind, const char*);
1621 hipError_t hipMemcpyFromSymbolAsync(void*, const void*, size_t, size_t,
1622  hipMemcpyKind, hipStream_t, const char*);
1623 } // Namespace hip_impl.
1624 #endif
1625 
1626 #if defined(__cplusplus)
1627 extern "C" {
1628 #endif
1629 
1656 #ifdef __cplusplus //Start : Not supported in gcc
1657 inline
1658 __attribute__((visibility("hidden")))
1659 hipError_t hipMemcpyToSymbolAsync(const void* symbolName, const void* src,
1660  size_t sizeBytes, size_t offset,
1661  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
1662  if (!symbolName) return hipErrorInvalidSymbol;
1663 
1664  hipDeviceptr_t dst = NULL;
1665  hipGetSymbolAddress(&dst, symbolName);
1666 
1667  return hip_impl::hipMemcpyToSymbolAsync(dst, src, sizeBytes, offset, kind,
1668  stream,
1669  (const char*)symbolName);
1670 }
1671 
1672 inline
1673 __attribute__((visibility("hidden")))
1674 hipError_t hipMemcpyFromSymbol(void* dst, const void* symbolName,
1675  size_t sizeBytes, size_t offset __dparm(0),
1676  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {
1677  if (!symbolName) return hipErrorInvalidSymbol;
1678 
1679  hipDeviceptr_t src = NULL;
1680  hipGetSymbolAddress(&src, symbolName);
1681 
1682  return hip_impl::hipMemcpyFromSymbol(dst, src, sizeBytes, offset, kind,
1683  (const char*)symbolName);
1684 }
1685 
1686 inline
1687 __attribute__((visibility("hidden")))
1688 hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbolName,
1689  size_t sizeBytes, size_t offset,
1690  hipMemcpyKind kind,
1691  hipStream_t stream __dparm(0)) {
1692  if (!symbolName) return hipErrorInvalidSymbol;
1693 
1694  hipDeviceptr_t src = NULL;
1695  hipGetSymbolAddress(&src, symbolName);
1696 
1697  return hip_impl::hipMemcpyFromSymbolAsync(dst, src, sizeBytes, offset, kind,
1698  stream,
1699  (const char*)symbolName);
1700 }
1701 #endif // End : Not supported in gcc
1702 
1703 #endif // __HIP_ROCclr__
1704 
1732 hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,
1733  hipStream_t stream __dparm(0));
1734 
1744 hipError_t hipMemset(void* dst, int value, size_t sizeBytes);
1745 
1755 hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count);
1756 
1772 hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0));
1773 
1783 hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count);
1784 
1800 hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0));
1801 
1811 hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count);
1812 
1828 hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0));
1829 
1845 hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count,
1846  hipStream_t stream __dparm(0));
1847 
1859 hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height);
1860 
1873 hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,hipStream_t stream __dparm(0));
1874 
1883 hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent );
1884 
1894 hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent ,hipStream_t stream __dparm(0));
1895 
1905 hipError_t hipMemGetInfo(size_t* free, size_t* total);
1906 
1907 
1908 hipError_t hipMemPtrGetInfo(void* ptr, size_t* size);
1909 
1910 
1923 hipError_t hipMallocArray(hipArray** array, const hipChannelFormatDesc* desc, size_t width,
1924  size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault));
1925 hipError_t hipArrayCreate(hipArray** pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray);
1926 
1927 hipError_t hipArray3DCreate(hipArray** array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);
1928 
1929 hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent);
1930 
1939 hipError_t hipFreeArray(hipArray* array);
1940 
1948 hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);
1949 
1962 hipError_t hipMalloc3DArray(hipArray** array, const struct hipChannelFormatDesc* desc,
1963  struct hipExtent extent, unsigned int flags);
1964 
1976 hipError_t hipMallocMipmappedArray(
1977  hipMipmappedArray_t *mipmappedArray,
1978  const struct hipChannelFormatDesc* desc,
1979  struct hipExtent extent,
1980  unsigned int numLevels,
1981  unsigned int flags __dparm(0));
1982 
1992 hipError_t hipGetMipmappedArrayLevel(
1993  hipArray_t *levelArray,
1994  hipMipmappedArray_const_t mipmappedArray,
1995  unsigned int level);
1996 
2013 hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
2014  size_t height, hipMemcpyKind kind);
2015 
2025 hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);
2026 
2037 hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D* pCopy, hipStream_t stream __dparm(0));
2038 
2056 hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
2057  size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));
2058 
2075 hipError_t hipMemcpy2DToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
2076  size_t spitch, size_t width, size_t height, hipMemcpyKind kind);
2077 
2094 hipError_t hipMemcpyToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
2095  size_t count, hipMemcpyKind kind);
2096 
2112 hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,
2113  size_t count, hipMemcpyKind kind);
2114 
2132 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);
2133 
2152 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));
2153 
2167 hipError_t hipMemcpyAtoH(void* dst, hipArray* srcArray, size_t srcOffset, size_t count);
2168 
2182 hipError_t hipMemcpyHtoA(hipArray* dstArray, size_t dstOffset, const void* srcHost, size_t count);
2183 
2194 hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);
2195 
2207 hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms* p, hipStream_t stream __dparm(0));
2208 
2219 hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);
2220 
2232 hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D* pCopy, hipStream_t stream);
2233 
2234 // doxygen end Memory
2266 hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId);
2267 
2268 
2285 hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags);
2286 
2287 
2299 hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);
2300 
2313 hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr);
2314 
2315 #ifndef USE_PEER_NON_UNIFIED
2316 #define USE_PEER_NON_UNIFIED 1
2317 #endif
2318 
2319 #if USE_PEER_NON_UNIFIED == 1
2320 
2331 hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId,
2332  size_t sizeBytes);
2333 
2346 hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice,
2347  size_t sizeBytes, hipStream_t stream __dparm(0));
2348 #endif
2349 
2350 
2351 // doxygen end PeerToPeer
2370 // TODO-ctx - more description on error codes.
2371 hipError_t hipInit(unsigned int flags);
2372 
2373 
2393 DEPRECATED(DEPRECATED_MSG)
2394 hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);
2395 
2406 DEPRECATED(DEPRECATED_MSG)
2407 hipError_t hipCtxDestroy(hipCtx_t ctx);
2408 
2419 DEPRECATED(DEPRECATED_MSG)
2420 hipError_t hipCtxPopCurrent(hipCtx_t* ctx);
2421 
2432 DEPRECATED(DEPRECATED_MSG)
2433 hipError_t hipCtxPushCurrent(hipCtx_t ctx);
2434 
2445 DEPRECATED(DEPRECATED_MSG)
2446 hipError_t hipCtxSetCurrent(hipCtx_t ctx);
2447 
2458 DEPRECATED(DEPRECATED_MSG)
2459 hipError_t hipCtxGetCurrent(hipCtx_t* ctx);
2460 
2472 DEPRECATED(DEPRECATED_MSG)
2473 hipError_t hipCtxGetDevice(hipDevice_t* device);
2474 
2492 DEPRECATED(DEPRECATED_MSG)
2493 hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int* apiVersion);
2494 
2508 DEPRECATED(DEPRECATED_MSG)
2509 hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);
2510 
2524 DEPRECATED(DEPRECATED_MSG)
2525 hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);
2526 
2540 DEPRECATED(DEPRECATED_MSG)
2541 hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);
2542 
2556 DEPRECATED(DEPRECATED_MSG)
2557 hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);
2558 
2570 DEPRECATED(DEPRECATED_MSG)
2571 hipError_t hipCtxSynchronize(void);
2572 
2583 DEPRECATED(DEPRECATED_MSG)
2584 hipError_t hipCtxGetFlags(unsigned int* flags);
2585 
2605 DEPRECATED(DEPRECATED_MSG)
2606 hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags);
2607 
2624 DEPRECATED(DEPRECATED_MSG)
2625 hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);
2626 
2639 hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active);
2640 
2653 hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);
2654 
2666 hipError_t hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev);
2667 
2678 hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);
2679 
2691 hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags);
2692 
2693 // doxygen end Context Management
2705 hipError_t hipDeviceGet(hipDevice_t* device, int ordinal);
2706 
2715 hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device);
2716 
2725 hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device);
2726 
2735 hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device);
2736 
2737 
2745 hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId);
2746 
2747 
2755 hipError_t hipDeviceTotalMem(size_t* bytes, hipDevice_t device);
2756 
2772 hipError_t hipDriverGetVersion(int* driverVersion);
2773 
2786 hipError_t hipRuntimeGetVersion(int* runtimeVersion);
2787 
2799 hipError_t hipModuleLoad(hipModule_t* module, const char* fname);
2800 
2811 hipError_t hipModuleUnload(hipModule_t module);
2812 
2823 hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname);
2824 
2834 hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func);
2835 
2845 hipError_t hipFuncGetAttribute(int* value, hipFunction_attribute attrib, hipFunction_t hfunc);
2846 
2847 #if !__HIP_ROCclr__
2848 #if defined(__cplusplus)
2849 } // extern "C"
2850 #endif
2851 
2852 #ifdef __cplusplus
2853 namespace hip_impl {
2854  class agent_globals_impl;
2855  class agent_globals {
2856  public:
2857  agent_globals();
2858  ~agent_globals();
2859  agent_globals(const agent_globals&) = delete;
2860 
2861  hipError_t read_agent_global_from_module(hipDeviceptr_t* dptr, size_t* bytes,
2862  hipModule_t hmod, const char* name);
2863  hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
2864  const char* name);
2865  private:
2866  agent_globals_impl* impl;
2867  };
2868 
2869  inline
2870  __attribute__((visibility("hidden")))
2871  agent_globals& get_agent_globals() {
2872  static agent_globals ag;
2873  return ag;
2874  }
2875 
2876  extern "C"
2877  inline
2878  __attribute__((visibility("hidden")))
2879  hipError_t read_agent_global_from_process(hipDeviceptr_t* dptr, size_t* bytes,
2880  const char* name) {
2881  return get_agent_globals().read_agent_global_from_process(dptr, bytes, name);
2882  }
2883 } // Namespace hip_impl.
2884 #endif
2885 
2886 #if defined(__cplusplus)
2887 extern "C" {
2888 #endif
2889 
2900 hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,
2901  hipModule_t hmod, const char* name);
2902 #endif // __HIP_ROCclr__
2903 
2904 hipError_t hipModuleGetTexRef(textureReference** texRef, hipModule_t hmod, const char* name);
2905 
2915 hipError_t hipModuleLoadData(hipModule_t* module, const void* image);
2916 
2929 hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions,
2930  hipJitOption* options, void** optionValues);
2931 
2956 hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY,
2957  unsigned int gridDimZ, unsigned int blockDimX,
2958  unsigned int blockDimY, unsigned int blockDimZ,
2959  unsigned int sharedMemBytes, hipStream_t stream,
2960  void** kernelParams, void** extra);
2961 
2962 
2963 #if __HIP_ROCclr__ && !defined(__HCC__)
2964 
2979 hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX,
2980  void** kernelParams, unsigned int sharedMemBytes,
2981  hipStream_t stream);
2982 
2993 hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
2994  int numDevices, unsigned int flags);
2995 
2996 #endif
2997 
3010 //TODO - Match CUoccupancyB2DSize
3011 hipError_t hipModuleOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,
3012  hipFunction_t f, size_t dynSharedMemPerBlk,
3013  int blockSizeLimit);
3014 
3027 //TODO - Match CUoccupancyB2DSize
3028 hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,
3029  hipFunction_t f, size_t dynSharedMemPerBlk,
3030  int blockSizeLimit, unsigned int flags);
3031 
3041  int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk);
3042 
3053  int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);
3054 
3064  int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk);
3065 
3076  int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags __dparm(hipOccupancyDefault));
3077 
3089 hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,
3090  const void* f, size_t dynSharedMemPerBlk,
3091  int blockSizeLimit);
3092 
3104 hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,
3105  int numDevices, unsigned int flags);
3106 
3107 
3108 // doxygen end Version Management
3126 // TODO - expand descriptions:
3132 DEPRECATED("use roctracer/rocTX instead")
3133 hipError_t hipProfilerStart();
3134 
3135 
3141 DEPRECATED("use roctracer/rocTX instead")
3142 hipError_t hipProfilerStop();
3143 
3144 
3149 // TODO: implement IPC apis
3150 
3176 hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr);
3177 
3214 hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);
3215 
3234 hipError_t hipIpcCloseMemHandle(void* devPtr);
3235 
3236 
3237 hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t* handle, hipEvent_t event);
3238 hipError_t hipIpcOpenEventHandle(hipEvent_t* event, hipIpcEventHandle_t handle);
3239 
3240 
3261 hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0));
3262 
3263 
3274 hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);
3275 
3276 
3285 hipError_t hipLaunchByPtr(const void* func);
3286 
3287 
3302 hipError_t __hipPushCallConfiguration(dim3 gridDim,
3303  dim3 blockDim,
3304  size_t sharedMem __dparm(0),
3305  hipStream_t stream __dparm(0));
3306 
3320 hipError_t __hipPopCallConfiguration(dim3 *gridDim,
3321  dim3 *blockDim,
3322  size_t *sharedMem,
3323  hipStream_t *stream);
3324 
3341 hipError_t hipLaunchKernel(const void* function_address,
3342  dim3 numBlocks,
3343  dim3 dimBlocks,
3344  void** args,
3345  size_t sharedMemBytes __dparm(0),
3346  hipStream_t stream __dparm(0));
3347 
3348 #if __HIP_ROCclr__
3349 hipError_t hipBindTexture(
3350  size_t* offset,
3351  const textureReference* tex,
3352  const void* devPtr,
3353  const hipChannelFormatDesc* desc,
3354  size_t size __dparm(UINT_MAX));
3355 
3356 hipError_t hipBindTexture2D(
3357  size_t* offset,
3358  const textureReference* tex,
3359  const void* devPtr,
3360  const hipChannelFormatDesc* desc,
3361  size_t width,
3362  size_t height,
3363  size_t pitch);
3364 
3365 hipError_t hipBindTextureToArray(
3366  const textureReference* tex,
3367  hipArray_const_t array,
3368  const hipChannelFormatDesc* desc);
3369 
3370 hipError_t hipBindTextureToMipmappedArray(
3371  const textureReference* tex,
3372  hipMipmappedArray_const_t mipmappedArray,
3373  const hipChannelFormatDesc* desc);
3374 
3375 hipError_t hipGetTextureAlignmentOffset(
3376  size_t* offset,
3377  const textureReference* texref);
3378 
3379 hipError_t hipGetTextureReference(
3380  const textureReference** texref,
3381  const void* symbol);
3382 
3383 hipError_t hipUnbindTexture(const textureReference* tex);
3384 
3385 hipError_t hipCreateTextureObject(
3386  hipTextureObject_t* pTexObject,
3387  const hipResourceDesc* pResDesc,
3388  const hipTextureDesc* pTexDesc,
3389  const struct hipResourceViewDesc* pResViewDesc);
3390 
3391 hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);
3392 
3393 hipError_t hipGetChannelDesc(
3394  hipChannelFormatDesc* desc,
3395  hipArray_const_t array);
3396 
3397 hipError_t hipGetTextureObjectResourceDesc(
3398  hipResourceDesc* pResDesc,
3399  hipTextureObject_t textureObject);
3400 
3401 hipError_t hipGetTextureObjectResourceViewDesc(
3402  struct hipResourceViewDesc* pResViewDesc,
3403  hipTextureObject_t textureObject);
3404 
3405 hipError_t hipGetTextureObjectTextureDesc(
3406  hipTextureDesc* pTexDesc,
3407  hipTextureObject_t textureObject);
3408 
3409 hipError_t hipTexRefGetAddress(
3410  hipDeviceptr_t* dev_ptr,
3411  const textureReference* texRef);
3412 
3413 hipError_t hipTexRefGetAddressMode(
3414  enum hipTextureAddressMode* pam,
3415  const textureReference* texRef,
3416  int dim);
3417 
3418 hipError_t hipTexRefGetFilterMode(
3419  enum hipTextureFilterMode* pfm,
3420  const textureReference* texRef);
3421 
3422 hipError_t hipTexRefGetFlags(
3423  unsigned int* pFlags,
3424  const textureReference* texRef);
3425 
3426 hipError_t hipTexRefGetFormat(
3427  hipArray_Format* pFormat,
3428  int* pNumChannels,
3429  const textureReference* texRef);
3430 
3431 hipError_t hipTexRefGetMaxAnisotropy(
3432  int* pmaxAnsio,
3433  const textureReference* texRef);
3434 
3435 hipError_t hipTexRefGetMipmapFilterMode(
3436  enum hipTextureFilterMode* pfm,
3437  const textureReference* texRef);
3438 
3439 hipError_t hipTexRefGetMipmapLevelBias(
3440  float* pbias,
3441  const textureReference* texRef);
3442 
3443 hipError_t hipTexRefGetMipmapLevelClamp(
3444  float* pminMipmapLevelClamp,
3445  float* pmaxMipmapLevelClamp,
3446  const textureReference* texRef);
3447 
3448 hipError_t hipTexRefGetMipMappedArray(
3449  hipMipmappedArray_t* pArray,
3450  const textureReference* texRef);
3451 
3452 hipError_t hipTexRefSetAddress(
3453  size_t* ByteOffset,
3454  textureReference* texRef,
3455  hipDeviceptr_t dptr,
3456  size_t bytes);
3457 
3458 hipError_t hipTexRefSetAddress2D(
3459  textureReference* texRef,
3460  const HIP_ARRAY_DESCRIPTOR* desc,
3461  hipDeviceptr_t dptr,
3462  size_t Pitch);
3463 
3464 hipError_t hipTexRefSetAddressMode(
3465  textureReference* texRef,
3466  int dim,
3467  enum hipTextureAddressMode am);
3468 
3469 hipError_t hipTexRefSetArray(
3470  textureReference* tex,
3471  hipArray_const_t array,
3472  unsigned int flags);
3473 
3474 hipError_t hipTexRefSetBorderColor(
3475  textureReference* texRef,
3476  float* pBorderColor);
3477 
3478 hipError_t hipTexRefSetFilterMode(
3479  textureReference* texRef,
3480  enum hipTextureFilterMode fm);
3481 
3482 hipError_t hipTexRefSetFlags(
3483  textureReference* texRef,
3484  unsigned int Flags);
3485 
3486 hipError_t hipTexRefSetFormat(
3487  textureReference* texRef,
3488  hipArray_Format fmt,
3489  int NumPackedComponents);
3490 
3491 hipError_t hipTexRefSetMaxAnisotropy(
3492  textureReference* texRef,
3493  unsigned int maxAniso);
3494 
3495 hipError_t hipTexRefSetMipmapFilterMode(
3496  textureReference* texRef,
3497  enum hipTextureFilterMode fm);
3498 
3499 hipError_t hipTexRefSetMipmapLevelBias(
3500  textureReference* texRef,
3501  float bias);
3502 
3503 hipError_t hipTexRefSetMipmapLevelClamp(
3504  textureReference* texRef,
3505  float minMipMapLevelClamp,
3506  float maxMipMapLevelClamp);
3507 
3508 hipError_t hipTexRefSetMipmappedArray(
3509  textureReference* texRef,
3510  struct hipMipmappedArray* mipmappedArray,
3511  unsigned int Flags);
3512 
3513 hipError_t hipMipmappedArrayCreate(
3514  hipMipmappedArray_t* pHandle,
3515  HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,
3516  unsigned int numMipmapLevels);
3517 
3518 hipError_t hipMipmappedArrayDestroy(
3519  hipMipmappedArray_t hMipmappedArray);
3520 
3521 hipError_t hipMipmappedArrayGetLevel(
3522  hipArray_t* pLevelArray,
3523  hipMipmappedArray_t hMipMappedArray,
3524  unsigned int level);
3525 
3526 hipError_t hipTexObjectCreate(
3527  hipTextureObject_t* pTexObject,
3528  const HIP_RESOURCE_DESC* pResDesc,
3529  const HIP_TEXTURE_DESC* pTexDesc,
3530  const HIP_RESOURCE_VIEW_DESC* pResViewDesc);
3531 
3532 hipError_t hipTexObjectDestroy(
3533  hipTextureObject_t texObject);
3534 
3535 hipError_t hipTexObjectGetResourceDesc(
3536  HIP_RESOURCE_DESC* pResDesc,
3537  hipTextureObject_t texObject);
3538 
3539 hipError_t hipTexObjectGetResourceViewDesc(
3540  HIP_RESOURCE_VIEW_DESC* pResViewDesc,
3541  hipTextureObject_t texObject);
3542 
3543 hipError_t hipTexObjectGetTextureDesc(
3544  HIP_TEXTURE_DESC* pTexDesc,
3545  hipTextureObject_t texObject);
3546 #endif
3547 
3553 #ifdef __cplusplus
3554 } /* extern "c" */
3555 #endif
3556 
3557 #if defined(__cplusplus) && !defined(__HCC__) && defined(__clang__) && defined(__HIP__)
3558 template <typename T>
3559 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,
3560  T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {
3561  return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);
3562 }
3563 
3564 template <typename T>
3565 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,
3566  T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0, unsigned int flags = 0 ) {
3567  return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);
3568 }
3569 #endif // defined(__cplusplus) && !defined(__HCC__) && defined(__clang__) && defined(__HIP__)
3570 
3571 #if defined(__cplusplus) && !defined(__HCC__)
3572 
3573 template <typename T>
3574 hipError_t hipGetSymbolAddress(void** devPtr, const T &symbol) {
3575  return ::hipGetSymbolAddress(devPtr, (const void *)&symbol);
3576 }
3577 
3578 template <typename T>
3579 hipError_t hipGetSymbolSize(size_t* size, const T &symbol) {
3580  return ::hipGetSymbolSize(size, (const void *)&symbol);
3581 }
3582 
3583 template <typename T>
3584 hipError_t hipMemcpyToSymbol(const T& symbol, const void* src, size_t sizeBytes,
3585  size_t offset __dparm(0),
3586  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {
3587  return ::hipMemcpyToSymbol((const void*)&symbol, src, sizeBytes, offset, kind);
3588 }
3589 
3590 template <typename T>
3591 hipError_t hipMemcpyToSymbolAsync(const T& symbol, const void* src, size_t sizeBytes, size_t offset,
3592  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
3593  return ::hipMemcpyToSymbolAsync((const void*)&symbol, src, sizeBytes, offset, kind, stream);
3594 }
3595 
3596 template <typename T>
3597 hipError_t hipMemcpyFromSymbol(void* dst, const T &symbol,
3598  size_t sizeBytes, size_t offset __dparm(0),
3599  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {
3600  return ::hipMemcpyFromSymbol(dst, (const void*)&symbol, sizeBytes, offset, kind);
3601 }
3602 
3603 template <typename T>
3604 hipError_t hipMemcpyFromSymbolAsync(void* dst, const T& symbol, size_t sizeBytes, size_t offset,
3605  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {
3606  return ::hipMemcpyFromSymbolAsync(dst, (const void*)&symbol, sizeBytes, offset, kind, stream);
3607 }
3608 
3609 #endif
3610 
3611 #if USE_PROF_API
3612 #include <hip/hcc_detail/hip_prof_str.h>
3613 #endif
3614 
3615 #ifdef __cplusplus
3616 extern "C" {
3617 #endif
3618 
3621 hipError_t hipRegisterApiCallback(uint32_t id, void* fun, void* arg);
3622 hipError_t hipRemoveApiCallback(uint32_t id);
3623 hipError_t hipRegisterActivityCallback(uint32_t id, void* fun, void* arg);
3624 hipError_t hipRemoveActivityCallback(uint32_t id);
3625 const char* hipApiName(uint32_t id);
3626 const char* hipKernelNameRef(const hipFunction_t f);
3627 const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream);
3628 #ifdef __cplusplus
3629 } /* extern "C" */
3630 #endif
3631 
3632 #ifdef __cplusplus
3633 
3634 template <class T>
3636  int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk) {
3638  numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk);
3639 }
3640 
3641 template <class T>
3643  int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) {
3645  numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk, flags);
3646 }
3647 
3648 class TlsData;
3649 
3650 #if !__HIP_ROCclr__
3651 hipError_t hipBindTexture(size_t* offset, textureReference* tex, const void* devPtr,
3652  const hipChannelFormatDesc* desc, size_t size = UINT_MAX);
3653 #endif
3654 
3655 #if !__HIP_ROCclr__
3656 hipError_t ihipBindTextureImpl(TlsData *tls, int dim, enum hipTextureReadMode readMode, size_t* offset,
3657  const void* devPtr, const struct hipChannelFormatDesc* desc,
3658  size_t size, textureReference* tex);
3659 #endif
3660 
3661 /*
3662  * @brief hipBindTexture Binds size bytes of the memory area pointed to by @p devPtr to the texture
3663  *reference tex.
3664  *
3665  * @p desc describes how the memory is interpreted when fetching values from the texture. The @p
3666  *offset parameter is an optional byte offset as with the low-level hipBindTexture() function. Any
3667  *memory previously bound to tex is unbound.
3668  *
3669  * @param[in] offset - Offset in bytes
3670  * @param[out] tex - texture to bind
3671  * @param[in] devPtr - Memory area on device
3672  * @param[in] desc - Channel format
3673  * @param[in] size - Size of the memory area pointed to by devPtr
3674  * @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknown
3675  **/
3676 #if !__HIP_ROCclr__
3677 template <class T, int dim, enum hipTextureReadMode readMode>
3678 hipError_t hipBindTexture(size_t* offset, struct texture<T, dim, readMode>& tex, const void* devPtr,
3679  const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) {
3680  return ihipBindTextureImpl(nullptr, dim, readMode, offset, devPtr, &desc, size, &tex);
3681 }
3682 #endif
3683 
3684 /*
3685  * @brief hipBindTexture Binds size bytes of the memory area pointed to by @p devPtr to the texture
3686  *reference tex.
3687  *
3688  * @p desc describes how the memory is interpreted when fetching values from the texture. The @p
3689  *offset parameter is an optional byte offset as with the low-level hipBindTexture() function. Any
3690  *memory previously bound to tex is unbound.
3691  *
3692  * @param[in] offset - Offset in bytes
3693  * @param[in] tex - texture to bind
3694  * @param[in] devPtr - Memory area on device
3695  * @param[in] size - Size of the memory area pointed to by devPtr
3696  * @return #hipSuccess, #hipErrorInvalidValue, #hipErrorMemoryFree, #hipErrorUnknown
3697  **/
3698 #if !__HIP_ROCclr__
3699 template <class T, int dim, enum hipTextureReadMode readMode>
3700 hipError_t hipBindTexture(size_t* offset, struct texture<T, dim, readMode>& tex, const void* devPtr,
3701  size_t size = UINT_MAX) {
3702  return ihipBindTextureImpl(nullptr, dim, readMode, offset, devPtr, &(tex.channelDesc), size, &tex);
3703 }
3704 #endif
3705 
3706 // C API
3707 #if !__HIP_ROCclr__
3708 hipError_t hipBindTexture2D(size_t* offset, textureReference* tex, const void* devPtr,
3709  const hipChannelFormatDesc* desc, size_t width, size_t height,
3710  size_t pitch);
3711 #endif
3712 
3713 #if !__HIP_ROCclr__
3714 hipError_t ihipBindTexture2DImpl(int dim, enum hipTextureReadMode readMode, size_t* offset,
3715  const void* devPtr, const struct hipChannelFormatDesc* desc,
3716  size_t width, size_t height, textureReference* tex, size_t pitch);
3717 #endif
3718 
3719 #if !__HIP_ROCclr__
3720 template <class T, int dim, enum hipTextureReadMode readMode>
3721 hipError_t hipBindTexture2D(size_t* offset, struct texture<T, dim, readMode>& tex,
3722  const void* devPtr, size_t width, size_t height, size_t pitch) {
3723  return ihipBindTexture2DImpl(dim, readMode, offset, devPtr, &(tex.channelDesc), width, height,
3724  &tex);
3725 }
3726 #endif
3727 
3728 #if !__HIP_ROCclr__
3729 template <class T, int dim, enum hipTextureReadMode readMode>
3730 hipError_t hipBindTexture2D(size_t* offset, struct texture<T, dim, readMode>& tex,
3731  const void* devPtr, const struct hipChannelFormatDesc& desc,
3732  size_t width, size_t height, size_t pitch) {
3733  return ihipBindTexture2DImpl(dim, readMode, offset, devPtr, &desc, width, height, &tex);
3734 }
3735 #endif
3736 
3737 // C API
3738 #if !__HIP_ROCclr__
3739 hipError_t hipBindTextureToArray(textureReference* tex, hipArray_const_t array,
3740  const hipChannelFormatDesc* desc);
3741 #endif
3742 
3743 #if !__HIP_ROCclr__
3744 hipError_t ihipBindTextureToArrayImpl(TlsData *tls, int dim, enum hipTextureReadMode readMode,
3745  hipArray_const_t array,
3746  const struct hipChannelFormatDesc& desc,
3747  textureReference* tex);
3748 #endif
3749 
3750 #if !__HIP_ROCclr__
3751 template <class T, int dim, enum hipTextureReadMode readMode>
3752 hipError_t hipBindTextureToArray(struct texture<T, dim, readMode>& tex, hipArray_const_t array) {
3753  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, tex.channelDesc, &tex);
3754 }
3755 #endif
3756 
3757 #if !__HIP_ROCclr__
3758 template <class T, int dim, enum hipTextureReadMode readMode>
3759 hipError_t hipBindTextureToArray(struct texture<T, dim, readMode>& tex, hipArray_const_t array,
3760  const struct hipChannelFormatDesc& desc) {
3761  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, desc, &tex);
3762 }
3763 #endif
3764 
3765 #if !__HIP_ROCclr__
3766 template <class T, int dim, enum hipTextureReadMode readMode>
3767 inline static hipError_t hipBindTextureToArray(struct texture<T, dim, readMode> *tex,
3768  hipArray_const_t array,
3769  const struct hipChannelFormatDesc* desc) {
3770  return ihipBindTextureToArrayImpl(nullptr, dim, readMode, array, *desc, tex);
3771 }
3772 #endif
3773 
3774 // C API
3775 #if !__HIP_ROCclr__
3776 hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,
3777  hipMipmappedArray_const_t mipmappedArray,
3778  const hipChannelFormatDesc* desc);
3779 #endif
3780 
3781 #if !__HIP_ROCclr__
3782 template <class T, int dim, enum hipTextureReadMode readMode>
3783 hipError_t hipBindTextureToMipmappedArray(const texture<T, dim, readMode>& tex,
3784  hipMipmappedArray_const_t mipmappedArray) {
3785  return hipSuccess;
3786 }
3787 #endif
3788 
3789 #if !__HIP_ROCclr__
3790 template <class T, int dim, enum hipTextureReadMode readMode>
3791 hipError_t hipBindTextureToMipmappedArray(const texture<T, dim, readMode>& tex,
3792  hipMipmappedArray_const_t mipmappedArray,
3793  const hipChannelFormatDesc& desc) {
3794  return hipSuccess;
3795 }
3796 #endif
3797 
3798 #if __HIP_ROCclr__ && !defined(__HCC__)
3799 
3800 template <typename F>
3801 inline hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,
3802  F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {
3803 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize,(hipFunction_t)kernel, dynSharedMemPerBlk, blockSizeLimit);
3804 }
3805 
3806 template <class T>
3807 inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim,
3808  void** kernelParams, unsigned int sharedMemBytes, hipStream_t stream) {
3809  return hipLaunchCooperativeKernel(reinterpret_cast<const void*>(f), gridDim,
3810  blockDim, kernelParams, sharedMemBytes, stream);
3811 }
3812 
3813 template <class T>
3814 inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,
3815  unsigned int numDevices, unsigned int flags = 0) {
3816  return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);
3817 }
3818 
3819 
3820 template <class T>
3821 inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,
3822  unsigned int numDevices, unsigned int flags = 0) {
3823  return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);
3824 }
3825 
3826 #endif
3827 
3828 /*
3829  * @brief Unbinds the textuer bound to @p tex
3830  *
3831  * @param[in] tex - texture to unbind
3832  *
3833  * @return #hipSuccess
3834  **/
3835 #if !__HIP_ROCclr__
3836 hipError_t hipUnbindTexture(const textureReference* tex);
3837 #endif
3838 
3839 #if !__HIP_ROCclr__
3840 extern hipError_t ihipUnbindTextureImpl(const hipTextureObject_t& textureObject);
3841 #endif
3842 
3843 #if !__HIP_ROCclr__
3844 template <class T, int dim, enum hipTextureReadMode readMode>
3845 hipError_t hipUnbindTexture(struct texture<T, dim, readMode>& tex) {
3846  return ihipUnbindTextureImpl(tex.textureObject);
3847 }
3848 #endif
3849 
3850 #if !__HIP_ROCclr__
3851 hipError_t hipGetChannelDesc(hipChannelFormatDesc* desc, hipArray_const_t array);
3852 hipError_t hipGetTextureAlignmentOffset(size_t* offset, const textureReference* texref);
3853 hipError_t hipGetTextureReference(const textureReference** texref, const void* symbol);
3854 
3855 hipError_t hipCreateTextureObject(hipTextureObject_t* pTexObject, const hipResourceDesc* pResDesc,
3856  const hipTextureDesc* pTexDesc,
3857  const hipResourceViewDesc* pResViewDesc);
3858 
3859 hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);
3860 
3861 hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,
3862  hipTextureObject_t textureObject);
3863 hipError_t hipGetTextureObjectResourceViewDesc(hipResourceViewDesc* pResViewDesc,
3864  hipTextureObject_t textureObject);
3865 hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,
3866  hipTextureObject_t textureObject);
3867 hipError_t hipTexRefSetArray(textureReference* tex, hipArray_const_t array, unsigned int flags);
3868 
3869 hipError_t hipTexRefGetArray(hipArray_t* array, textureReference tex);
3870 
3871 hipError_t hipTexRefSetAddressMode(textureReference* tex, int dim, hipTextureAddressMode am);
3872 
3873 hipError_t hipTexRefGetAddressMode(hipTextureAddressMode* am, textureReference tex, int dim);
3874 
3875 hipError_t hipTexRefSetFilterMode(textureReference* tex, hipTextureFilterMode fm);
3876 
3877 hipError_t hipTexRefSetFlags(textureReference* tex, unsigned int flags);
3878 
3879 hipError_t hipTexRefSetFormat(textureReference* tex, hipArray_Format fmt, int NumPackedComponents);
3880 
3881 hipError_t hipTexRefSetAddress(size_t* offset, textureReference* tex, hipDeviceptr_t devPtr,
3882  size_t size);
3883 
3884 hipError_t hipTexRefGetAddress(hipDeviceptr_t* dev_ptr, textureReference tex);
3885 
3886 hipError_t hipTexRefSetAddress2D(textureReference* tex, const HIP_ARRAY_DESCRIPTOR* desc,
3887  hipDeviceptr_t devPtr, size_t pitch);
3888 #endif
3889 
3890 hipError_t hipCreateSurfaceObject(hipSurfaceObject_t* pSurfObject, const hipResourceDesc* pResDesc);
3891 
3892 hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);
3893 
3894 #if __HIP_ROCclr__
3895 template<class T, int dim, enum hipTextureReadMode readMode>
3896 static inline hipError_t hipBindTexture(
3897  size_t *offset,
3898  const struct texture<T, dim, readMode> &tex,
3899  const void *devPtr,
3900  size_t size = UINT_MAX)
3901 {
3902  return hipBindTexture(offset, &tex, devPtr, &tex.channelDesc, size);
3903 }
3904 
3905 template<class T, int dim, enum hipTextureReadMode readMode>
3906 static inline hipError_t hipBindTexture(
3907  size_t *offset,
3908  const struct texture<T, dim, readMode> &tex,
3909  const void *devPtr,
3910  const struct hipChannelFormatDesc &desc,
3911  size_t size = UINT_MAX)
3912 {
3913  return hipBindTexture(offset, &tex, devPtr, &desc, size);
3914 }
3915 
3916 template<class T, int dim, enum hipTextureReadMode readMode>
3917 static inline hipError_t hipBindTexture2D(
3918  size_t *offset,
3919  const struct texture<T, dim, readMode> &tex,
3920  const void *devPtr,
3921  size_t width,
3922  size_t height,
3923  size_t pitch)
3924 {
3925  return hipBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch);
3926 }
3927 
3928 template<class T, int dim, enum hipTextureReadMode readMode>
3929 static inline hipError_t hipBindTexture2D(
3930  size_t *offset,
3931  const struct texture<T, dim, readMode> &tex,
3932  const void *devPtr,
3933  const struct hipChannelFormatDesc &desc,
3934  size_t width,
3935  size_t height,
3936  size_t pitch)
3937 {
3938  return hipBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch);
3939 }
3940 
3941 template<class T, int dim, enum hipTextureReadMode readMode>
3942 static inline hipError_t hipBindTextureToArray(
3943  const struct texture<T, dim, readMode> &tex,
3944  hipArray_const_t array)
3945 {
3946  struct hipChannelFormatDesc desc;
3947  hipError_t err = hipGetChannelDesc(&desc, array);
3948  return (err == hipSuccess) ? hipBindTextureToArray(&tex, array, &desc) : err;
3949 }
3950 
3951 template<class T, int dim, enum hipTextureReadMode readMode>
3952 static inline hipError_t hipBindTextureToArray(
3953  const struct texture<T, dim, readMode> &tex,
3954  hipArray_const_t array,
3955  const struct hipChannelFormatDesc &desc)
3956 {
3957  return hipBindTextureToArray(&tex, array, &desc);
3958 }
3959 
3960 template<class T, int dim, enum hipTextureReadMode readMode>
3961 static inline hipError_t hipBindTextureToMipmappedArray(
3962  const struct texture<T, dim, readMode> &tex,
3963  hipMipmappedArray_const_t mipmappedArray)
3964 {
3965  struct hipChannelFormatDesc desc;
3966  hipArray_t levelArray;
3967  hipError_t err = hipGetMipmappedArrayLevel(&levelArray, mipmappedArray, 0);
3968  if (err != hipSuccess) {
3969  return err;
3970  }
3971  err = hipGetChannelDesc(&desc, levelArray);
3972  return (err == hipSuccess) ? hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc) : err;
3973 }
3974 
3975 template<class T, int dim, enum hipTextureReadMode readMode>
3976 static inline hipError_t hipBindTextureToMipmappedArray(
3977  const struct texture<T, dim, readMode> &tex,
3978  hipMipmappedArray_const_t mipmappedArray,
3979  const struct hipChannelFormatDesc &desc)
3980 {
3981  return hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc);
3982 }
3983 
3984 template<class T, int dim, enum hipTextureReadMode readMode>
3985 static inline hipError_t hipUnbindTexture(
3986  const struct texture<T, dim, readMode> &tex)
3987 {
3988  return hipUnbindTexture(&tex);
3989 }
3990 #endif
3991 
3992 // doxygen end Texture
3998 #endif
3999 
4000 #ifdef __GNUC__
4001 #pragma GCC visibility pop
4002 #endif
4003 
4021 // end-group HCC_Specific
4027 // doxygen end HIP API
4032 #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:2396
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)
Returns occupancy for a device function.
Definition: hip_module.cpp:1698
Definition: driver_types.h:337
prefer larger L1 cache and smaller shared memory
Definition: hip_runtime_api.h:253
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:1309
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:227
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:2286
hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)
Query the priority of a stream.
Definition: hip_stream.cpp:238
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:282
hipError_t hipPeekAtLastError(void)
Return last error returned by any HIP runtime API call.
Definition: hip_error.cpp:41
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags __dparm(hipOccupancyDefault))
Returns occupancy for a device function.
Definition: hip_hcc_internal.h:408
hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)
Copies memory for 2D arrays.
Definition: hip_memory.cpp:2144
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:434
hipError_t hipDeviceGetByPCIBusId(int *device, const char *pciBusId)
Returns a handle to a compute device.
Definition: hip_device.cpp:492
Definition: hip_runtime_api.h:113
hipError_t hipExtMallocWithFlags(void **ptr, size_t sizeBytes, unsigned int flags)
Allocate memory on the default accelerator.
Definition: hip_memory.cpp:723
hipError_t hipMemGetAddressRange(hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr)
Get information on memory allocations.
Definition: hip_memory.cpp:2437
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 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
Definition: hip_module.cpp:1656
hipError_t hipFreeHost(void *ptr)
Free memory allocated by the hcc hip host memory allocation API. [Deprecated].
Definition: hip_memory.cpp:2407
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:1494
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:1511
Definition: driver_types.h:370
hipError_t hipMallocPitch(void **ptr, size_t *pitch, size_t width, size_t height)
Definition: hip_memory.cpp:851
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:2271
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:2020
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:258
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:1511
uint32_t x
x
Definition: hip_runtime_api.h:274
hipError_t hipMemcpyAtoH(void *dst, hipArray *srcArray, size_t srcOffset, size_t count)
Copies data between host and device.
Definition: hip_memory.cpp:1544
hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)
Copies data between host and device.
hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)
Frees a mipmapped array on the device.
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:200
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:124
Definition: hip_runtime_api.h:159
hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)
Returns numerical values that correspond to the least and greatest stream priority.
Definition: hip_stream.cpp:122
hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)
Gets a mipmap level of a HIP mipmapped array.
prefer equal size L1 cache and shared memory
Definition: hip_runtime_api.h:254
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:2409
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:300
Definition: driver_types.h:262
hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void *src, size_t sizeBytes)
Copy data from Host to Device.
Definition: hip_memory.cpp:1374
hipError_t hipModuleUnload(hipModule_t module)
Frees the module.
Definition: hip_module.cpp:1244
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:394
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:193
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:2154
Definition: hip_hcc_internal.h:185
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.
Definition: hip_clang.cpp:409
hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)
Gets an interprocess memory handle for an existing device memory allocation.
Definition: hip_memory.cpp:2458
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:116
hipError_t hipHostMalloc(void **ptr, size_t size, unsigned int flags)
Allocate device accessible page locked host memory.
Definition: hip_memory.cpp:762
Definition: hip_hcc_internal.h:938
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
Definition: driver_types.h:287
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:1492
Definition: driver_types.h:78
hipDeviceAttribute_t
Definition: hip_runtime_api.h:287
hipError_t hipEventDestroy(hipEvent_t event)
Destroy the specified event.
Definition: hip_event.cpp:278
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:518
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:273
uint32_t y
y
Definition: hip_runtime_api.h:275
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition: hip_runtime_api.h:847
hipError_t hipModuleLoad(hipModule_t *module, const char *fname)
Loads code object from file into a hipModule_t.
Definition: hip_module.cpp:1497
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:201
#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:794
hipError_t hipMallocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
Definition: hip_memory.cpp:788
hipError_t hipEventElapsedTime(float *ms, hipEvent_t start, hipEvent_t stop)
Return the elapsed time between two events.
Definition: hip_event.cpp:344
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:186
hipError_t hipGetDeviceCount(int *count)
Return number of compute-capable devices.
Definition: hip_device.cpp:69
Definition: driver_types.h:69
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:2220
Definition: driver_types.h:383
hipError_t hipFuncGetAttribute(int *value, hipFunction_attribute attrib, hipFunction_t hfunc)
Find out a specific attribute for a given function.
Definition: hip_module.cpp:1411
hipError_t hipStreamDestroy(hipStream_t stream)
Destroys the specified stream.
Definition: hip_stream.cpp:195
hipError_t hipHostGetFlags(unsigned int *flagsPtr, void *hostPtr)
Return flags associated with host pointer.
Definition: hip_memory.cpp:1133
hipError_t hipStreamSynchronize(hipStream_t stream)
Wait for all commands in stream to complete.
Definition: hip_stream.cpp:184
Definition: driver_types.h:166
hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)
Definition: hip_memory.cpp:862
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:2494
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:1390
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:263
dim3 gridDim
Grid dimentions.
Definition: hip_runtime_api.h:284
no preference for shared memory or L1 (default)
Definition: hip_runtime_api.h:251
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:1091
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:1437
hipError_t hipMallocMipmappedArray(hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags __dparm(0))
Allocate a mipmapped array on the device.
void * func
Device function symbol.
Definition: hip_runtime_api.h:283
hipError_t hipDeviceSynchronize(void)
Waits on all active streams on current device.
Definition: hip_device.cpp:143
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:1382
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:446
hipError_t hipGetDeviceProperties(hipDeviceProp_t *prop, int deviceId)
Returns device properties.
Definition: hip_device.cpp:381
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:1158
Definition: driver_types.h:62
hipError_t hipMalloc(void **ptr, size_t size)
Allocate memory on the default accelerator.
Definition: hip_memory.cpp:695
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:2251
Definition: driver_types.h:363
dim3 blockDim
Block dimentions.
Definition: hip_runtime_api.h:285
hipFuncCache_t
Definition: hip_runtime_api.h:250
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 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 hipStreamGetFlags(hipStream_t stream, unsigned int *flags)
Return flags associated with this stream.
Definition: hip_stream.cpp:223
Defines surface types for HIP runtime.
hipStream_t stream
Stream identifier.
Definition: hip_runtime_api.h:288
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:2296
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:2344
uint32_t z
z
Definition: hip_runtime_api.h:276
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:148
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:1712
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:1528
hipError_t hipSetupArgument(const void *arg, size_t size, size_t offset)
Set a kernel argument.
Definition: hip_clang.cpp:467
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:1429
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:132
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:480
hipError_t hipMemAllocHost(void **ptr, size_t size)
Allocate pinned host memory [Deprecated].
Definition: hip_memory.cpp:791
hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)
Copies data between host and device asynchronously.
hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)
Set Cache configuration for a specific function.
Definition: hip_device.cpp:108
The compiler selects a device-specific value for the banking.
Definition: hip_runtime_api.h:262
Definition: hip_runtime.h:210
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:605
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:261
Definition: driver_types.h:38
Definition: hip_hcc_internal.h:759
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 hipDeviceGetAttribute(int *pi, hipDeviceAttribute_t attr, int deviceId)
Query for a specific device attribute.
Definition: hip_device.cpp:354
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:1422
hipError_t hipHostUnregister(void *hostPtr)
Un-register host pointer.
Definition: hip_memory.cpp:1233
Definition: hip_hcc_internal.h:580
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:207
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:1367
hipError_t hipEventCreate(hipEvent_t *event)
Definition: hip_event.cpp:207
Definition: driver_types.h:394
Definition: driver_types.h:91
Definition: hip_runtime_api.h:104
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:221
Definition: driver_types.h:323
hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)
The bank width of shared memory on current device is set.
Definition: hip_device.cpp:116
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:213
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:1113
Definition: hip_hcc_internal.h:415
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:460
prefer larger shared memory and smaller L1 cache
Definition: hip_runtime_api.h:252
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:1444
void ** args
Arguments.
Definition: hip_runtime_api.h:286
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:161
hipError_t hipFuncGetAttributes(struct hipFuncAttributes *attr, const void *func)
Find out attributes for a given function.
Definition: hip_module.cpp:1393
hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.
Definition: hip_module.cpp:1667
Definition: hip_runtime_api.h:265
hipError_t hipIpcCloseMemHandle(void *devPtr)
Close memory mapped with hipIpcOpenMemHandle.
Definition: hip_memory.cpp:2539
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
Definition: hip_module.cpp:1646
hipError_t hipPointerGetAttributes(hipPointerAttribute_t *attributes, const void *ptr)
Return attributes for the specified pointer.
Definition: hip_memory.cpp:617
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:287
hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk)
Returns occupancy for a device function.
Definition: hip_module.cpp:1677
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:2261
hipError_t hipProfilerStop()
Stop recording of profiling information. When using this API, start the profiler with profiling disab...
Definition: hip_hcc.cpp:2502
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:2281
hipError_t hipProfilerStart()
Start recording of profiling information When using this API, start the profiler with profiling disab...
Definition: hip_hcc.cpp:2496
hipError_t hipLaunchByPtr(const void *func)
Launch a kernel.
Definition: hip_clang.cpp:485
Definition: texture_types.h:95