HIP: Heterogenous-computing Interface for Portability
Loading...
Searching...
No Matches
hip_api_trace.hpp
1/*
2 Copyright (c) 2023 - 2024 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#pragma once
23
24#include <hip/hip_runtime.h>
25
26// Define some version macros for the API table. Use similar naming conventions to HSA-runtime
27// (MAJOR and STEP versions). Three groups at this time:
28//
29// (A) HIP_API_TABLE_* defines for versioning for API table structure
30// (B) HIP_RUNTIME_API_TABLE_* defines for versioning the HipDispatchTable struct
31// (C) HIP_COMPILER_API_TABLE_* defines for versioning the HipCompilerDispatchTable struct
32//
33// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! IMPORTANT !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
34//
35// 1. When new functions are added to the API table, always add the new function pointer to the
36// end of the table and increment the dispatch table's step version number. NEVER re-arrange
37// the order of the member variables in a dispatch table. This will break the ABI.
38// 2. In dire circumstances, if the type of an existing member variable in a dispatch
39// table has be changed because a data type has been changed/removed, increment the dispatch
40// table's major version number. If the function pointer type can no longer be declared, DO
41// NOT REMOVE IT! Make the function pointer type void* and have it always be set to a nullptr.
42//
43// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
44//
45// The major version number should (ideally) never need to be incremented.
46// - Increment the HIP_API_TABLE_MAJOR_VERSION for fundamental changes to the API table structs.
47// - Increment the HIP_RUNTIME_API_TABLE_MAJOR_VERSION for fundamental changes to the
48// HipDispatchTable struct, such as a *change* to type/name an existing member variable. DO NOT
49// REMOVE IT.
50// - Increment the HIP_COMPILER_API_TABLE_MAJOR_VERSION for fundamental changes to the
51// HipCompilerDispatchTable struct, such as a *change* to type/name an existing member variable.
52// DO NOT REMOVE IT.
53#define HIP_API_TABLE_MAJOR_VERSION 0
54#define HIP_COMPILER_API_TABLE_MAJOR_VERSION 0
55#define HIP_RUNTIME_API_TABLE_MAJOR_VERSION 0
56
57// The step version number should be changed whenever the size of the API table struct(s) change.
58// - Increment the HIP_API_TABLE_STEP_VERSION when/if new API table structs are added
59// - Increment the HIP_RUNTIME_API_TABLE_STEP_VERSION when new runtime API functions are added
60// - Increment the HIP_COMPILER_API_TABLE_STEP_VERSION when new compiler API functions are added
61// - Reset any of the *_STEP_VERSION defines to zero if the corresponding *_MAJOR_VERSION increases
62#define HIP_API_TABLE_STEP_VERSION 0
63#define HIP_COMPILER_API_TABLE_STEP_VERSION 0
64#define HIP_RUNTIME_API_TABLE_STEP_VERSION 4
65
66// HIP API interface
67typedef hipError_t (*t___hipPopCallConfiguration)(dim3* gridDim, dim3* blockDim, size_t* sharedMem,
68 hipStream_t* stream);
69typedef hipError_t (*t___hipPushCallConfiguration)(dim3 gridDim, dim3 blockDim, size_t sharedMem,
70 hipStream_t stream);
71typedef void** (*t___hipRegisterFatBinary)(const void* data);
72typedef void (*t___hipRegisterFunction)(void** modules, const void* hostFunction,
73 char* deviceFunction, const char* deviceName,
74 unsigned int threadLimit, uint3* tid, uint3* bid,
75 dim3* blockDim, dim3* gridDim, int* wSize);
76typedef void (*t___hipRegisterManagedVar)(void* hipModule, void** pointer, void* init_value,
77 const char* name, size_t size, unsigned align);
78typedef void (*t___hipRegisterSurface)(void** modules, void* var, char* hostVar,
79 char* deviceVar, int type, int ext);
80typedef void (*t___hipRegisterTexture)(void** modules, void* var, char* hostVar,
81 char* deviceVar, int type, int norm, int ext);
82typedef void (*t___hipRegisterVar)(void** modules, void* var, char* hostVar,
83 char* deviceVar, int ext, size_t size, int constant, int global);
84typedef void (*t___hipUnregisterFatBinary)(void** modules);
85
86typedef const char* (*t_hipApiName)(uint32_t id);
87typedef hipError_t (*t_hipArray3DCreate)(hipArray_t* array,
88 const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);
89typedef hipError_t (*t_hipArray3DGetDescriptor)(HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor,
90 hipArray_t array);
91typedef hipError_t (*t_hipArrayCreate)(hipArray_t* pHandle,
92 const HIP_ARRAY_DESCRIPTOR* pAllocateArray);
93typedef hipError_t (*t_hipArrayDestroy)(hipArray_t array);
94typedef hipError_t (*t_hipArrayGetDescriptor)(HIP_ARRAY_DESCRIPTOR* pArrayDescriptor,
95 hipArray_t array);
96typedef hipError_t (*t_hipArrayGetInfo)(hipChannelFormatDesc* desc, hipExtent* extent,
97 unsigned int* flags, hipArray_t array);
98typedef hipError_t (*t_hipBindTexture)(size_t* offset, const textureReference* tex,
99 const void* devPtr, const hipChannelFormatDesc* desc,
100 size_t size);
101typedef hipError_t (*t_hipBindTexture2D)(size_t* offset, const textureReference* tex,
102 const void* devPtr, const hipChannelFormatDesc* desc,
103 size_t width, size_t height, size_t pitch);
104typedef hipError_t (*t_hipBindTextureToArray)(const textureReference* tex, hipArray_const_t array,
105 const hipChannelFormatDesc* desc);
106typedef hipError_t (*t_hipBindTextureToMipmappedArray)(const textureReference* tex,
107 hipMipmappedArray_const_t mipmappedArray,
108 const hipChannelFormatDesc* desc);
109typedef hipError_t (*t_hipChooseDevice)(int* device, const hipDeviceProp_t* prop);
110typedef hipError_t (*t_hipChooseDeviceR0000)(int* device, const hipDeviceProp_tR0000* properties);
111typedef hipError_t (*t_hipConfigureCall)(dim3 gridDim, dim3 blockDim, size_t sharedMem,
112 hipStream_t stream);
113typedef hipError_t (*t_hipCreateSurfaceObject)(hipSurfaceObject_t* pSurfObject,
114 const hipResourceDesc* pResDesc);
115typedef hipError_t (*t_hipCreateTextureObject)(hipTextureObject_t* pTexObject,
116 const hipResourceDesc* pResDesc,
117 const hipTextureDesc* pTexDesc,
118 const struct hipResourceViewDesc* pResViewDesc);
119typedef hipError_t (*t_hipCtxCreate)(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);
120typedef hipError_t (*t_hipCtxDestroy)(hipCtx_t ctx);
121typedef hipError_t (*t_hipCtxDisablePeerAccess)(hipCtx_t peerCtx);
122typedef hipError_t (*t_hipCtxEnablePeerAccess)(hipCtx_t peerCtx, unsigned int flags);
123typedef hipError_t (*t_hipCtxGetApiVersion)(hipCtx_t ctx, int* apiVersion);
124typedef hipError_t (*t_hipCtxGetCacheConfig)(hipFuncCache_t* cacheConfig);
125typedef hipError_t (*t_hipCtxGetCurrent)(hipCtx_t* ctx);
126typedef hipError_t (*t_hipCtxGetDevice)(hipDevice_t* device);
127typedef hipError_t (*t_hipCtxGetFlags)(unsigned int* flags);
128typedef hipError_t (*t_hipCtxGetSharedMemConfig)(hipSharedMemConfig* pConfig);
129typedef hipError_t (*t_hipCtxPopCurrent)(hipCtx_t* ctx);
130typedef hipError_t (*t_hipCtxPushCurrent)(hipCtx_t ctx);
131typedef hipError_t (*t_hipCtxSetCacheConfig)(hipFuncCache_t cacheConfig);
132typedef hipError_t (*t_hipCtxSetCurrent)(hipCtx_t ctx);
133typedef hipError_t (*t_hipCtxSetSharedMemConfig)(hipSharedMemConfig config);
134typedef hipError_t (*t_hipCtxSynchronize)(void);
135typedef hipError_t (*t_hipDestroyExternalMemory)(hipExternalMemory_t extMem);
136typedef hipError_t (*t_hipDestroyExternalSemaphore)(hipExternalSemaphore_t extSem);
137typedef hipError_t (*t_hipDestroySurfaceObject)(hipSurfaceObject_t surfaceObject);
138typedef hipError_t (*t_hipDestroyTextureObject)(hipTextureObject_t textureObject);
139typedef hipError_t (*t_hipDeviceCanAccessPeer)(int* canAccessPeer, int deviceId, int peerDeviceId);
140typedef hipError_t (*t_hipDeviceComputeCapability)(int* major, int* minor, hipDevice_t device);
141typedef hipError_t (*t_hipDeviceDisablePeerAccess)(int peerDeviceId);
142typedef hipError_t (*t_hipDeviceEnablePeerAccess)(int peerDeviceId, unsigned int flags);
143typedef hipError_t (*t_hipDeviceGet)(hipDevice_t* device, int ordinal);
144typedef hipError_t (*t_hipDeviceGetAttribute)(int* pi, hipDeviceAttribute_t attr, int deviceId);
145typedef hipError_t (*t_hipDeviceGetByPCIBusId)(int* device, const char* pciBusId);
146typedef hipError_t (*t_hipDeviceGetCacheConfig)(hipFuncCache_t* cacheConfig);
147typedef hipError_t (*t_hipDeviceGetDefaultMemPool)(hipMemPool_t* mem_pool, int device);
148typedef hipError_t (*t_hipDeviceGetGraphMemAttribute)(int device, hipGraphMemAttributeType attr,
149 void* value);
150typedef hipError_t (*t_hipDeviceGetLimit)(size_t* pValue, enum hipLimit_t limit);
151typedef hipError_t (*t_hipDeviceGetMemPool)(hipMemPool_t* mem_pool, int device);
152typedef hipError_t (*t_hipDeviceGetName)(char* name, int len, hipDevice_t device);
153typedef hipError_t (*t_hipDeviceGetP2PAttribute)(int* value, hipDeviceP2PAttr attr, int srcDevice,
154 int dstDevice);
155typedef hipError_t (*t_hipDeviceGetPCIBusId)(char* pciBusId, int len, int device);
156typedef hipError_t (*t_hipDeviceGetSharedMemConfig)(hipSharedMemConfig* pConfig);
157typedef hipError_t (*t_hipDeviceGetStreamPriorityRange)(int* leastPriority, int* greatestPriority);
158typedef hipError_t (*t_hipDeviceGetUuid)(hipUUID* uuid, hipDevice_t device);
159typedef hipError_t (*t_hipDeviceGraphMemTrim)(int device);
160typedef hipError_t (*t_hipDevicePrimaryCtxGetState)(hipDevice_t dev, unsigned int* flags,
161 int* active);
162typedef hipError_t (*t_hipDevicePrimaryCtxRelease)(hipDevice_t dev);
163typedef hipError_t (*t_hipDevicePrimaryCtxReset)(hipDevice_t dev);
164typedef hipError_t (*t_hipDevicePrimaryCtxRetain)(hipCtx_t* pctx, hipDevice_t dev);
165typedef hipError_t (*t_hipDevicePrimaryCtxSetFlags)(hipDevice_t dev, unsigned int flags);
166typedef hipError_t (*t_hipDeviceReset)(void);
167typedef hipError_t (*t_hipDeviceSetCacheConfig)(hipFuncCache_t cacheConfig);
168typedef hipError_t (*t_hipDeviceSetGraphMemAttribute)(int device, hipGraphMemAttributeType attr,
169 void* value);
170typedef hipError_t (*t_hipDeviceSetLimit)(enum hipLimit_t limit, size_t value);
171typedef hipError_t (*t_hipDeviceSetMemPool)(int device, hipMemPool_t mem_pool);
172typedef hipError_t (*t_hipDeviceSetSharedMemConfig)(hipSharedMemConfig config);
173typedef hipError_t (*t_hipDeviceSynchronize)(void);
174typedef hipError_t (*t_hipDeviceTotalMem)(size_t* bytes, hipDevice_t device);
175typedef hipError_t (*t_hipDriverGetVersion)(int* driverVersion);
176typedef hipError_t (*t_hipDrvGetErrorName)(hipError_t hipError, const char** errorString);
177typedef hipError_t (*t_hipDrvGetErrorString)(hipError_t hipError, const char** errorString);
178typedef hipError_t (*t_hipDrvGraphAddMemcpyNode)(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,
179 const hipGraphNode_t* dependencies,
180 size_t numDependencies,
181 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);
182typedef hipError_t (*t_hipDrvMemcpy2DUnaligned)(const hip_Memcpy2D* pCopy);
183typedef hipError_t (*t_hipDrvMemcpy3D)(const HIP_MEMCPY3D* pCopy);
184typedef hipError_t (*t_hipDrvMemcpy3DAsync)(const HIP_MEMCPY3D* pCopy, hipStream_t stream);
185typedef hipError_t (*t_hipDrvPointerGetAttributes)(unsigned int numAttributes,
186 hipPointer_attribute* attributes, void** data,
187 hipDeviceptr_t ptr);
188typedef hipError_t (*t_hipEventCreate)(hipEvent_t* event);
189typedef hipError_t (*t_hipEventCreateWithFlags)(hipEvent_t* event, unsigned flags);
190typedef hipError_t (*t_hipEventDestroy)(hipEvent_t event);
191typedef hipError_t (*t_hipEventElapsedTime)(float* ms, hipEvent_t start, hipEvent_t stop);
192typedef hipError_t (*t_hipEventQuery)(hipEvent_t event);
193typedef hipError_t (*t_hipEventRecord)(hipEvent_t event, hipStream_t stream);
194typedef hipError_t (*t_hipEventSynchronize)(hipEvent_t event);
195typedef hipError_t (*t_hipExtGetLinkTypeAndHopCount)(int device1, int device2, uint32_t* linktype,
196 uint32_t* hopcount);
197typedef hipError_t (*t_hipExtLaunchKernel)(const void* function_address, dim3 numBlocks,
198 dim3 dimBlocks, void** args, size_t sharedMemBytes,
199 hipStream_t stream, hipEvent_t startEvent,
200 hipEvent_t stopEvent, int flags);
201typedef hipError_t (*t_hipExtLaunchMultiKernelMultiDevice)(hipLaunchParams* launchParamsList,
202 int numDevices, unsigned int flags);
203typedef hipError_t (*t_hipExtMallocWithFlags)(void** ptr, size_t sizeBytes, unsigned int flags);
204typedef hipError_t (*t_hipExtStreamCreateWithCUMask)(hipStream_t* stream, uint32_t cuMaskSize,
205 const uint32_t* cuMask);
206typedef hipError_t (*t_hipExtStreamGetCUMask)(hipStream_t stream, uint32_t cuMaskSize,
207 uint32_t* cuMask);
208typedef hipError_t (*t_hipExternalMemoryGetMappedBuffer)(
209 void** devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc* bufferDesc);
210typedef hipError_t (*t_hipFree)(void* ptr);
211typedef hipError_t (*t_hipFreeArray)(hipArray_t array);
212typedef hipError_t (*t_hipFreeAsync)(void* dev_ptr, hipStream_t stream);
213typedef hipError_t (*t_hipFreeHost)(void* ptr);
214typedef hipError_t (*t_hipFreeMipmappedArray)(hipMipmappedArray_t mipmappedArray);
215typedef hipError_t (*t_hipFuncGetAttribute)(int* value, hipFunction_attribute attrib,
216 hipFunction_t hfunc);
217typedef hipError_t (*t_hipFuncGetAttributes)(struct hipFuncAttributes* attr, const void* func);
218typedef hipError_t (*t_hipFuncSetAttribute)(const void* func, hipFuncAttribute attr, int value);
219typedef hipError_t (*t_hipFuncSetCacheConfig)(const void* func, hipFuncCache_t config);
220typedef hipError_t (*t_hipFuncSetSharedMemConfig)(const void* func, hipSharedMemConfig config);
221typedef hipError_t (*t_hipGLGetDevices)(unsigned int* pHipDeviceCount, int* pHipDevices,
222 unsigned int hipDeviceCount, hipGLDeviceList deviceList);
223typedef hipError_t (*t_hipGetChannelDesc)(hipChannelFormatDesc* desc, hipArray_const_t array);
224typedef hipError_t (*t_hipGetDevice)(int* deviceId);
225typedef hipError_t (*t_hipGetDeviceCount)(int* count);
226typedef hipError_t (*t_hipGetDeviceFlags)(unsigned int* flags);
227typedef hipError_t (*t_hipGetDevicePropertiesR0600)(hipDeviceProp_tR0600* prop, int device);
228typedef hipError_t (*t_hipGetDevicePropertiesR0000)(hipDeviceProp_tR0000* prop, int device);
229typedef const char* (*t_hipGetErrorName)(hipError_t hip_error);
230typedef const char* (*t_hipGetErrorString)(hipError_t hipError);
231typedef hipError_t (*t_hipGetLastError)(void);
232typedef hipError_t (*t_hipGetMipmappedArrayLevel)(hipArray_t* levelArray,
233 hipMipmappedArray_const_t mipmappedArray,
234 unsigned int level);
235typedef hipError_t (*t_hipGetSymbolAddress)(void** devPtr, const void* symbol);
236typedef hipError_t (*t_hipGetSymbolSize)(size_t* size, const void* symbol);
237typedef hipError_t (*t_hipGetTextureAlignmentOffset)(size_t* offset,
238 const textureReference* texref);
239typedef hipError_t (*t_hipGetTextureObjectResourceDesc)(hipResourceDesc* pResDesc,
240 hipTextureObject_t textureObject);
241typedef hipError_t (*t_hipGetTextureObjectResourceViewDesc)(
242 struct hipResourceViewDesc* pResViewDesc, hipTextureObject_t textureObject);
243typedef hipError_t (*t_hipGetTextureObjectTextureDesc)(hipTextureDesc* pTexDesc,
244 hipTextureObject_t textureObject);
245typedef hipError_t (*t_hipGetTextureReference)(const textureReference** texref, const void* symbol);
246typedef hipError_t (*t_hipGraphAddChildGraphNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
247 const hipGraphNode_t* pDependencies,
248 size_t numDependencies, hipGraph_t childGraph);
249typedef hipError_t (*t_hipGraphAddDependencies)(hipGraph_t graph, const hipGraphNode_t* from,
250 const hipGraphNode_t* to, size_t numDependencies);
251typedef hipError_t (*t_hipGraphAddEmptyNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
252 const hipGraphNode_t* pDependencies,
253 size_t numDependencies);
254typedef hipError_t (*t_hipGraphAddEventRecordNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
255 const hipGraphNode_t* pDependencies,
256 size_t numDependencies, hipEvent_t event);
257typedef hipError_t (*t_hipGraphAddEventWaitNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
258 const hipGraphNode_t* pDependencies,
259 size_t numDependencies, hipEvent_t event);
260typedef hipError_t (*t_hipGraphAddHostNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
261 const hipGraphNode_t* pDependencies,
262 size_t numDependencies,
263 const hipHostNodeParams* pNodeParams);
264typedef hipError_t (*t_hipGraphAddKernelNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
265 const hipGraphNode_t* pDependencies,
266 size_t numDependencies,
267 const hipKernelNodeParams* pNodeParams);
268typedef hipError_t (*t_hipGraphAddMemAllocNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
269 const hipGraphNode_t* pDependencies,
270 size_t numDependencies,
271 hipMemAllocNodeParams* pNodeParams);
272typedef hipError_t (*t_hipGraphAddMemFreeNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
273 const hipGraphNode_t* pDependencies,
274 size_t numDependencies, void* dev_ptr);
275typedef hipError_t (*t_hipGraphAddMemcpyNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
276 const hipGraphNode_t* pDependencies,
277 size_t numDependencies,
278 const hipMemcpy3DParms* pCopyParams);
279typedef hipError_t (*t_hipGraphAddMemcpyNode1D)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
280 const hipGraphNode_t* pDependencies,
281 size_t numDependencies, void* dst, const void* src,
282 size_t count, hipMemcpyKind kind);
283typedef hipError_t (*t_hipGraphAddMemcpyNodeFromSymbol)(hipGraphNode_t* pGraphNode,
284 hipGraph_t graph,
285 const hipGraphNode_t* pDependencies,
286 size_t numDependencies, void* dst,
287 const void* symbol, size_t count,
288 size_t offset, hipMemcpyKind kind);
289typedef hipError_t (*t_hipGraphAddMemcpyNodeToSymbol)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
290 const hipGraphNode_t* pDependencies,
291 size_t numDependencies, const void* symbol,
292 const void* src, size_t count, size_t offset,
293 hipMemcpyKind kind);
294typedef hipError_t (*t_hipGraphAddMemsetNode)(hipGraphNode_t* pGraphNode, hipGraph_t graph,
295 const hipGraphNode_t* pDependencies,
296 size_t numDependencies,
297 const hipMemsetParams* pMemsetParams);
298
299typedef hipError_t (*t_hipGraphChildGraphNodeGetGraph)(hipGraphNode_t node, hipGraph_t* pGraph);
300typedef hipError_t (*t_hipGraphClone)(hipGraph_t* pGraphClone, hipGraph_t originalGraph);
301typedef hipError_t (*t_hipGraphCreate)(hipGraph_t* pGraph, unsigned int flags);
302typedef hipError_t (*t_hipGraphDebugDotPrint)(hipGraph_t graph, const char* path,
303 unsigned int flags);
304typedef hipError_t (*t_hipGraphDestroy)(hipGraph_t graph);
305typedef hipError_t (*t_hipGraphDestroyNode)(hipGraphNode_t node);
306typedef hipError_t (*t_hipGraphEventRecordNodeGetEvent)(hipGraphNode_t node, hipEvent_t* event_out);
307typedef hipError_t (*t_hipGraphEventRecordNodeSetEvent)(hipGraphNode_t node, hipEvent_t event);
308typedef hipError_t (*t_hipGraphEventWaitNodeGetEvent)(hipGraphNode_t node, hipEvent_t* event_out);
309typedef hipError_t (*t_hipGraphEventWaitNodeSetEvent)(hipGraphNode_t node, hipEvent_t event);
310typedef hipError_t (*t_hipGraphExecChildGraphNodeSetParams)(hipGraphExec_t hGraphExec,
311 hipGraphNode_t node,
312 hipGraph_t childGraph);
313typedef hipError_t (*t_hipGraphExecDestroy)(hipGraphExec_t graphExec);
314typedef hipError_t (*t_hipGraphExecEventRecordNodeSetEvent)(hipGraphExec_t hGraphExec,
315 hipGraphNode_t hNode, hipEvent_t event);
316typedef hipError_t (*t_hipGraphExecEventWaitNodeSetEvent)(hipGraphExec_t hGraphExec,
317 hipGraphNode_t hNode, hipEvent_t event);
318typedef hipError_t (*t_hipGraphExecHostNodeSetParams)(hipGraphExec_t hGraphExec,
319 hipGraphNode_t node,
320 const hipHostNodeParams* pNodeParams);
321typedef hipError_t (*t_hipGraphExecKernelNodeSetParams)(hipGraphExec_t hGraphExec,
322 hipGraphNode_t node,
323 const hipKernelNodeParams* pNodeParams);
324typedef hipError_t (*t_hipGraphExecMemcpyNodeSetParams)(hipGraphExec_t hGraphExec,
325 hipGraphNode_t node,
326 hipMemcpy3DParms* pNodeParams);
327typedef hipError_t (*t_hipGraphExecMemcpyNodeSetParams1D)(hipGraphExec_t hGraphExec,
328 hipGraphNode_t node, void* dst,
329 const void* src, size_t count,
330 hipMemcpyKind kind);
331typedef hipError_t (*t_hipGraphExecMemcpyNodeSetParamsFromSymbol)(hipGraphExec_t hGraphExec,
332 hipGraphNode_t node, void* dst,
333 const void* symbol, size_t count,
334 size_t offset,
335 hipMemcpyKind kind);
336typedef hipError_t (*t_hipGraphExecMemcpyNodeSetParamsToSymbol)(hipGraphExec_t hGraphExec,
337 hipGraphNode_t node,
338 const void* symbol, const void* src,
339 size_t count, size_t offset,
340 hipMemcpyKind kind);
341typedef hipError_t (*t_hipGraphExecMemsetNodeSetParams)(hipGraphExec_t hGraphExec,
342 hipGraphNode_t node,
343 const hipMemsetParams* pNodeParams);
344typedef hipError_t (*t_hipGraphExecUpdate)(hipGraphExec_t hGraphExec, hipGraph_t hGraph,
345 hipGraphNode_t* hErrorNode_out,
346 hipGraphExecUpdateResult* updateResult_out);
347typedef hipError_t (*t_hipGraphGetEdges)(hipGraph_t graph, hipGraphNode_t* from, hipGraphNode_t* to,
348 size_t* numEdges);
349typedef hipError_t (*t_hipGraphGetNodes)(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes);
350typedef hipError_t (*t_hipGraphGetRootNodes)(hipGraph_t graph, hipGraphNode_t* pRootNodes,
351 size_t* pNumRootNodes);
352typedef hipError_t (*t_hipGraphHostNodeGetParams)(hipGraphNode_t node,
353 hipHostNodeParams* pNodeParams);
354typedef hipError_t (*t_hipGraphHostNodeSetParams)(hipGraphNode_t node,
355 const hipHostNodeParams* pNodeParams);
356typedef hipError_t (*t_hipGraphInstantiate)(hipGraphExec_t* pGraphExec, hipGraph_t graph,
357 hipGraphNode_t* pErrorNode, char* pLogBuffer,
358 size_t bufferSize);
359typedef hipError_t (*t_hipGraphInstantiateWithFlags)(hipGraphExec_t* pGraphExec, hipGraph_t graph,
360 unsigned long long flags);
361typedef hipError_t (*t_hipGraphKernelNodeCopyAttributes)(hipGraphNode_t hSrc, hipGraphNode_t hDst);
362typedef hipError_t (*t_hipGraphKernelNodeGetAttribute)(hipGraphNode_t hNode,
363 hipKernelNodeAttrID attr,
364 hipKernelNodeAttrValue* value);
365typedef hipError_t (*t_hipGraphKernelNodeGetParams)(hipGraphNode_t node,
366 hipKernelNodeParams* pNodeParams);
367typedef hipError_t (*t_hipGraphKernelNodeSetAttribute)(hipGraphNode_t hNode,
368 hipKernelNodeAttrID attr,
369 const hipKernelNodeAttrValue* value);
370typedef hipError_t (*t_hipGraphKernelNodeSetParams)(hipGraphNode_t node,
371 const hipKernelNodeParams* pNodeParams);
372typedef hipError_t (*t_hipGraphLaunch)(hipGraphExec_t graphExec, hipStream_t stream);
373typedef hipError_t (*t_hipGraphMemAllocNodeGetParams)(hipGraphNode_t node,
374 hipMemAllocNodeParams* pNodeParams);
375typedef hipError_t (*t_hipGraphMemFreeNodeGetParams)(hipGraphNode_t node, void* dev_ptr);
376typedef hipError_t (*t_hipGraphMemcpyNodeGetParams)(hipGraphNode_t node,
377 hipMemcpy3DParms* pNodeParams);
378typedef hipError_t (*t_hipGraphMemcpyNodeSetParams)(hipGraphNode_t node,
379 const hipMemcpy3DParms* pNodeParams);
380typedef hipError_t (*t_hipGraphMemcpyNodeSetParams1D)(hipGraphNode_t node, void* dst,
381 const void* src, size_t count,
382 hipMemcpyKind kind);
383typedef hipError_t (*t_hipGraphMemcpyNodeSetParamsFromSymbol)(hipGraphNode_t node, void* dst,
384 const void* symbol, size_t count,
385 size_t offset, hipMemcpyKind kind);
386typedef hipError_t (*t_hipGraphMemcpyNodeSetParamsToSymbol)(hipGraphNode_t node, const void* symbol,
387 const void* src, size_t count,
388 size_t offset, hipMemcpyKind kind);
389typedef hipError_t (*t_hipGraphMemsetNodeGetParams)(hipGraphNode_t node,
390 hipMemsetParams* pNodeParams);
391typedef hipError_t (*t_hipGraphMemsetNodeSetParams)(hipGraphNode_t node,
392 const hipMemsetParams* pNodeParams);
393typedef hipError_t (*t_hipGraphNodeFindInClone)(hipGraphNode_t* pNode, hipGraphNode_t originalNode,
394 hipGraph_t clonedGraph);
395typedef hipError_t (*t_hipGraphNodeGetDependencies)(hipGraphNode_t node,
396 hipGraphNode_t* pDependencies,
397 size_t* pNumDependencies);
398typedef hipError_t (*t_hipGraphNodeGetDependentNodes)(hipGraphNode_t node,
399 hipGraphNode_t* pDependentNodes,
400 size_t* pNumDependentNodes);
401typedef hipError_t (*t_hipGraphNodeGetEnabled)(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,
402 unsigned int* isEnabled);
403typedef hipError_t (*t_hipGraphNodeGetType)(hipGraphNode_t node, hipGraphNodeType* pType);
404typedef hipError_t (*t_hipGraphNodeSetEnabled)(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,
405 unsigned int isEnabled);
406typedef hipError_t (*t_hipGraphReleaseUserObject)(hipGraph_t graph, hipUserObject_t object,
407 unsigned int count);
408typedef hipError_t (*t_hipGraphRemoveDependencies)(hipGraph_t graph, const hipGraphNode_t* from,
409 const hipGraphNode_t* to,
410 size_t numDependencies);
411typedef hipError_t (*t_hipGraphRetainUserObject)(hipGraph_t graph, hipUserObject_t object,
412 unsigned int count, unsigned int flags);
413typedef hipError_t (*t_hipGraphUpload)(hipGraphExec_t graphExec, hipStream_t stream);
414typedef hipError_t (*t_hipGraphicsGLRegisterBuffer)(hipGraphicsResource** resource, GLuint buffer,
415 unsigned int flags);
416typedef hipError_t (*t_hipGraphicsGLRegisterImage)(hipGraphicsResource** resource, GLuint image,
417 GLenum target, unsigned int flags);
418typedef hipError_t (*t_hipGraphicsMapResources)(int count, hipGraphicsResource_t* resources,
419 hipStream_t stream);
420typedef hipError_t (*t_hipGraphicsResourceGetMappedPointer)(void** devPtr, size_t* size,
421 hipGraphicsResource_t resource);
422typedef hipError_t (*t_hipGraphicsSubResourceGetMappedArray)(hipArray_t* array,
423 hipGraphicsResource_t resource,
424 unsigned int arrayIndex,
425 unsigned int mipLevel);
426typedef hipError_t (*t_hipGraphicsUnmapResources)(int count, hipGraphicsResource_t* resources,
427 hipStream_t stream);
428typedef hipError_t (*t_hipGraphicsUnregisterResource)(hipGraphicsResource_t resource);
429typedef hipError_t (*t_hipHostAlloc)(void** ptr, size_t size, unsigned int flags);
430typedef hipError_t (*t_hipHostFree)(void* ptr);
431typedef hipError_t (*t_hipHostGetDevicePointer)(void** devPtr, void* hstPtr, unsigned int flags);
432typedef hipError_t (*t_hipHostGetFlags)(unsigned int* flagsPtr, void* hostPtr);
433typedef hipError_t (*t_hipHostMalloc)(void** ptr, size_t size, unsigned int flags);
434typedef hipError_t (*t_hipHostRegister)(void* hostPtr, size_t sizeBytes, unsigned int flags);
435typedef hipError_t (*t_hipHostUnregister)(void* hostPtr);
436typedef hipError_t (*t_hipImportExternalMemory)(hipExternalMemory_t* extMem_out,
437 const hipExternalMemoryHandleDesc* memHandleDesc);
438typedef hipError_t (*t_hipImportExternalSemaphore)(
439 hipExternalSemaphore_t* extSem_out, const hipExternalSemaphoreHandleDesc* semHandleDesc);
440typedef hipError_t (*t_hipInit)(unsigned int flags);
441typedef hipError_t (*t_hipIpcCloseMemHandle)(void* devPtr);
442typedef hipError_t (*t_hipIpcGetEventHandle)(hipIpcEventHandle_t* handle, hipEvent_t event);
443typedef hipError_t (*t_hipIpcGetMemHandle)(hipIpcMemHandle_t* handle, void* devPtr);
444typedef hipError_t (*t_hipIpcOpenEventHandle)(hipEvent_t* event, hipIpcEventHandle_t handle);
445typedef hipError_t (*t_hipIpcOpenMemHandle)(void** devPtr, hipIpcMemHandle_t handle,
446 unsigned int flags);
447typedef const char* (*t_hipKernelNameRef)(const hipFunction_t f);
448typedef const char* (*t_hipKernelNameRefByPtr)(const void* hostFunction, hipStream_t stream);
449typedef hipError_t (*t_hipLaunchByPtr)(const void* func);
450typedef hipError_t (*t_hipLaunchCooperativeKernel)(const void* f, dim3 gridDim, dim3 blockDimX,
451 void** kernelParams, unsigned int sharedMemBytes,
452 hipStream_t stream);
453typedef hipError_t (*t_hipLaunchCooperativeKernelMultiDevice)(hipLaunchParams* launchParamsList,
454 int numDevices, unsigned int flags);
455typedef hipError_t (*t_hipLaunchHostFunc)(hipStream_t stream, hipHostFn_t fn, void* userData);
456typedef hipError_t (*t_hipLaunchKernel)(const void* function_address, dim3 numBlocks,
457 dim3 dimBlocks, void** args, size_t sharedMemBytes,
458 hipStream_t stream);
459typedef hipError_t (*t_hipMalloc)(void** ptr, size_t size);
460typedef hipError_t (*t_hipMalloc3D)(hipPitchedPtr* pitchedDevPtr, hipExtent extent);
461typedef hipError_t (*t_hipMalloc3DArray)(hipArray_t* array, const struct hipChannelFormatDesc* desc,
462 struct hipExtent extent, unsigned int flags);
463typedef hipError_t (*t_hipMallocArray)(hipArray_t* array, const hipChannelFormatDesc* desc,
464 size_t width, size_t height, unsigned int flags);
465typedef hipError_t (*t_hipMallocAsync)(void** dev_ptr, size_t size, hipStream_t stream);
466typedef hipError_t (*t_hipMallocFromPoolAsync)(void** dev_ptr, size_t size, hipMemPool_t mem_pool,
467 hipStream_t stream);
468typedef hipError_t (*t_hipMallocHost)(void** ptr, size_t size);
469typedef hipError_t (*t_hipMallocManaged)(void** dev_ptr, size_t size, unsigned int flags);
470typedef hipError_t (*t_hipMallocMipmappedArray)(hipMipmappedArray_t* mipmappedArray,
471 const struct hipChannelFormatDesc* desc,
472 struct hipExtent extent, unsigned int numLevels,
473 unsigned int flags);
474typedef hipError_t (*t_hipMallocPitch)(void** ptr, size_t* pitch, size_t width, size_t height);
475typedef hipError_t (*t_hipMemAddressFree)(void* devPtr, size_t size);
476typedef hipError_t (*t_hipMemAddressReserve)(void** ptr, size_t size, size_t alignment, void* addr,
477 unsigned long long flags);
478typedef hipError_t (*t_hipMemAdvise)(const void* dev_ptr, size_t count, hipMemoryAdvise advice,
479 int device);
480typedef hipError_t (*t_hipMemAllocHost)(void** ptr, size_t size);
481typedef hipError_t (*t_hipMemAllocPitch)(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes,
482 size_t height, unsigned int elementSizeBytes);
483typedef hipError_t (*t_hipMemCreate)(hipMemGenericAllocationHandle_t* handle, size_t size,
484 const hipMemAllocationProp* prop, unsigned long long flags);
485typedef hipError_t (*t_hipMemExportToShareableHandle)(void* shareableHandle,
486 hipMemGenericAllocationHandle_t handle,
487 hipMemAllocationHandleType handleType,
488 unsigned long long flags);
489typedef hipError_t (*t_hipMemGetAccess)(unsigned long long* flags, const hipMemLocation* location,
490 void* ptr);
491typedef hipError_t (*t_hipMemGetAddressRange)(hipDeviceptr_t* pbase, size_t* psize,
492 hipDeviceptr_t dptr);
493typedef hipError_t (*t_hipMemGetAllocationGranularity)(size_t* granularity,
494 const hipMemAllocationProp* prop,
495 hipMemAllocationGranularity_flags option);
496typedef hipError_t (*t_hipMemGetAllocationPropertiesFromHandle)(
497 hipMemAllocationProp* prop, hipMemGenericAllocationHandle_t handle);
498typedef hipError_t (*t_hipMemGetInfo)(size_t* free, size_t* total);
499typedef hipError_t (*t_hipMemImportFromShareableHandle)(hipMemGenericAllocationHandle_t* handle,
500 void* osHandle,
501 hipMemAllocationHandleType shHandleType);
502typedef hipError_t (*t_hipMemMap)(void* ptr, size_t size, size_t offset,
503 hipMemGenericAllocationHandle_t handle, unsigned long long flags);
504typedef hipError_t (*t_hipMemMapArrayAsync)(hipArrayMapInfo* mapInfoList, unsigned int count,
505 hipStream_t stream);
506typedef hipError_t (*t_hipMemPoolCreate)(hipMemPool_t* mem_pool, const hipMemPoolProps* pool_props);
507typedef hipError_t (*t_hipMemPoolDestroy)(hipMemPool_t mem_pool);
508typedef hipError_t (*t_hipMemPoolExportPointer)(hipMemPoolPtrExportData* export_data,
509 void* dev_ptr);
510typedef hipError_t (*t_hipMemPoolExportToShareableHandle)(void* shared_handle,
511 hipMemPool_t mem_pool,
512 hipMemAllocationHandleType handle_type,
513 unsigned int flags);
514typedef hipError_t (*t_hipMemPoolGetAccess)(hipMemAccessFlags* flags, hipMemPool_t mem_pool,
515 hipMemLocation* location);
516typedef hipError_t (*t_hipMemPoolGetAttribute)(hipMemPool_t mem_pool, hipMemPoolAttr attr,
517 void* value);
518typedef hipError_t (*t_hipMemPoolImportFromShareableHandle)(hipMemPool_t* mem_pool,
519 void* shared_handle,
520 hipMemAllocationHandleType handle_type,
521 unsigned int flags);
522typedef hipError_t (*t_hipMemPoolImportPointer)(void** dev_ptr, hipMemPool_t mem_pool,
523 hipMemPoolPtrExportData* export_data);
524typedef hipError_t (*t_hipMemPoolSetAccess)(hipMemPool_t mem_pool,
525 const hipMemAccessDesc* desc_list, size_t count);
526typedef hipError_t (*t_hipMemPoolSetAttribute)(hipMemPool_t mem_pool, hipMemPoolAttr attr,
527 void* value);
528typedef hipError_t (*t_hipMemPoolTrimTo)(hipMemPool_t mem_pool, size_t min_bytes_to_hold);
529typedef hipError_t (*t_hipMemPrefetchAsync)(const void* dev_ptr, size_t count, int device,
530 hipStream_t stream);
531typedef hipError_t (*t_hipMemPtrGetInfo)(void* ptr, size_t* size);
532typedef hipError_t (*t_hipMemRangeGetAttribute)(void* data, size_t data_size,
533 hipMemRangeAttribute attribute, const void* dev_ptr,
534 size_t count);
535typedef hipError_t (*t_hipMemRangeGetAttributes)(void** data, size_t* data_sizes,
536 hipMemRangeAttribute* attributes,
537 size_t num_attributes, const void* dev_ptr,
538 size_t count);
539typedef hipError_t (*t_hipMemRelease)(hipMemGenericAllocationHandle_t handle);
540typedef hipError_t (*t_hipMemRetainAllocationHandle)(hipMemGenericAllocationHandle_t* handle,
541 void* addr);
542typedef hipError_t (*t_hipMemSetAccess)(void* ptr, size_t size, const hipMemAccessDesc* desc,
543 size_t count);
544typedef hipError_t (*t_hipMemUnmap)(void* ptr, size_t size);
545typedef hipError_t (*t_hipMemcpy)(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);
546typedef hipError_t (*t_hipMemcpy2D)(void* dst, size_t dpitch, const void* src, size_t spitch,
547 size_t width, size_t height, hipMemcpyKind kind);
548typedef hipError_t (*t_hipMemcpy2DAsync)(void* dst, size_t dpitch, const void* src, size_t spitch,
549 size_t width, size_t height, hipMemcpyKind kind,
550 hipStream_t stream);
551typedef hipError_t (*t_hipMemcpy2DFromArray)(void* dst, size_t dpitch, hipArray_const_t src,
552 size_t wOffset, size_t hOffset, size_t width,
553 size_t height, hipMemcpyKind kind);
554typedef hipError_t (*t_hipMemcpy2DFromArrayAsync)(void* dst, size_t dpitch, hipArray_const_t src,
555 size_t wOffset, size_t hOffset, size_t width,
556 size_t height, hipMemcpyKind kind,
557 hipStream_t stream);
558typedef hipError_t (*t_hipMemcpy2DToArray)(hipArray_t dst, size_t wOffset, size_t hOffset,
559 const void* src, size_t spitch, size_t width,
560 size_t height, hipMemcpyKind kind);
561typedef hipError_t (*t_hipMemcpy2DToArrayAsync)(hipArray_t dst, size_t wOffset, size_t hOffset,
562 const void* src, size_t spitch, size_t width,
563 size_t height, hipMemcpyKind kind,
564 hipStream_t stream);
565typedef hipError_t (*t_hipMemcpy3D)(const struct hipMemcpy3DParms* p);
566typedef hipError_t (*t_hipMemcpy3DAsync)(const struct hipMemcpy3DParms* p, hipStream_t stream);
567typedef hipError_t (*t_hipMemcpyAsync)(void* dst, const void* src, size_t sizeBytes,
568 hipMemcpyKind kind, hipStream_t stream);
569typedef hipError_t (*t_hipMemcpyAtoH)(void* dst, hipArray_t srcArray, size_t srcOffset,
570 size_t count);
571typedef hipError_t (*t_hipMemcpyDtoD)(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes);
572typedef hipError_t (*t_hipMemcpyDtoDAsync)(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,
573 hipStream_t stream);
574typedef hipError_t (*t_hipMemcpyDtoH)(void* dst, hipDeviceptr_t src, size_t sizeBytes);
575typedef hipError_t (*t_hipMemcpyDtoHAsync)(void* dst, hipDeviceptr_t src, size_t sizeBytes,
576 hipStream_t stream);
577typedef hipError_t (*t_hipMemcpyFromArray)(void* dst, hipArray_const_t srcArray, size_t wOffset,
578 size_t hOffset, size_t count, hipMemcpyKind kind);
579typedef hipError_t (*t_hipMemcpyFromSymbol)(void* dst, const void* symbol, size_t sizeBytes,
580 size_t offset, hipMemcpyKind kind);
581typedef hipError_t (*t_hipMemcpyFromSymbolAsync)(void* dst, const void* symbol, size_t sizeBytes,
582 size_t offset, hipMemcpyKind kind,
583 hipStream_t stream);
584typedef hipError_t (*t_hipMemcpyHtoA)(hipArray_t dstArray, size_t dstOffset, const void* srcHost,
585 size_t count);
586typedef hipError_t (*t_hipMemcpyHtoD)(hipDeviceptr_t dst, void* src, size_t sizeBytes);
587typedef hipError_t (*t_hipMemcpyHtoDAsync)(hipDeviceptr_t dst, void* src, size_t sizeBytes,
588 hipStream_t stream);
589typedef hipError_t (*t_hipMemcpyParam2D)(const hip_Memcpy2D* pCopy);
590typedef hipError_t (*t_hipMemcpyParam2DAsync)(const hip_Memcpy2D* pCopy, hipStream_t stream);
591typedef hipError_t (*t_hipMemcpyPeer)(void* dst, int dstDeviceId, const void* src, int srcDeviceId,
592 size_t sizeBytes);
593typedef hipError_t (*t_hipMemcpyPeerAsync)(void* dst, int dstDeviceId, const void* src,
594 int srcDevice, size_t sizeBytes, hipStream_t stream);
595typedef hipError_t (*t_hipMemcpyToArray)(hipArray_t dst, size_t wOffset, size_t hOffset,
596 const void* src, size_t count, hipMemcpyKind kind);
597typedef hipError_t (*t_hipMemcpyToSymbol)(const void* symbol, const void* src, size_t sizeBytes,
598 size_t offset, hipMemcpyKind kind);
599typedef hipError_t (*t_hipMemcpyToSymbolAsync)(const void* symbol, const void* src,
600 size_t sizeBytes, size_t offset, hipMemcpyKind kind,
601 hipStream_t stream);
602typedef hipError_t (*t_hipMemcpyWithStream)(void* dst, const void* src, size_t sizeBytes,
603 hipMemcpyKind kind, hipStream_t stream);
604typedef hipError_t (*t_hipMemset)(void* dst, int value, size_t sizeBytes);
605typedef hipError_t (*t_hipMemset2D)(void* dst, size_t pitch, int value, size_t width,
606 size_t height);
607typedef hipError_t (*t_hipMemset2DAsync)(void* dst, size_t pitch, int value, size_t width,
608 size_t height, hipStream_t stream);
609typedef hipError_t (*t_hipMemset3D)(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent);
610typedef hipError_t (*t_hipMemset3DAsync)(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent,
611 hipStream_t stream);
612typedef hipError_t (*t_hipMemsetAsync)(void* dst, int value, size_t sizeBytes, hipStream_t stream);
613typedef hipError_t (*t_hipMemsetD16)(hipDeviceptr_t dest, unsigned short value, size_t count);
614typedef hipError_t (*t_hipMemsetD16Async)(hipDeviceptr_t dest, unsigned short value, size_t count,
615 hipStream_t stream);
616typedef hipError_t (*t_hipMemsetD32)(hipDeviceptr_t dest, int value, size_t count);
617typedef hipError_t (*t_hipMemsetD32Async)(hipDeviceptr_t dst, int value, size_t count,
618 hipStream_t stream);
619typedef hipError_t (*t_hipMemsetD8)(hipDeviceptr_t dest, unsigned char value, size_t count);
620typedef hipError_t (*t_hipMemsetD8Async)(hipDeviceptr_t dest, unsigned char value, size_t count,
621 hipStream_t stream);
622typedef hipError_t (*t_hipMipmappedArrayCreate)(hipMipmappedArray_t* pHandle,
623 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,
624 unsigned int numMipmapLevels);
625typedef hipError_t (*t_hipMipmappedArrayDestroy)(hipMipmappedArray_t hMipmappedArray);
626typedef hipError_t (*t_hipMipmappedArrayGetLevel)(hipArray_t* pLevelArray,
627 hipMipmappedArray_t hMipMappedArray,
628 unsigned int level);
629typedef hipError_t (*t_hipModuleGetFunction)(hipFunction_t* function, hipModule_t module,
630 const char* kname);
631typedef hipError_t (*t_hipModuleGetGlobal)(hipDeviceptr_t* dptr, size_t* bytes, hipModule_t hmod,
632 const char* name);
633typedef hipError_t (*t_hipModuleGetTexRef)(textureReference** texRef, hipModule_t hmod,
634 const char* name);
635typedef hipError_t (*t_hipModuleLaunchCooperativeKernel)(
636 hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ,
637 unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ,
638 unsigned int sharedMemBytes, hipStream_t stream, void** kernelParams);
639typedef hipError_t (*t_hipModuleLaunchCooperativeKernelMultiDevice)(
640 hipFunctionLaunchParams* launchParamsList, unsigned int numDevices, unsigned int flags);
641typedef hipError_t (*t_hipModuleLaunchKernel)(hipFunction_t f, unsigned int gridDimX,
642 unsigned int gridDimY, unsigned int gridDimZ,
643 unsigned int blockDimX, unsigned int blockDimY,
644 unsigned int blockDimZ, unsigned int sharedMemBytes,
645 hipStream_t stream, void** kernelParams,
646 void** extra);
647typedef hipError_t (*t_hipModuleLoad)(hipModule_t* module, const char* fname);
648typedef hipError_t (*t_hipModuleLoadData)(hipModule_t* module, const void* image);
649typedef hipError_t (*t_hipModuleLoadDataEx)(hipModule_t* module, const void* image,
650 unsigned int numOptions, hipJitOption* options,
651 void** optionValues);
652typedef hipError_t (*t_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor)(
653 int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk);
654typedef hipError_t (*t_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)(
655 int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);
656typedef hipError_t (*t_hipModuleOccupancyMaxPotentialBlockSize)(int* gridSize, int* blockSize,
657 hipFunction_t f,
658 size_t dynSharedMemPerBlk,
659 int blockSizeLimit);
660typedef hipError_t (*t_hipModuleOccupancyMaxPotentialBlockSizeWithFlags)(
661 int* gridSize, int* blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit,
662 unsigned int flags);
663typedef hipError_t (*t_hipModuleUnload)(hipModule_t module);
664typedef hipError_t (*t_hipOccupancyMaxActiveBlocksPerMultiprocessor)(int* numBlocks, const void* f,
665 int blockSize,
666 size_t dynSharedMemPerBlk);
667typedef hipError_t (*t_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)(
668 int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);
669typedef hipError_t (*t_hipOccupancyMaxPotentialBlockSize)(int* gridSize, int* blockSize,
670 const void* f, size_t dynSharedMemPerBlk,
671 int blockSizeLimit);
672typedef hipError_t (*t_hipPeekAtLastError)(void);
673typedef hipError_t (*t_hipPointerGetAttribute)(void* data, hipPointer_attribute attribute,
674 hipDeviceptr_t ptr);
675typedef hipError_t (*t_hipPointerGetAttributes)(hipPointerAttribute_t* attributes, const void* ptr);
676typedef hipError_t (*t_hipPointerSetAttribute)(const void* value, hipPointer_attribute attribute,
677 hipDeviceptr_t ptr);
678typedef hipError_t (*t_hipProfilerStart)();
679typedef hipError_t (*t_hipProfilerStop)();
680typedef hipError_t (*t_hipRuntimeGetVersion)(int* runtimeVersion);
681typedef hipError_t (*t_hipSetDevice)(int deviceId);
682typedef hipError_t (*t_hipSetDeviceFlags)(unsigned flags);
683typedef hipError_t (*t_hipSetupArgument)(const void* arg, size_t size, size_t offset);
684typedef hipError_t (*t_hipSignalExternalSemaphoresAsync)(
685 const hipExternalSemaphore_t* extSemArray, const hipExternalSemaphoreSignalParams* paramsArray,
686 unsigned int numExtSems, hipStream_t stream);
687typedef hipError_t (*t_hipStreamAddCallback)(hipStream_t stream, hipStreamCallback_t callback,
688 void* userData, unsigned int flags);
689typedef hipError_t (*t_hipStreamAttachMemAsync)(hipStream_t stream, void* dev_ptr, size_t length,
690 unsigned int flags);
691typedef hipError_t (*t_hipStreamBeginCapture)(hipStream_t stream, hipStreamCaptureMode mode);
692typedef hipError_t (*t_hipStreamCreate)(hipStream_t* stream);
693typedef hipError_t (*t_hipStreamCreateWithFlags)(hipStream_t* stream, unsigned int flags);
694typedef hipError_t (*t_hipStreamCreateWithPriority)(hipStream_t* stream, unsigned int flags,
695 int priority);
696typedef hipError_t (*t_hipStreamDestroy)(hipStream_t stream);
697typedef hipError_t (*t_hipStreamEndCapture)(hipStream_t stream, hipGraph_t* pGraph);
698typedef hipError_t (*t_hipStreamGetCaptureInfo)(hipStream_t stream,
699 hipStreamCaptureStatus* pCaptureStatus,
700 unsigned long long* pId);
701typedef hipError_t (*t_hipStreamGetCaptureInfo_v2)(
702 hipStream_t stream, hipStreamCaptureStatus* captureStatus_out, unsigned long long* id_out,
703 hipGraph_t* graph_out, const hipGraphNode_t** dependencies_out, size_t* numDependencies_out);
704typedef hipError_t (*t_hipStreamGetDevice)(hipStream_t stream, hipDevice_t* device);
705typedef hipError_t (*t_hipStreamGetFlags)(hipStream_t stream, unsigned int* flags);
706typedef hipError_t (*t_hipStreamGetPriority)(hipStream_t stream, int* priority);
707typedef hipError_t (*t_hipStreamIsCapturing)(hipStream_t stream,
708 hipStreamCaptureStatus* pCaptureStatus);
709typedef hipError_t (*t_hipStreamQuery)(hipStream_t stream);
710typedef hipError_t (*t_hipStreamSynchronize)(hipStream_t stream);
711typedef hipError_t (*t_hipStreamUpdateCaptureDependencies)(hipStream_t stream,
712 hipGraphNode_t* dependencies,
713 size_t numDependencies,
714 unsigned int flags);
715typedef hipError_t (*t_hipStreamWaitEvent)(hipStream_t stream, hipEvent_t event,
716 unsigned int flags);
717typedef hipError_t (*t_hipStreamWaitValue32)(hipStream_t stream, void* ptr, uint32_t value,
718 unsigned int flags, uint32_t mask);
719typedef hipError_t (*t_hipStreamWaitValue64)(hipStream_t stream, void* ptr, uint64_t value,
720 unsigned int flags, uint64_t mask);
721typedef hipError_t (*t_hipStreamWriteValue32)(hipStream_t stream, void* ptr, uint32_t value,
722 unsigned int flags);
723typedef hipError_t (*t_hipStreamWriteValue64)(hipStream_t stream, void* ptr, uint64_t value,
724 unsigned int flags);
725typedef hipError_t (*t_hipTexObjectCreate)(hipTextureObject_t* pTexObject,
726 const HIP_RESOURCE_DESC* pResDesc,
727 const HIP_TEXTURE_DESC* pTexDesc,
728 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);
729typedef hipError_t (*t_hipTexObjectDestroy)(hipTextureObject_t texObject);
730typedef hipError_t (*t_hipTexObjectGetResourceDesc)(HIP_RESOURCE_DESC* pResDesc,
731 hipTextureObject_t texObject);
732typedef hipError_t (*t_hipTexObjectGetResourceViewDesc)(HIP_RESOURCE_VIEW_DESC* pResViewDesc,
733 hipTextureObject_t texObject);
734typedef hipError_t (*t_hipTexObjectGetTextureDesc)(HIP_TEXTURE_DESC* pTexDesc,
735 hipTextureObject_t texObject);
736typedef hipError_t (*t_hipTexRefGetAddress)(hipDeviceptr_t* dev_ptr,
737 const textureReference* texRef);
738typedef hipError_t (*t_hipTexRefGetAddressMode)(enum hipTextureAddressMode* pam,
739 const textureReference* texRef, int dim);
740typedef hipError_t (*t_hipTexRefGetFilterMode)(enum hipTextureFilterMode* pfm,
741 const textureReference* texRef);
742typedef hipError_t (*t_hipTexRefGetFlags)(unsigned int* pFlags, const textureReference* texRef);
743typedef hipError_t (*t_hipTexRefGetFormat)(hipArray_Format* pFormat, int* pNumChannels,
744 const textureReference* texRef);
745typedef hipError_t (*t_hipTexRefGetMaxAnisotropy)(int* pmaxAnsio, const textureReference* texRef);
746typedef hipError_t (*t_hipTexRefGetMipMappedArray)(hipMipmappedArray_t* pArray,
747 const textureReference* texRef);
748typedef hipError_t (*t_hipTexRefGetMipmapFilterMode)(enum hipTextureFilterMode* pfm,
749 const textureReference* texRef);
750typedef hipError_t (*t_hipTexRefGetMipmapLevelBias)(float* pbias, const textureReference* texRef);
751typedef hipError_t (*t_hipTexRefGetMipmapLevelClamp)(float* pminMipmapLevelClamp,
752 float* pmaxMipmapLevelClamp,
753 const textureReference* texRef);
754typedef hipError_t (*t_hipTexRefSetAddress)(size_t* ByteOffset, textureReference* texRef,
755 hipDeviceptr_t dptr, size_t bytes);
756typedef hipError_t (*t_hipTexRefSetAddress2D)(textureReference* texRef,
757 const HIP_ARRAY_DESCRIPTOR* desc, hipDeviceptr_t dptr,
758 size_t Pitch);
759typedef hipError_t (*t_hipTexRefSetAddressMode)(textureReference* texRef, int dim,
760 enum hipTextureAddressMode am);
761typedef hipError_t (*t_hipTexRefSetArray)(textureReference* tex, hipArray_const_t array,
762 unsigned int flags);
763typedef hipError_t (*t_hipTexRefSetBorderColor)(textureReference* texRef, float* pBorderColor);
764typedef hipError_t (*t_hipTexRefSetFilterMode)(textureReference* texRef,
765 enum hipTextureFilterMode fm);
766typedef hipError_t (*t_hipTexRefSetFlags)(textureReference* texRef, unsigned int Flags);
767typedef hipError_t (*t_hipTexRefSetFormat)(textureReference* texRef, hipArray_Format fmt,
768 int NumPackedComponents);
769typedef hipError_t (*t_hipTexRefSetMaxAnisotropy)(textureReference* texRef, unsigned int maxAniso);
770typedef hipError_t (*t_hipTexRefSetMipmapFilterMode)(textureReference* texRef,
771 enum hipTextureFilterMode fm);
772typedef hipError_t (*t_hipTexRefSetMipmapLevelBias)(textureReference* texRef, float bias);
773typedef hipError_t (*t_hipTexRefSetMipmapLevelClamp)(textureReference* texRef,
774 float minMipMapLevelClamp,
775 float maxMipMapLevelClamp);
776typedef hipError_t (*t_hipTexRefSetMipmappedArray)(textureReference* texRef,
777 struct hipMipmappedArray* mipmappedArray,
778 unsigned int Flags);
779typedef hipError_t (*t_hipThreadExchangeStreamCaptureMode)(hipStreamCaptureMode* mode);
780typedef hipError_t (*t_hipUnbindTexture)(const textureReference* tex);
781typedef hipError_t (*t_hipUserObjectCreate)(hipUserObject_t* object_out, void* ptr,
782 hipHostFn_t destroy, unsigned int initialRefcount,
783 unsigned int flags);
784typedef hipError_t (*t_hipUserObjectRelease)(hipUserObject_t object, unsigned int count);
785typedef hipError_t (*t_hipUserObjectRetain)(hipUserObject_t object, unsigned int count);
786typedef hipError_t (*t_hipWaitExternalSemaphoresAsync)(
787 const hipExternalSemaphore_t* extSemArray, const hipExternalSemaphoreWaitParams* paramsArray,
788 unsigned int numExtSems, hipStream_t stream);
789
790typedef hipError_t (*t_hipMemcpy_spt)(void* dst, const void* src, size_t sizeBytes,
791 hipMemcpyKind kind);
792
793typedef hipError_t (*t_hipMemcpyToSymbol_spt)(const void* symbol, const void* src, size_t sizeBytes,
794 size_t offset, hipMemcpyKind kind);
795
796typedef hipError_t (*t_hipMemcpyFromSymbol_spt)(void* dst, const void* symbol, size_t sizeBytes,
797 size_t offset, hipMemcpyKind kind);
798
799typedef hipError_t (*t_hipMemcpy2D_spt)(void* dst, size_t dpitch, const void* src, size_t spitch,
800 size_t width, size_t height, hipMemcpyKind kind);
801
802typedef hipError_t (*t_hipMemcpy2DFromArray_spt)(void* dst, size_t dpitch, hipArray_const_t src,
803 size_t wOffset, size_t hOffset, size_t width,
804 size_t height, hipMemcpyKind kind);
805
806typedef hipError_t (*t_hipMemcpy3D_spt)(const struct hipMemcpy3DParms* p);
807
808typedef hipError_t (*t_hipMemset_spt)(void* dst, int value, size_t sizeBytes);
809
810typedef hipError_t (*t_hipMemsetAsync_spt)(void* dst, int value, size_t sizeBytes,
811 hipStream_t stream);
812
813typedef hipError_t (*t_hipMemset2D_spt)(void* dst, size_t pitch, int value, size_t width,
814 size_t height);
815
816typedef hipError_t (*t_hipMemset2DAsync_spt)(void* dst, size_t pitch, int value, size_t width,
817 size_t height, hipStream_t stream);
818
819typedef hipError_t (*t_hipMemset3DAsync_spt)(hipPitchedPtr pitchedDevPtr, int value,
820 hipExtent extent, hipStream_t stream);
821
822typedef hipError_t (*t_hipMemset3D_spt)(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent);
823
824typedef hipError_t (*t_hipMemcpyAsync_spt)(void* dst, const void* src, size_t sizeBytes,
825 hipMemcpyKind kind, hipStream_t stream);
826
827typedef hipError_t (*t_hipMemcpy3DAsync_spt)(const hipMemcpy3DParms* p, hipStream_t stream);
828
829typedef hipError_t (*t_hipMemcpy2DAsync_spt)(void* dst, size_t dpitch, const void* src,
830 size_t spitch, size_t width, size_t height,
831 hipMemcpyKind kind, hipStream_t stream);
832
833typedef hipError_t (*t_hipMemcpyFromSymbolAsync_spt)(void* dst, const void* symbol,
834 size_t sizeBytes, size_t offset,
835 hipMemcpyKind kind, hipStream_t stream);
836
837typedef hipError_t (*t_hipMemcpyToSymbolAsync_spt)(const void* symbol, const void* src,
838 size_t sizeBytes, size_t offset,
839 hipMemcpyKind kind, hipStream_t stream);
840
841typedef hipError_t (*t_hipMemcpyFromArray_spt)(void* dst, hipArray_const_t src, size_t wOffsetSrc,
842 size_t hOffset, size_t count, hipMemcpyKind kind);
843
844typedef hipError_t (*t_hipMemcpy2DToArray_spt)(hipArray_t dst, size_t wOffset, size_t hOffset,
845 const void* src, size_t spitch, size_t width,
846 size_t height, hipMemcpyKind kind);
847
848typedef hipError_t (*t_hipMemcpy2DFromArrayAsync_spt)(void* dst, size_t dpitch,
849 hipArray_const_t src, size_t wOffsetSrc,
850 size_t hOffsetSrc, size_t width,
851 size_t height, hipMemcpyKind kind,
852 hipStream_t stream);
853
854typedef hipError_t (*t_hipMemcpy2DToArrayAsync_spt)(hipArray_t dst, size_t wOffset, size_t hOffset,
855 const void* src, size_t spitch, size_t width,
856 size_t height, hipMemcpyKind kind,
857 hipStream_t stream);
858
859typedef hipError_t (*t_hipStreamQuery_spt)(hipStream_t stream);
860
861typedef hipError_t (*t_hipStreamSynchronize_spt)(hipStream_t stream);
862
863typedef hipError_t (*t_hipStreamGetPriority_spt)(hipStream_t stream, int* priority);
864
865typedef hipError_t (*t_hipStreamWaitEvent_spt)(hipStream_t stream, hipEvent_t event,
866 unsigned int flags);
867
868typedef hipError_t (*t_hipStreamGetFlags_spt)(hipStream_t stream, unsigned int* flags);
869
870typedef hipError_t (*t_hipStreamAddCallback_spt)(hipStream_t stream, hipStreamCallback_t callback,
871 void* userData, unsigned int flags);
872typedef hipError_t (*t_hipEventRecord_spt)(hipEvent_t event, hipStream_t stream);
873typedef hipError_t (*t_hipLaunchCooperativeKernel_spt)(const void* f, dim3 gridDim, dim3 blockDim,
874 void** kernelParams, uint32_t sharedMemBytes,
875 hipStream_t hStream);
876
877typedef hipError_t (*t_hipLaunchKernel_spt)(const void* function_address, dim3 numBlocks,
878 dim3 dimBlocks, void** args, size_t sharedMemBytes,
879 hipStream_t stream);
880
881typedef hipError_t (*t_hipGraphLaunch_spt)(hipGraphExec_t graphExec, hipStream_t stream);
882typedef hipError_t (*t_hipStreamBeginCapture_spt)(hipStream_t stream, hipStreamCaptureMode mode);
883typedef hipError_t (*t_hipStreamEndCapture_spt)(hipStream_t stream, hipGraph_t* pGraph);
884typedef hipError_t (*t_hipStreamIsCapturing_spt)(hipStream_t stream,
885 hipStreamCaptureStatus* pCaptureStatus);
886typedef hipError_t (*t_hipStreamGetCaptureInfo_spt)(hipStream_t stream,
887 hipStreamCaptureStatus* pCaptureStatus,
888 unsigned long long* pId);
889typedef hipError_t (*t_hipStreamGetCaptureInfo_v2_spt)(
890 hipStream_t stream, hipStreamCaptureStatus* captureStatus_out, unsigned long long* id_out,
891 hipGraph_t* graph_out, const hipGraphNode_t** dependencies_out, size_t* numDependencies_out);
892typedef hipError_t (*t_hipLaunchHostFunc_spt)(hipStream_t stream, hipHostFn_t fn, void* userData);
893typedef hipChannelFormatDesc (*t_hipCreateChannelDesc)(int x, int y, int z, int w,
894 hipChannelFormatKind f);
895typedef hipError_t (*t_hipExtModuleLaunchKernel)(hipFunction_t f, uint32_t globalWorkSizeX,
896 uint32_t globalWorkSizeY, uint32_t globalWorkSizeZ,
897 uint32_t localWorkSizeX, uint32_t localWorkSizeY,
898 uint32_t localWorkSizeZ, size_t sharedMemBytes,
899 hipStream_t hStream, void** kernelParams,
900 void** extra, hipEvent_t startEvent,
901 hipEvent_t stopEvent, uint32_t flags);
902typedef hipError_t (*t_hipHccModuleLaunchKernel)(hipFunction_t f, uint32_t globalWorkSizeX,
903 uint32_t globalWorkSizeY, uint32_t globalWorkSizeZ,
904 uint32_t localWorkSizeX, uint32_t localWorkSizeY,
905 uint32_t localWorkSizeZ, size_t sharedMemBytes,
906 hipStream_t hStream, void** kernelParams,
907 void** extra, hipEvent_t startEvent,
908 hipEvent_t stopEvent);
909typedef int (*t_hipGetStreamDeviceId)(hipStream_t stream);
910typedef hipError_t (*t_hipDrvGraphAddMemsetNode)(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,
911 const hipGraphNode_t* dependencies, size_t numDependencies,
912 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);
913typedef hipError_t (*t_hipGraphAddExternalSemaphoresWaitNode)(hipGraphNode_t* pGraphNode,
914 hipGraph_t graph, const hipGraphNode_t* pDependencies,
915 size_t numDependencies,
916 const hipExternalSemaphoreWaitNodeParams* nodeParams);
917typedef hipError_t (*t_hipGraphAddExternalSemaphoresSignalNode)(hipGraphNode_t* pGraphNode,
918 hipGraph_t graph, const hipGraphNode_t* pDependencies,
919 size_t numDependencies,
920 const hipExternalSemaphoreSignalNodeParams* nodeParams);
921typedef hipError_t (*t_hipGraphExternalSemaphoresSignalNodeSetParams)(hipGraphNode_t hNode,
922 const hipExternalSemaphoreSignalNodeParams* nodeParams);
923typedef hipError_t (*t_hipGraphExternalSemaphoresWaitNodeSetParams)(hipGraphNode_t hNode,
924 const hipExternalSemaphoreWaitNodeParams* nodeParams);
925typedef hipError_t (*t_hipGraphExternalSemaphoresSignalNodeGetParams)(hipGraphNode_t hNode,
926 hipExternalSemaphoreSignalNodeParams* params_out);
927typedef hipError_t (*t_hipGraphExternalSemaphoresWaitNodeGetParams)(hipGraphNode_t hNode,
928 hipExternalSemaphoreWaitNodeParams* params_out);
929typedef hipError_t (*t_hipGraphExecExternalSemaphoresSignalNodeSetParams)(hipGraphExec_t hGraphExec,
930 hipGraphNode_t hNode,
931 const hipExternalSemaphoreSignalNodeParams* nodeParams);
932typedef hipError_t (*t_hipGraphExecExternalSemaphoresWaitNodeSetParams)(hipGraphExec_t hGraphExec,
933 hipGraphNode_t hNode,
934 const hipExternalSemaphoreWaitNodeParams* nodeParams);
935typedef hipError_t (*t_hipGraphAddNode)(hipGraphNode_t *pGraphNode, hipGraph_t graph,
936 const hipGraphNode_t *pDependencies, size_t numDependencies,
937 hipGraphNodeParams *nodeParams);
938typedef hipError_t (*t_hipGraphInstantiateWithParams)(hipGraphExec_t* pGraphExec, hipGraph_t graph,
939 hipGraphInstantiateParams* instantiateParams);
940typedef hipError_t (*t_hipExtGetLastError)();
941typedef hipError_t (*t_hipTexRefGetBorderColor)(float* pBorderColor,
942 const textureReference* texRef);
943typedef hipError_t (*t_hipTexRefGetArray)(hipArray_t* pArray, const textureReference* texRef);
944
945typedef hipError_t (*t_hipTexRefGetBorderColor)(float* pBorderColor,
946 const textureReference* texRef);
947typedef hipError_t (*t_hipTexRefGetArray)(hipArray_t* pArray, const textureReference* texRef);
948typedef hipError_t (*t_hipGetProcAddress)(const char* symbol, void** pfn, int hipVersion, uint64_t flags,
949 hipDriverProcAddressQueryResult* symbolStatus);
950typedef hipError_t (*t_hipStreamBeginCaptureToGraph)(hipStream_t stream, hipGraph_t graph,
951 const hipGraphNode_t* dependencies,
952 const hipGraphEdgeData* dependencyData,
953 size_t numDependencies,
954 hipStreamCaptureMode mode);
955typedef hipError_t (*t_hipGetFuncBySymbol)(hipFunction_t* functionPtr, const void* symbolPtr);
956typedef hipError_t (*t_hipDrvGraphAddMemFreeNode)(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,
957 const hipGraphNode_t* dependencies, size_t numDependencies,
958 hipDeviceptr_t dptr);
959
960typedef hipError_t (*t_hipDrvGraphExecMemcpyNodeSetParams)(hipGraphExec_t hGraphExec,
961 hipGraphNode_t hNode, const HIP_MEMCPY3D* copyParams,
962 hipCtx_t ctx);
963
964typedef hipError_t (*t_hipDrvGraphExecMemsetNodeSetParams)(hipGraphExec_t hGraphExec,
965 hipGraphNode_t hNode, const HIP_MEMSET_NODE_PARAMS* memsetParams,
966 hipCtx_t ctx);
967typedef hipError_t (*t_hipSetValidDevices)(int* device_arr, int len);
968typedef hipError_t (*t_hipMemcpyAtoD)(hipDeviceptr_t dstDevice, hipArray_t srcArray,
969 size_t srcOffset, size_t ByteCount);
970typedef hipError_t (*t_hipMemcpyDtoA)(hipArray_t dstArray, size_t dstOffset,
971 hipDeviceptr_t srcDevice, size_t ByteCount);
972typedef hipError_t (*t_hipMemcpyAtoA)(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray,
973 size_t srcOffset, size_t ByteCount);
974typedef hipError_t (*t_hipMemcpyAtoHAsync)(void* dstHost, hipArray_t srcArray, size_t srcOffset,
975 size_t ByteCount, hipStream_t stream);
976typedef hipError_t (*t_hipMemcpyHtoAAsync)(hipArray_t dstArray, size_t dstOffset,
977 const void* srcHost, size_t ByteCount,
978 hipStream_t stream);
979typedef hipError_t (*t_hipMemcpy2DArrayToArray)(hipArray_t dst, size_t wOffsetDst,
980 size_t hOffsetDst, hipArray_const_t src,
981 size_t wOffsetSrc, size_t hOffsetSrc, size_t width,
982 size_t height, hipMemcpyKind kind);
983
984
985typedef hipError_t (*t_hipGraphExecGetFlags)(hipGraphExec_t graphExec, unsigned long long* flags);
986typedef hipError_t (*t_hipGraphNodeSetParams)(hipGraphNode_t node, hipGraphNodeParams *nodeParams);
987typedef hipError_t (*t_hipGraphExecNodeSetParams)(hipGraphExec_t graphExec, hipGraphNode_t node,
988 hipGraphNodeParams* nodeParams);
989
990
991
992typedef hipError_t (*t_hipExternalMemoryGetMappedMipmappedArray)(
993 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,
994 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);
995typedef hipError_t (*t_hipDrvGraphMemcpyNodeGetParams)(hipGraphNode_t hNode,
996 HIP_MEMCPY3D* nodeParams);
997
998typedef hipError_t (*t_hipDrvGraphMemcpyNodeSetParams)(hipGraphNode_t hNode,
999 const HIP_MEMCPY3D* nodeParams);
1000
1001// HIP Compiler dispatch table
1003 size_t size;
1004 t___hipPopCallConfiguration __hipPopCallConfiguration_fn;
1005 t___hipPushCallConfiguration __hipPushCallConfiguration_fn;
1006 t___hipRegisterFatBinary __hipRegisterFatBinary_fn;
1007 t___hipRegisterFunction __hipRegisterFunction_fn;
1008 t___hipRegisterManagedVar __hipRegisterManagedVar_fn;
1009 t___hipRegisterSurface __hipRegisterSurface_fn;
1010 t___hipRegisterTexture __hipRegisterTexture_fn;
1011 t___hipRegisterVar __hipRegisterVar_fn;
1012 t___hipUnregisterFatBinary __hipUnregisterFatBinary_fn;
1013};
1014
1015// HIP API dispatch table
1017 size_t size;
1018 t_hipApiName hipApiName_fn;
1019 t_hipArray3DCreate hipArray3DCreate_fn;
1020 t_hipArray3DGetDescriptor hipArray3DGetDescriptor_fn;
1021 t_hipArrayCreate hipArrayCreate_fn;
1022 t_hipArrayDestroy hipArrayDestroy_fn;
1023 t_hipArrayGetDescriptor hipArrayGetDescriptor_fn;
1024 t_hipArrayGetInfo hipArrayGetInfo_fn;
1025 t_hipBindTexture hipBindTexture_fn;
1026 t_hipBindTexture2D hipBindTexture2D_fn;
1027 t_hipBindTextureToArray hipBindTextureToArray_fn;
1028 t_hipBindTextureToMipmappedArray hipBindTextureToMipmappedArray_fn;
1029 t_hipChooseDevice hipChooseDevice_fn;
1030 t_hipChooseDeviceR0000 hipChooseDeviceR0000_fn;
1031 t_hipConfigureCall hipConfigureCall_fn;
1032 t_hipCreateSurfaceObject hipCreateSurfaceObject_fn;
1033 t_hipCreateTextureObject hipCreateTextureObject_fn;
1034 t_hipCtxCreate hipCtxCreate_fn;
1035 t_hipCtxDestroy hipCtxDestroy_fn;
1036 t_hipCtxDisablePeerAccess hipCtxDisablePeerAccess_fn;
1037 t_hipCtxEnablePeerAccess hipCtxEnablePeerAccess_fn;
1038 t_hipCtxGetApiVersion hipCtxGetApiVersion_fn;
1039 t_hipCtxGetCacheConfig hipCtxGetCacheConfig_fn;
1040 t_hipCtxGetCurrent hipCtxGetCurrent_fn;
1041 t_hipCtxGetDevice hipCtxGetDevice_fn;
1042 t_hipCtxGetFlags hipCtxGetFlags_fn;
1043 t_hipCtxGetSharedMemConfig hipCtxGetSharedMemConfig_fn;
1044 t_hipCtxPopCurrent hipCtxPopCurrent_fn;
1045 t_hipCtxPushCurrent hipCtxPushCurrent_fn;
1046 t_hipCtxSetCacheConfig hipCtxSetCacheConfig_fn;
1047 t_hipCtxSetCurrent hipCtxSetCurrent_fn;
1048 t_hipCtxSetSharedMemConfig hipCtxSetSharedMemConfig_fn;
1049 t_hipCtxSynchronize hipCtxSynchronize_fn;
1050 t_hipDestroyExternalMemory hipDestroyExternalMemory_fn;
1051 t_hipDestroyExternalSemaphore hipDestroyExternalSemaphore_fn;
1052 t_hipDestroySurfaceObject hipDestroySurfaceObject_fn;
1053 t_hipDestroyTextureObject hipDestroyTextureObject_fn;
1054 t_hipDeviceCanAccessPeer hipDeviceCanAccessPeer_fn;
1055 t_hipDeviceComputeCapability hipDeviceComputeCapability_fn;
1056 t_hipDeviceDisablePeerAccess hipDeviceDisablePeerAccess_fn;
1057 t_hipDeviceEnablePeerAccess hipDeviceEnablePeerAccess_fn;
1058 t_hipDeviceGet hipDeviceGet_fn;
1059 t_hipDeviceGetAttribute hipDeviceGetAttribute_fn;
1060 t_hipDeviceGetByPCIBusId hipDeviceGetByPCIBusId_fn;
1061 t_hipDeviceGetCacheConfig hipDeviceGetCacheConfig_fn;
1062 t_hipDeviceGetDefaultMemPool hipDeviceGetDefaultMemPool_fn;
1063 t_hipDeviceGetGraphMemAttribute hipDeviceGetGraphMemAttribute_fn;
1064 t_hipDeviceGetLimit hipDeviceGetLimit_fn;
1065 t_hipDeviceGetMemPool hipDeviceGetMemPool_fn;
1066 t_hipDeviceGetName hipDeviceGetName_fn;
1067 t_hipDeviceGetP2PAttribute hipDeviceGetP2PAttribute_fn;
1068 t_hipDeviceGetPCIBusId hipDeviceGetPCIBusId_fn;
1069 t_hipDeviceGetSharedMemConfig hipDeviceGetSharedMemConfig_fn;
1070 t_hipDeviceGetStreamPriorityRange hipDeviceGetStreamPriorityRange_fn;
1071 t_hipDeviceGetUuid hipDeviceGetUuid_fn;
1072 t_hipDeviceGraphMemTrim hipDeviceGraphMemTrim_fn;
1073 t_hipDevicePrimaryCtxGetState hipDevicePrimaryCtxGetState_fn;
1074 t_hipDevicePrimaryCtxRelease hipDevicePrimaryCtxRelease_fn;
1075 t_hipDevicePrimaryCtxReset hipDevicePrimaryCtxReset_fn;
1076 t_hipDevicePrimaryCtxRetain hipDevicePrimaryCtxRetain_fn;
1077 t_hipDevicePrimaryCtxSetFlags hipDevicePrimaryCtxSetFlags_fn;
1078 t_hipDeviceReset hipDeviceReset_fn;
1079 t_hipDeviceSetCacheConfig hipDeviceSetCacheConfig_fn;
1080 t_hipDeviceSetGraphMemAttribute hipDeviceSetGraphMemAttribute_fn;
1081 t_hipDeviceSetLimit hipDeviceSetLimit_fn;
1082 t_hipDeviceSetMemPool hipDeviceSetMemPool_fn;
1083 t_hipDeviceSetSharedMemConfig hipDeviceSetSharedMemConfig_fn;
1084 t_hipDeviceSynchronize hipDeviceSynchronize_fn;
1085 t_hipDeviceTotalMem hipDeviceTotalMem_fn;
1086 t_hipDriverGetVersion hipDriverGetVersion_fn;
1087 t_hipDrvGetErrorName hipDrvGetErrorName_fn;
1088 t_hipDrvGetErrorString hipDrvGetErrorString_fn;
1089 t_hipDrvGraphAddMemcpyNode hipDrvGraphAddMemcpyNode_fn;
1090 t_hipDrvMemcpy2DUnaligned hipDrvMemcpy2DUnaligned_fn;
1091 t_hipDrvMemcpy3D hipDrvMemcpy3D_fn;
1092 t_hipDrvMemcpy3DAsync hipDrvMemcpy3DAsync_fn;
1093 t_hipDrvPointerGetAttributes hipDrvPointerGetAttributes_fn;
1094 t_hipEventCreate hipEventCreate_fn;
1095 t_hipEventCreateWithFlags hipEventCreateWithFlags_fn;
1096 t_hipEventDestroy hipEventDestroy_fn;
1097 t_hipEventElapsedTime hipEventElapsedTime_fn;
1098 t_hipEventQuery hipEventQuery_fn;
1099 t_hipEventRecord hipEventRecord_fn;
1100 t_hipEventSynchronize hipEventSynchronize_fn;
1101 t_hipExtGetLinkTypeAndHopCount hipExtGetLinkTypeAndHopCount_fn;
1102 t_hipExtLaunchKernel hipExtLaunchKernel_fn;
1103 t_hipExtLaunchMultiKernelMultiDevice hipExtLaunchMultiKernelMultiDevice_fn;
1104 t_hipExtMallocWithFlags hipExtMallocWithFlags_fn;
1105 t_hipExtStreamCreateWithCUMask hipExtStreamCreateWithCUMask_fn;
1106 t_hipExtStreamGetCUMask hipExtStreamGetCUMask_fn;
1107 t_hipExternalMemoryGetMappedBuffer hipExternalMemoryGetMappedBuffer_fn;
1108 t_hipFree hipFree_fn;
1109 t_hipFreeArray hipFreeArray_fn;
1110 t_hipFreeAsync hipFreeAsync_fn;
1111 t_hipFreeHost hipFreeHost_fn;
1112 t_hipFreeMipmappedArray hipFreeMipmappedArray_fn;
1113 t_hipFuncGetAttribute hipFuncGetAttribute_fn;
1114 t_hipFuncGetAttributes hipFuncGetAttributes_fn;
1115 t_hipFuncSetAttribute hipFuncSetAttribute_fn;
1116 t_hipFuncSetCacheConfig hipFuncSetCacheConfig_fn;
1117 t_hipFuncSetSharedMemConfig hipFuncSetSharedMemConfig_fn;
1118 t_hipGLGetDevices hipGLGetDevices_fn;
1119 t_hipGetChannelDesc hipGetChannelDesc_fn;
1120 t_hipGetDevice hipGetDevice_fn;
1121 t_hipGetDeviceCount hipGetDeviceCount_fn;
1122 t_hipGetDeviceFlags hipGetDeviceFlags_fn;
1123 t_hipGetDevicePropertiesR0600 hipGetDevicePropertiesR0600_fn;
1124 t_hipGetDevicePropertiesR0000 hipGetDevicePropertiesR0000_fn;
1125 t_hipGetErrorName hipGetErrorName_fn;
1126 t_hipGetErrorString hipGetErrorString_fn;
1127 t_hipGetLastError hipGetLastError_fn;
1128 t_hipGetMipmappedArrayLevel hipGetMipmappedArrayLevel_fn;
1129 t_hipGetSymbolAddress hipGetSymbolAddress_fn;
1130 t_hipGetSymbolSize hipGetSymbolSize_fn;
1131 t_hipGetTextureAlignmentOffset hipGetTextureAlignmentOffset_fn;
1132 t_hipGetTextureObjectResourceDesc hipGetTextureObjectResourceDesc_fn;
1133 t_hipGetTextureObjectResourceViewDesc hipGetTextureObjectResourceViewDesc_fn;
1134 t_hipGetTextureObjectTextureDesc hipGetTextureObjectTextureDesc_fn;
1135 t_hipGetTextureReference hipGetTextureReference_fn;
1136 t_hipGraphAddChildGraphNode hipGraphAddChildGraphNode_fn;
1137 t_hipGraphAddDependencies hipGraphAddDependencies_fn;
1138 t_hipGraphAddEmptyNode hipGraphAddEmptyNode_fn;
1139 t_hipGraphAddEventRecordNode hipGraphAddEventRecordNode_fn;
1140 t_hipGraphAddEventWaitNode hipGraphAddEventWaitNode_fn;
1141 t_hipGraphAddHostNode hipGraphAddHostNode_fn;
1142 t_hipGraphAddKernelNode hipGraphAddKernelNode_fn;
1143 t_hipGraphAddMemAllocNode hipGraphAddMemAllocNode_fn;
1144 t_hipGraphAddMemFreeNode hipGraphAddMemFreeNode_fn;
1145 t_hipGraphAddMemcpyNode hipGraphAddMemcpyNode_fn;
1146 t_hipGraphAddMemcpyNode1D hipGraphAddMemcpyNode1D_fn;
1147 t_hipGraphAddMemcpyNodeFromSymbol hipGraphAddMemcpyNodeFromSymbol_fn;
1148 t_hipGraphAddMemcpyNodeToSymbol hipGraphAddMemcpyNodeToSymbol_fn;
1149 t_hipGraphAddMemsetNode hipGraphAddMemsetNode_fn;
1150 t_hipGraphChildGraphNodeGetGraph hipGraphChildGraphNodeGetGraph_fn;
1151 t_hipGraphClone hipGraphClone_fn;
1152 t_hipGraphCreate hipGraphCreate_fn;
1153 t_hipGraphDebugDotPrint hipGraphDebugDotPrint_fn;
1154 t_hipGraphDestroy hipGraphDestroy_fn;
1155 t_hipGraphDestroyNode hipGraphDestroyNode_fn;
1156 t_hipGraphEventRecordNodeGetEvent hipGraphEventRecordNodeGetEvent_fn;
1157 t_hipGraphEventRecordNodeSetEvent hipGraphEventRecordNodeSetEvent_fn;
1158 t_hipGraphEventWaitNodeGetEvent hipGraphEventWaitNodeGetEvent_fn;
1159 t_hipGraphEventWaitNodeSetEvent hipGraphEventWaitNodeSetEvent_fn;
1160 t_hipGraphExecChildGraphNodeSetParams hipGraphExecChildGraphNodeSetParams_fn;
1161 t_hipGraphExecDestroy hipGraphExecDestroy_fn;
1162 t_hipGraphExecEventRecordNodeSetEvent hipGraphExecEventRecordNodeSetEvent_fn;
1163 t_hipGraphExecEventWaitNodeSetEvent hipGraphExecEventWaitNodeSetEvent_fn;
1164 t_hipGraphExecHostNodeSetParams hipGraphExecHostNodeSetParams_fn;
1165 t_hipGraphExecKernelNodeSetParams hipGraphExecKernelNodeSetParams_fn;
1166 t_hipGraphExecMemcpyNodeSetParams hipGraphExecMemcpyNodeSetParams_fn;
1167 t_hipGraphExecMemcpyNodeSetParams1D hipGraphExecMemcpyNodeSetParams1D_fn;
1168 t_hipGraphExecMemcpyNodeSetParamsFromSymbol hipGraphExecMemcpyNodeSetParamsFromSymbol_fn;
1169 t_hipGraphExecMemcpyNodeSetParamsToSymbol hipGraphExecMemcpyNodeSetParamsToSymbol_fn;
1170 t_hipGraphExecMemsetNodeSetParams hipGraphExecMemsetNodeSetParams_fn;
1171 t_hipGraphExecUpdate hipGraphExecUpdate_fn;
1172 t_hipGraphGetEdges hipGraphGetEdges_fn;
1173 t_hipGraphGetNodes hipGraphGetNodes_fn;
1174 t_hipGraphGetRootNodes hipGraphGetRootNodes_fn;
1175 t_hipGraphHostNodeGetParams hipGraphHostNodeGetParams_fn;
1176 t_hipGraphHostNodeSetParams hipGraphHostNodeSetParams_fn;
1177 t_hipGraphInstantiate hipGraphInstantiate_fn;
1178 t_hipGraphInstantiateWithFlags hipGraphInstantiateWithFlags_fn;
1179 t_hipGraphKernelNodeCopyAttributes hipGraphKernelNodeCopyAttributes_fn;
1180 t_hipGraphKernelNodeGetAttribute hipGraphKernelNodeGetAttribute_fn;
1181 t_hipGraphKernelNodeGetParams hipGraphKernelNodeGetParams_fn;
1182 t_hipGraphKernelNodeSetAttribute hipGraphKernelNodeSetAttribute_fn;
1183 t_hipGraphKernelNodeSetParams hipGraphKernelNodeSetParams_fn;
1184 t_hipGraphLaunch hipGraphLaunch_fn;
1185 t_hipGraphMemAllocNodeGetParams hipGraphMemAllocNodeGetParams_fn;
1186 t_hipGraphMemFreeNodeGetParams hipGraphMemFreeNodeGetParams_fn;
1187 t_hipGraphMemcpyNodeGetParams hipGraphMemcpyNodeGetParams_fn;
1188 t_hipGraphMemcpyNodeSetParams hipGraphMemcpyNodeSetParams_fn;
1189 t_hipGraphMemcpyNodeSetParams1D hipGraphMemcpyNodeSetParams1D_fn;
1190 t_hipGraphMemcpyNodeSetParamsFromSymbol hipGraphMemcpyNodeSetParamsFromSymbol_fn;
1191 t_hipGraphMemcpyNodeSetParamsToSymbol hipGraphMemcpyNodeSetParamsToSymbol_fn;
1192 t_hipGraphMemsetNodeGetParams hipGraphMemsetNodeGetParams_fn;
1193 t_hipGraphMemsetNodeSetParams hipGraphMemsetNodeSetParams_fn;
1194 t_hipGraphNodeFindInClone hipGraphNodeFindInClone_fn;
1195 t_hipGraphNodeGetDependencies hipGraphNodeGetDependencies_fn;
1196 t_hipGraphNodeGetDependentNodes hipGraphNodeGetDependentNodes_fn;
1197 t_hipGraphNodeGetEnabled hipGraphNodeGetEnabled_fn;
1198 t_hipGraphNodeGetType hipGraphNodeGetType_fn;
1199 t_hipGraphNodeSetEnabled hipGraphNodeSetEnabled_fn;
1200 t_hipGraphReleaseUserObject hipGraphReleaseUserObject_fn;
1201 t_hipGraphRemoveDependencies hipGraphRemoveDependencies_fn;
1202 t_hipGraphRetainUserObject hipGraphRetainUserObject_fn;
1203 t_hipGraphUpload hipGraphUpload_fn;
1204 t_hipGraphicsGLRegisterBuffer hipGraphicsGLRegisterBuffer_fn;
1205 t_hipGraphicsGLRegisterImage hipGraphicsGLRegisterImage_fn;
1206 t_hipGraphicsMapResources hipGraphicsMapResources_fn;
1207 t_hipGraphicsResourceGetMappedPointer hipGraphicsResourceGetMappedPointer_fn;
1208 t_hipGraphicsSubResourceGetMappedArray hipGraphicsSubResourceGetMappedArray_fn;
1209 t_hipGraphicsUnmapResources hipGraphicsUnmapResources_fn;
1210 t_hipGraphicsUnregisterResource hipGraphicsUnregisterResource_fn;
1211 t_hipHostAlloc hipHostAlloc_fn;
1212 t_hipHostFree hipHostFree_fn;
1213 t_hipHostGetDevicePointer hipHostGetDevicePointer_fn;
1214 t_hipHostGetFlags hipHostGetFlags_fn;
1215 t_hipHostMalloc hipHostMalloc_fn;
1216 t_hipHostRegister hipHostRegister_fn;
1217 t_hipHostUnregister hipHostUnregister_fn;
1218 t_hipImportExternalMemory hipImportExternalMemory_fn;
1219 t_hipImportExternalSemaphore hipImportExternalSemaphore_fn;
1220 t_hipInit hipInit_fn;
1221 t_hipIpcCloseMemHandle hipIpcCloseMemHandle_fn;
1222 t_hipIpcGetEventHandle hipIpcGetEventHandle_fn;
1223 t_hipIpcGetMemHandle hipIpcGetMemHandle_fn;
1224 t_hipIpcOpenEventHandle hipIpcOpenEventHandle_fn;
1225 t_hipIpcOpenMemHandle hipIpcOpenMemHandle_fn;
1226 t_hipKernelNameRef hipKernelNameRef_fn;
1227 t_hipKernelNameRefByPtr hipKernelNameRefByPtr_fn;
1228 t_hipLaunchByPtr hipLaunchByPtr_fn;
1229 t_hipLaunchCooperativeKernel hipLaunchCooperativeKernel_fn;
1230 t_hipLaunchCooperativeKernelMultiDevice hipLaunchCooperativeKernelMultiDevice_fn;
1231 t_hipLaunchHostFunc hipLaunchHostFunc_fn;
1232 t_hipLaunchKernel hipLaunchKernel_fn;
1233 t_hipMalloc hipMalloc_fn;
1234 t_hipMalloc3D hipMalloc3D_fn;
1235 t_hipMalloc3DArray hipMalloc3DArray_fn;
1236 t_hipMallocArray hipMallocArray_fn;
1237 t_hipMallocAsync hipMallocAsync_fn;
1238 t_hipMallocFromPoolAsync hipMallocFromPoolAsync_fn;
1239 t_hipMallocHost hipMallocHost_fn;
1240 t_hipMallocManaged hipMallocManaged_fn;
1241 t_hipMallocMipmappedArray hipMallocMipmappedArray_fn;
1242 t_hipMallocPitch hipMallocPitch_fn;
1243 t_hipMemAddressFree hipMemAddressFree_fn;
1244 t_hipMemAddressReserve hipMemAddressReserve_fn;
1245 t_hipMemAdvise hipMemAdvise_fn;
1246 t_hipMemAllocHost hipMemAllocHost_fn;
1247 t_hipMemAllocPitch hipMemAllocPitch_fn;
1248 t_hipMemCreate hipMemCreate_fn;
1249 t_hipMemExportToShareableHandle hipMemExportToShareableHandle_fn;
1250 t_hipMemGetAccess hipMemGetAccess_fn;
1251 t_hipMemGetAddressRange hipMemGetAddressRange_fn;
1252 t_hipMemGetAllocationGranularity hipMemGetAllocationGranularity_fn;
1253 t_hipMemGetAllocationPropertiesFromHandle hipMemGetAllocationPropertiesFromHandle_fn;
1254 t_hipMemGetInfo hipMemGetInfo_fn;
1255 t_hipMemImportFromShareableHandle hipMemImportFromShareableHandle_fn;
1256 t_hipMemMap hipMemMap_fn;
1257 t_hipMemMapArrayAsync hipMemMapArrayAsync_fn;
1258 t_hipMemPoolCreate hipMemPoolCreate_fn;
1259 t_hipMemPoolDestroy hipMemPoolDestroy_fn;
1260 t_hipMemPoolExportPointer hipMemPoolExportPointer_fn;
1261 t_hipMemPoolExportToShareableHandle hipMemPoolExportToShareableHandle_fn;
1262 t_hipMemPoolGetAccess hipMemPoolGetAccess_fn;
1263 t_hipMemPoolGetAttribute hipMemPoolGetAttribute_fn;
1264 t_hipMemPoolImportFromShareableHandle hipMemPoolImportFromShareableHandle_fn;
1265 t_hipMemPoolImportPointer hipMemPoolImportPointer_fn;
1266 t_hipMemPoolSetAccess hipMemPoolSetAccess_fn;
1267 t_hipMemPoolSetAttribute hipMemPoolSetAttribute_fn;
1268 t_hipMemPoolTrimTo hipMemPoolTrimTo_fn;
1269 t_hipMemPrefetchAsync hipMemPrefetchAsync_fn;
1270 t_hipMemPtrGetInfo hipMemPtrGetInfo_fn;
1271 t_hipMemRangeGetAttribute hipMemRangeGetAttribute_fn;
1272 t_hipMemRangeGetAttributes hipMemRangeGetAttributes_fn;
1273 t_hipMemRelease hipMemRelease_fn;
1274 t_hipMemRetainAllocationHandle hipMemRetainAllocationHandle_fn;
1275 t_hipMemSetAccess hipMemSetAccess_fn;
1276 t_hipMemUnmap hipMemUnmap_fn;
1277 t_hipMemcpy hipMemcpy_fn;
1278 t_hipMemcpy2D hipMemcpy2D_fn;
1279 t_hipMemcpy2DAsync hipMemcpy2DAsync_fn;
1280 t_hipMemcpy2DFromArray hipMemcpy2DFromArray_fn;
1281 t_hipMemcpy2DFromArrayAsync hipMemcpy2DFromArrayAsync_fn;
1282 t_hipMemcpy2DToArray hipMemcpy2DToArray_fn;
1283 t_hipMemcpy2DToArrayAsync hipMemcpy2DToArrayAsync_fn;
1284 t_hipMemcpy3D hipMemcpy3D_fn;
1285 t_hipMemcpy3DAsync hipMemcpy3DAsync_fn;
1286 t_hipMemcpyAsync hipMemcpyAsync_fn;
1287 t_hipMemcpyAtoH hipMemcpyAtoH_fn;
1288 t_hipMemcpyDtoD hipMemcpyDtoD_fn;
1289 t_hipMemcpyDtoDAsync hipMemcpyDtoDAsync_fn;
1290 t_hipMemcpyDtoH hipMemcpyDtoH_fn;
1291 t_hipMemcpyDtoHAsync hipMemcpyDtoHAsync_fn;
1292 t_hipMemcpyFromArray hipMemcpyFromArray_fn;
1293 t_hipMemcpyFromSymbol hipMemcpyFromSymbol_fn;
1294 t_hipMemcpyFromSymbolAsync hipMemcpyFromSymbolAsync_fn;
1295 t_hipMemcpyHtoA hipMemcpyHtoA_fn;
1296 t_hipMemcpyHtoD hipMemcpyHtoD_fn;
1297 t_hipMemcpyHtoDAsync hipMemcpyHtoDAsync_fn;
1298 t_hipMemcpyParam2D hipMemcpyParam2D_fn;
1299 t_hipMemcpyParam2DAsync hipMemcpyParam2DAsync_fn;
1300 t_hipMemcpyPeer hipMemcpyPeer_fn;
1301 t_hipMemcpyPeerAsync hipMemcpyPeerAsync_fn;
1302 t_hipMemcpyToArray hipMemcpyToArray_fn;
1303 t_hipMemcpyToSymbol hipMemcpyToSymbol_fn;
1304 t_hipMemcpyToSymbolAsync hipMemcpyToSymbolAsync_fn;
1305 t_hipMemcpyWithStream hipMemcpyWithStream_fn;
1306 t_hipMemset hipMemset_fn;
1307 t_hipMemset2D hipMemset2D_fn;
1308 t_hipMemset2DAsync hipMemset2DAsync_fn;
1309 t_hipMemset3D hipMemset3D_fn;
1310 t_hipMemset3DAsync hipMemset3DAsync_fn;
1311 t_hipMemsetAsync hipMemsetAsync_fn;
1312 t_hipMemsetD16 hipMemsetD16_fn;
1313 t_hipMemsetD16Async hipMemsetD16Async_fn;
1314 t_hipMemsetD32 hipMemsetD32_fn;
1315 t_hipMemsetD32Async hipMemsetD32Async_fn;
1316 t_hipMemsetD8 hipMemsetD8_fn;
1317 t_hipMemsetD8Async hipMemsetD8Async_fn;
1318 t_hipMipmappedArrayCreate hipMipmappedArrayCreate_fn;
1319 t_hipMipmappedArrayDestroy hipMipmappedArrayDestroy_fn;
1320 t_hipMipmappedArrayGetLevel hipMipmappedArrayGetLevel_fn;
1321 t_hipModuleGetFunction hipModuleGetFunction_fn;
1322 t_hipModuleGetGlobal hipModuleGetGlobal_fn;
1323 t_hipModuleGetTexRef hipModuleGetTexRef_fn;
1324 t_hipModuleLaunchCooperativeKernel hipModuleLaunchCooperativeKernel_fn;
1325 t_hipModuleLaunchCooperativeKernelMultiDevice hipModuleLaunchCooperativeKernelMultiDevice_fn;
1326 t_hipModuleLaunchKernel hipModuleLaunchKernel_fn;
1327 t_hipModuleLoad hipModuleLoad_fn;
1328 t_hipModuleLoadData hipModuleLoadData_fn;
1329 t_hipModuleLoadDataEx hipModuleLoadDataEx_fn;
1330 t_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor
1331 hipModuleOccupancyMaxActiveBlocksPerMultiprocessor_fn;
1332 t_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
1333 hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_fn;
1334 t_hipModuleOccupancyMaxPotentialBlockSize hipModuleOccupancyMaxPotentialBlockSize_fn;
1335 t_hipModuleOccupancyMaxPotentialBlockSizeWithFlags
1336 hipModuleOccupancyMaxPotentialBlockSizeWithFlags_fn;
1337 t_hipModuleUnload hipModuleUnload_fn;
1338 t_hipOccupancyMaxActiveBlocksPerMultiprocessor hipOccupancyMaxActiveBlocksPerMultiprocessor_fn;
1339 t_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
1340 hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_fn;
1341 t_hipOccupancyMaxPotentialBlockSize hipOccupancyMaxPotentialBlockSize_fn;
1342 t_hipPeekAtLastError hipPeekAtLastError_fn;
1343 t_hipPointerGetAttribute hipPointerGetAttribute_fn;
1344 t_hipPointerGetAttributes hipPointerGetAttributes_fn;
1345 t_hipPointerSetAttribute hipPointerSetAttribute_fn;
1346 t_hipProfilerStart hipProfilerStart_fn;
1347 t_hipProfilerStop hipProfilerStop_fn;
1348 t_hipRuntimeGetVersion hipRuntimeGetVersion_fn;
1349 t_hipSetDevice hipSetDevice_fn;
1350 t_hipSetDeviceFlags hipSetDeviceFlags_fn;
1351 t_hipSetupArgument hipSetupArgument_fn;
1352 t_hipSignalExternalSemaphoresAsync hipSignalExternalSemaphoresAsync_fn;
1353 t_hipStreamAddCallback hipStreamAddCallback_fn;
1354 t_hipStreamAttachMemAsync hipStreamAttachMemAsync_fn;
1355 t_hipStreamBeginCapture hipStreamBeginCapture_fn;
1356 t_hipStreamCreate hipStreamCreate_fn;
1357 t_hipStreamCreateWithFlags hipStreamCreateWithFlags_fn;
1358 t_hipStreamCreateWithPriority hipStreamCreateWithPriority_fn;
1359 t_hipStreamDestroy hipStreamDestroy_fn;
1360 t_hipStreamEndCapture hipStreamEndCapture_fn;
1361 t_hipStreamGetCaptureInfo hipStreamGetCaptureInfo_fn;
1362 t_hipStreamGetCaptureInfo_v2 hipStreamGetCaptureInfo_v2_fn;
1363 t_hipStreamGetDevice hipStreamGetDevice_fn;
1364 t_hipStreamGetFlags hipStreamGetFlags_fn;
1365 t_hipStreamGetPriority hipStreamGetPriority_fn;
1366 t_hipStreamIsCapturing hipStreamIsCapturing_fn;
1367 t_hipStreamQuery hipStreamQuery_fn;
1368 t_hipStreamSynchronize hipStreamSynchronize_fn;
1369 t_hipStreamUpdateCaptureDependencies hipStreamUpdateCaptureDependencies_fn;
1370 t_hipStreamWaitEvent hipStreamWaitEvent_fn;
1371 t_hipStreamWaitValue32 hipStreamWaitValue32_fn;
1372 t_hipStreamWaitValue64 hipStreamWaitValue64_fn;
1373 t_hipStreamWriteValue32 hipStreamWriteValue32_fn;
1374 t_hipStreamWriteValue64 hipStreamWriteValue64_fn;
1375 t_hipTexObjectCreate hipTexObjectCreate_fn;
1376 t_hipTexObjectDestroy hipTexObjectDestroy_fn;
1377 t_hipTexObjectGetResourceDesc hipTexObjectGetResourceDesc_fn;
1378 t_hipTexObjectGetResourceViewDesc hipTexObjectGetResourceViewDesc_fn;
1379 t_hipTexObjectGetTextureDesc hipTexObjectGetTextureDesc_fn;
1380 t_hipTexRefGetAddress hipTexRefGetAddress_fn;
1381 t_hipTexRefGetAddressMode hipTexRefGetAddressMode_fn;
1382 t_hipTexRefGetFilterMode hipTexRefGetFilterMode_fn;
1383 t_hipTexRefGetFlags hipTexRefGetFlags_fn;
1384 t_hipTexRefGetFormat hipTexRefGetFormat_fn;
1385 t_hipTexRefGetMaxAnisotropy hipTexRefGetMaxAnisotropy_fn;
1386 t_hipTexRefGetMipMappedArray hipTexRefGetMipMappedArray_fn;
1387 t_hipTexRefGetMipmapFilterMode hipTexRefGetMipmapFilterMode_fn;
1388 t_hipTexRefGetMipmapLevelBias hipTexRefGetMipmapLevelBias_fn;
1389 t_hipTexRefGetMipmapLevelClamp hipTexRefGetMipmapLevelClamp_fn;
1390 t_hipTexRefSetAddress hipTexRefSetAddress_fn;
1391 t_hipTexRefSetAddress2D hipTexRefSetAddress2D_fn;
1392 t_hipTexRefSetAddressMode hipTexRefSetAddressMode_fn;
1393 t_hipTexRefSetArray hipTexRefSetArray_fn;
1394 t_hipTexRefSetBorderColor hipTexRefSetBorderColor_fn;
1395 t_hipTexRefSetFilterMode hipTexRefSetFilterMode_fn;
1396 t_hipTexRefSetFlags hipTexRefSetFlags_fn;
1397 t_hipTexRefSetFormat hipTexRefSetFormat_fn;
1398 t_hipTexRefSetMaxAnisotropy hipTexRefSetMaxAnisotropy_fn;
1399 t_hipTexRefSetMipmapFilterMode hipTexRefSetMipmapFilterMode_fn;
1400 t_hipTexRefSetMipmapLevelBias hipTexRefSetMipmapLevelBias_fn;
1401 t_hipTexRefSetMipmapLevelClamp hipTexRefSetMipmapLevelClamp_fn;
1402 t_hipTexRefSetMipmappedArray hipTexRefSetMipmappedArray_fn;
1403 t_hipThreadExchangeStreamCaptureMode hipThreadExchangeStreamCaptureMode_fn;
1404 t_hipUnbindTexture hipUnbindTexture_fn;
1405 t_hipUserObjectCreate hipUserObjectCreate_fn;
1406 t_hipUserObjectRelease hipUserObjectRelease_fn;
1407 t_hipUserObjectRetain hipUserObjectRetain_fn;
1408 t_hipWaitExternalSemaphoresAsync hipWaitExternalSemaphoresAsync_fn;
1409 t_hipCreateChannelDesc hipCreateChannelDesc_fn;
1410 t_hipExtModuleLaunchKernel hipExtModuleLaunchKernel_fn;
1411 t_hipHccModuleLaunchKernel hipHccModuleLaunchKernel_fn;
1412 t_hipMemcpy_spt hipMemcpy_spt_fn;
1413 t_hipMemcpyToSymbol_spt hipMemcpyToSymbol_spt_fn;
1414 t_hipMemcpyFromSymbol_spt hipMemcpyFromSymbol_spt_fn;
1415 t_hipMemcpy2D_spt hipMemcpy2D_spt_fn;
1416 t_hipMemcpy2DFromArray_spt hipMemcpy2DFromArray_spt_fn;
1417 t_hipMemcpy3D_spt hipMemcpy3D_spt_fn;
1418 t_hipMemset_spt hipMemset_spt_fn;
1419 t_hipMemsetAsync_spt hipMemsetAsync_spt_fn;
1420 t_hipMemset2D_spt hipMemset2D_spt_fn;
1421 t_hipMemset2DAsync_spt hipMemset2DAsync_spt_fn;
1422 t_hipMemset3DAsync_spt hipMemset3DAsync_spt_fn;
1423 t_hipMemset3D_spt hipMemset3D_spt_fn;
1424 t_hipMemcpyAsync_spt hipMemcpyAsync_spt_fn;
1425 t_hipMemcpy3DAsync_spt hipMemcpy3DAsync_spt_fn;
1426 t_hipMemcpy2DAsync_spt hipMemcpy2DAsync_spt_fn;
1427 t_hipMemcpyFromSymbolAsync_spt hipMemcpyFromSymbolAsync_spt_fn;
1428 t_hipMemcpyToSymbolAsync_spt hipMemcpyToSymbolAsync_spt_fn;
1429 t_hipMemcpyFromArray_spt hipMemcpyFromArray_spt_fn;
1430 t_hipMemcpy2DToArray_spt hipMemcpy2DToArray_spt_fn;
1431 t_hipMemcpy2DFromArrayAsync_spt hipMemcpy2DFromArrayAsync_spt_fn;
1432 t_hipMemcpy2DToArrayAsync_spt hipMemcpy2DToArrayAsync_spt_fn;
1433 t_hipStreamQuery_spt hipStreamQuery_spt_fn;
1434 t_hipStreamSynchronize_spt hipStreamSynchronize_spt_fn;
1435 t_hipStreamGetPriority_spt hipStreamGetPriority_spt_fn;
1436 t_hipStreamWaitEvent_spt hipStreamWaitEvent_spt_fn;
1437 t_hipStreamGetFlags_spt hipStreamGetFlags_spt_fn;
1438 t_hipStreamAddCallback_spt hipStreamAddCallback_spt_fn;
1439 t_hipEventRecord_spt hipEventRecord_spt_fn;
1440 t_hipLaunchCooperativeKernel_spt hipLaunchCooperativeKernel_spt_fn;
1441 t_hipLaunchKernel_spt hipLaunchKernel_spt_fn;
1442 t_hipGraphLaunch_spt hipGraphLaunch_spt_fn;
1443 t_hipStreamBeginCapture_spt hipStreamBeginCapture_spt_fn;
1444 t_hipStreamEndCapture_spt hipStreamEndCapture_spt_fn;
1445 t_hipStreamIsCapturing_spt hipStreamIsCapturing_spt_fn;
1446 t_hipStreamGetCaptureInfo_spt hipStreamGetCaptureInfo_spt_fn;
1447 t_hipStreamGetCaptureInfo_v2_spt hipStreamGetCaptureInfo_v2_spt_fn;
1448 t_hipLaunchHostFunc_spt hipLaunchHostFunc_spt_fn;
1449 t_hipGetStreamDeviceId hipGetStreamDeviceId_fn;
1450 t_hipDrvGraphAddMemsetNode hipDrvGraphAddMemsetNode_fn;
1451 t_hipGraphAddExternalSemaphoresWaitNode hipGraphAddExternalSemaphoresWaitNode_fn;
1452 t_hipGraphAddExternalSemaphoresSignalNode hipGraphAddExternalSemaphoresSignalNode_fn;
1453 t_hipGraphExternalSemaphoresSignalNodeSetParams hipGraphExternalSemaphoresSignalNodeSetParams_fn;
1454 t_hipGraphExternalSemaphoresWaitNodeSetParams hipGraphExternalSemaphoresWaitNodeSetParams_fn;
1455 t_hipGraphExternalSemaphoresSignalNodeGetParams hipGraphExternalSemaphoresSignalNodeGetParams_fn;
1456 t_hipGraphExternalSemaphoresWaitNodeGetParams hipGraphExternalSemaphoresWaitNodeGetParams_fn;
1457 t_hipGraphExecExternalSemaphoresSignalNodeSetParams hipGraphExecExternalSemaphoresSignalNodeSetParams_fn;
1458 t_hipGraphExecExternalSemaphoresWaitNodeSetParams hipGraphExecExternalSemaphoresWaitNodeSetParams_fn;
1459 t_hipGraphAddNode hipGraphAddNode_fn;
1460 t_hipGraphInstantiateWithParams hipGraphInstantiateWithParams_fn;
1461 t_hipExtGetLastError hipExtGetLastError_fn;
1462 t_hipTexRefGetBorderColor hipTexRefGetBorderColor_fn;
1463 t_hipTexRefGetArray hipTexRefGetArray_fn;
1464 t_hipGetProcAddress hipGetProcAddress_fn;
1465 t_hipStreamBeginCaptureToGraph hipStreamBeginCaptureToGraph_fn;
1466 t_hipGetFuncBySymbol hipGetFuncBySymbol_fn;
1467 t_hipDrvGraphAddMemFreeNode hipDrvGraphAddMemFreeNode_fn;
1468 t_hipDrvGraphExecMemcpyNodeSetParams hipDrvGraphExecMemcpyNodeSetParams_fn;
1469 t_hipDrvGraphExecMemsetNodeSetParams hipDrvGraphExecMemsetNodeSetParams_fn;
1470 t_hipSetValidDevices hipSetValidDevices_fn;
1471 t_hipMemcpyAtoD hipMemcpyAtoD_fn;
1472 t_hipMemcpyDtoA hipMemcpyDtoA_fn;
1473 t_hipMemcpyAtoA hipMemcpyAtoA_fn;
1474 t_hipMemcpyAtoHAsync hipMemcpyAtoHAsync_fn;
1475 t_hipMemcpyHtoAAsync hipMemcpyHtoAAsync_fn;
1476 t_hipMemcpy2DArrayToArray hipMemcpy2DArrayToArray_fn;
1477 t_hipGraphExecGetFlags hipGraphExecGetFlags_fn;
1478 t_hipGraphNodeSetParams hipGraphNodeSetParams_fn;
1479 t_hipGraphExecNodeSetParams hipGraphExecNodeSetParams_fn;
1480 t_hipExternalMemoryGetMappedMipmappedArray hipExternalMemoryGetMappedMipmappedArray_fn;
1481 t_hipDrvGraphMemcpyNodeGetParams hipDrvGraphMemcpyNodeGetParams_fn;
1482 t_hipDrvGraphMemcpyNodeSetParams hipDrvGraphMemcpyNodeSetParams_fn;
1483};
hipGLDeviceList
Definition amd_hip_gl_interop.h:40
unsigned int GLenum
Definition amd_hip_gl_interop.h:52
unsigned int GLuint
Definition amd_hip_gl_interop.h:50
Definition amd_hip_vector_types.h:1872
Definition hip_api_trace.hpp:1002
Definition hip_api_trace.hpp:1016