HIP: Heterogenous-computing Interface for Portability
hip_prof_str.h
1 // automatically generated sources
2 #ifndef _HIP_PROF_STR_H
3 #define _HIP_PROF_STR_H
4 
5 // Dummy API primitives
6 #define INIT_NONE_CB_ARGS_DATA(cb_data) {};
7 #define INIT_hipModuleGetFunctionEx_CB_ARGS_DATA(cb_data) {};
8 #define INIT_hipDestroyTextureObject_CB_ARGS_DATA(cb_data) {};
9 #define INIT_hipTexRefSetAddress_CB_ARGS_DATA(cb_data) {};
10 #define INIT_hipBindTexture2D_CB_ARGS_DATA(cb_data) {};
11 #define INIT_hipTexRefGetArray_CB_ARGS_DATA(cb_data) {};
12 #define INIT_hipCreateTextureObject_CB_ARGS_DATA(cb_data) {};
13 #define INIT_hipBindTextureToMipmappedArray_CB_ARGS_DATA(cb_data) {};
14 #define INIT_hipBindTextureToArray_CB_ARGS_DATA(cb_data) {};
15 #define INIT_hipTexRefSetFormat_CB_ARGS_DATA(cb_data) {};
16 #define INIT_hipMemcpyHtoH_CB_ARGS_DATA(cb_data) {};
17 #define INIT_hipGetTextureReference_CB_ARGS_DATA(cb_data) {};
18 #define INIT_hipTexRefSetArray_CB_ARGS_DATA(cb_data) {};
19 #define INIT_hipHccGetAcceleratorView_CB_ARGS_DATA(cb_data) {};
20 #define INIT_hipTexRefSetAddress2D_CB_ARGS_DATA(cb_data) {};
21 #define INIT_hipGetTextureObjectResourceViewDesc_CB_ARGS_DATA(cb_data) {};
22 #define INIT_hipUnbindTexture_CB_ARGS_DATA(cb_data) {};
23 #define INIT_hipTexRefSetFilterMode_CB_ARGS_DATA(cb_data) {};
24 #define INIT_hipGetTextureAlignmentOffset_CB_ARGS_DATA(cb_data) {};
25 #define INIT_hipCreateSurfaceObject_CB_ARGS_DATA(cb_data) {};
26 #define INIT_hipGetChannelDesc_CB_ARGS_DATA(cb_data) {};
27 #define INIT_hipTexRefGetAddressMode_CB_ARGS_DATA(cb_data) {};
28 #define INIT_hipGetTextureObjectResourceDesc_CB_ARGS_DATA(cb_data) {};
29 #define INIT_hipDestroySurfaceObject_CB_ARGS_DATA(cb_data) {};
30 #define INIT_hipTexRefSetAddressMode_CB_ARGS_DATA(cb_data) {};
31 #define INIT_hipTexRefSetFlags_CB_ARGS_DATA(cb_data) {};
32 #define INIT_hipBindTexture_CB_ARGS_DATA(cb_data) {};
33 #define INIT_hipHccGetAccelerator_CB_ARGS_DATA(cb_data) {};
34 #define INIT_hipTexRefGetAddress_CB_ARGS_DATA(cb_data) {};
35 #define INIT_hipGetTextureObjectTextureDesc_CB_ARGS_DATA(cb_data) {};
36 
37 // HIP API callbacks ID enumaration
38 enum hip_api_id_t {
39  HIP_API_ID_hipStreamCreateWithPriority = 0,
40  HIP_API_ID_hipMemcpyToSymbolAsync = 1,
41  HIP_API_ID_hipMallocPitch = 2,
42  HIP_API_ID_hipMalloc = 3,
43  HIP_API_ID_hipMemsetD16 = 4,
44  HIP_API_ID_hipDeviceGetName = 5,
45  HIP_API_ID_hipEventRecord = 6,
46  HIP_API_ID_hipCtxSynchronize = 7,
47  HIP_API_ID_hipDrvOccupancyMaxActiveBlocksPerMultiprocessor = 8,
48  HIP_API_ID_hipSetDevice = 9,
49  HIP_API_ID_hipCtxGetApiVersion = 10,
50  HIP_API_ID_hipSetupArgument = 11,
51  HIP_API_ID_hipMemcpyFromSymbolAsync = 12,
52  HIP_API_ID_hipExtGetLinkTypeAndHopCount = 13,
53  HIP_API_ID_hipMemcpyDtoD = 14,
54  HIP_API_ID_hipHostFree = 15,
55  HIP_API_ID_hipMemcpy2DToArray = 16,
56  HIP_API_ID_hipMemsetD8Async = 17,
57  HIP_API_ID_hipCtxGetCacheConfig = 18,
58  HIP_API_ID_hipStreamWaitEvent = 19,
59  HIP_API_ID_hipDeviceGetStreamPriorityRange = 20,
60  HIP_API_ID_hipModuleLoad = 21,
61  HIP_API_ID_hipDevicePrimaryCtxSetFlags = 22,
62  HIP_API_ID_hipLaunchCooperativeKernel = 23,
63  HIP_API_ID_hipLaunchCooperativeKernelMultiDevice = 24,
64  HIP_API_ID_hipMemcpyAsync = 25,
65  HIP_API_ID_hipMalloc3DArray = 26,
66  HIP_API_ID_hipStreamCreate = 27,
67  HIP_API_ID_hipCtxGetCurrent = 28,
68  HIP_API_ID_hipDevicePrimaryCtxGetState = 29,
69  HIP_API_ID_hipEventQuery = 30,
70  HIP_API_ID_hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = 31,
71  HIP_API_ID_hipEventCreate = 32,
72  HIP_API_ID_hipMemGetAddressRange = 33,
73  HIP_API_ID_hipMemcpyFromSymbol = 34,
74  HIP_API_ID_hipArrayCreate = 35,
75  HIP_API_ID_hipStreamGetFlags = 36,
76  HIP_API_ID_hipMallocArray = 37,
77  HIP_API_ID_hipCtxGetSharedMemConfig = 38,
78  HIP_API_ID_hipMemPtrGetInfo = 39,
79  HIP_API_ID_hipFuncGetAttribute = 40,
80  HIP_API_ID_hipCtxGetFlags = 41,
81  HIP_API_ID_hipStreamDestroy = 42,
82  HIP_API_ID___hipPushCallConfiguration = 43,
83  HIP_API_ID_hipMemset3DAsync = 44,
84  HIP_API_ID_hipMemcpy3D = 45,
85  HIP_API_ID_hipInit = 46,
86  HIP_API_ID_hipMemcpyAtoH = 47,
87  HIP_API_ID_hipStreamGetPriority = 48,
88  HIP_API_ID_hipMemset2D = 49,
89  HIP_API_ID_hipMemset2DAsync = 50,
90  HIP_API_ID_hipDeviceCanAccessPeer = 51,
91  HIP_API_ID_hipDeviceEnablePeerAccess = 52,
92  HIP_API_ID_hipLaunchKernel = 53,
93  HIP_API_ID_hipMemsetD16Async = 54,
94  HIP_API_ID_hipModuleUnload = 55,
95  HIP_API_ID_hipHostUnregister = 56,
96  HIP_API_ID_hipProfilerStop = 57,
97  HIP_API_ID_hipLaunchByPtr = 58,
98  HIP_API_ID_hipStreamSynchronize = 59,
99  HIP_API_ID_hipDeviceSetCacheConfig = 60,
100  HIP_API_ID_hipGetErrorName = 61,
101  HIP_API_ID_hipMemcpyHtoD = 62,
102  HIP_API_ID_hipModuleGetGlobal = 63,
103  HIP_API_ID_hipMemcpyHtoA = 64,
104  HIP_API_ID_hipCtxCreate = 65,
105  HIP_API_ID_hipMemcpy2D = 66,
106  HIP_API_ID_hipIpcCloseMemHandle = 67,
107  HIP_API_ID_hipChooseDevice = 68,
108  HIP_API_ID_hipGetLastError = 69,
109  HIP_API_ID_hipDeviceComputeCapability = 70,
110  HIP_API_ID_hipDeviceGet = 71,
111  HIP_API_ID_hipProfilerStart = 72,
112  HIP_API_ID_hipCtxSetCacheConfig = 73,
113  HIP_API_ID_hipFuncSetCacheConfig = 74,
114  HIP_API_ID_hipModuleGetTexRef = 75,
115  HIP_API_ID_hipMemcpyPeerAsync = 76,
116  HIP_API_ID_hipMemcpyWithStream = 77,
117  HIP_API_ID_hipDevicePrimaryCtxReset = 78,
118  HIP_API_ID_hipMemcpy3DAsync = 79,
119  HIP_API_ID_hipEventDestroy = 80,
120  HIP_API_ID_hipCtxPopCurrent = 81,
121  HIP_API_ID_hipGetSymbolAddress = 82,
122  HIP_API_ID_hipHostGetFlags = 83,
123  HIP_API_ID_hipHostMalloc = 84,
124  HIP_API_ID_hipDriverGetVersion = 85,
125  HIP_API_ID_hipMemGetInfo = 86,
126  HIP_API_ID_hipDeviceReset = 87,
127  HIP_API_ID_hipMemset = 88,
128  HIP_API_ID_hipMemsetD8 = 89,
129  HIP_API_ID_hipMemcpyParam2DAsync = 90,
130  HIP_API_ID_hipHostRegister = 91,
131  HIP_API_ID_hipCtxSetSharedMemConfig = 92,
132  HIP_API_ID_hipArray3DCreate = 93,
133  HIP_API_ID_hipIpcOpenMemHandle = 94,
134  HIP_API_ID_hipDeviceSetSharedMemConfig = 95,
135  HIP_API_ID_hipCtxDestroy = 96,
136  HIP_API_ID_hipDeviceGetSharedMemConfig = 97,
137  HIP_API_ID_hipMemcpy2DFromArray = 98,
138  HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = 99,
139  HIP_API_ID_hipSetDeviceFlags = 100,
140  HIP_API_ID_hipHccModuleLaunchKernel = 101,
141  HIP_API_ID_hipFree = 102,
142  HIP_API_ID_hipOccupancyMaxPotentialBlockSize = 103,
143  HIP_API_ID_hipDeviceGetAttribute = 104,
144  HIP_API_ID_hipMemcpyDtoH = 105,
145  HIP_API_ID_hipCtxDisablePeerAccess = 106,
146  HIP_API_ID_hipMallocManaged = 107,
147  HIP_API_ID_hipDeviceGetByPCIBusId = 108,
148  HIP_API_ID_hipIpcGetMemHandle = 109,
149  HIP_API_ID_hipMemcpyHtoDAsync = 110,
150  HIP_API_ID_hipCtxGetDevice = 111,
151  HIP_API_ID_hipMemset3D = 112,
152  HIP_API_ID_hipModuleLoadData = 113,
153  HIP_API_ID_hipDeviceTotalMem = 114,
154  HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor = 115,
155  HIP_API_ID_hipCtxSetCurrent = 116,
156  HIP_API_ID_hipGetErrorString = 117,
157  HIP_API_ID_hipDevicePrimaryCtxRetain = 118,
158  HIP_API_ID_hipDeviceDisablePeerAccess = 119,
159  HIP_API_ID_hipStreamCreateWithFlags = 120,
160  HIP_API_ID_hipMemcpyFromArray = 121,
161  HIP_API_ID_hipMemcpy2DAsync = 122,
162  HIP_API_ID_hipFuncGetAttributes = 123,
163  HIP_API_ID_hipGetSymbolSize = 124,
164  HIP_API_ID_hipEventCreateWithFlags = 125,
165  HIP_API_ID_hipStreamQuery = 126,
166  HIP_API_ID_hipDeviceGetPCIBusId = 127,
167  HIP_API_ID_hipMemcpy = 128,
168  HIP_API_ID_hipPeekAtLastError = 129,
169  HIP_API_ID_hipExtLaunchMultiKernelMultiDevice = 130,
170  HIP_API_ID_hipStreamAddCallback = 131,
171  HIP_API_ID_hipMemcpyToArray = 132,
172  HIP_API_ID_hipMemsetD32 = 133,
173  HIP_API_ID_hipExtModuleLaunchKernel = 134,
174  HIP_API_ID_hipDeviceSynchronize = 135,
175  HIP_API_ID_hipDeviceGetCacheConfig = 136,
176  HIP_API_ID_hipMalloc3D = 137,
177  HIP_API_ID_hipPointerGetAttributes = 138,
178  HIP_API_ID_hipMemsetAsync = 139,
179  HIP_API_ID_hipMemcpyToSymbol = 140,
180  HIP_API_ID_hipCtxPushCurrent = 141,
181  HIP_API_ID_hipMemcpyPeer = 142,
182  HIP_API_ID_hipEventSynchronize = 143,
183  HIP_API_ID_hipMemcpyDtoDAsync = 144,
184  HIP_API_ID_hipExtMallocWithFlags = 145,
185  HIP_API_ID_hipCtxEnablePeerAccess = 146,
186  HIP_API_ID_hipMemcpyDtoHAsync = 147,
187  HIP_API_ID_hipModuleLaunchKernel = 148,
188  HIP_API_ID_hipMemAllocPitch = 149,
189  HIP_API_ID_hipMemcpy2DFromArrayAsync = 150,
190  HIP_API_ID_hipDeviceGetLimit = 151,
191  HIP_API_ID_hipModuleLoadDataEx = 152,
192  HIP_API_ID_hipRuntimeGetVersion = 153,
193  HIP_API_ID___hipPopCallConfiguration = 154,
194  HIP_API_ID_hipGetDeviceProperties = 155,
195  HIP_API_ID_hipFreeArray = 156,
196  HIP_API_ID_hipEventElapsedTime = 157,
197  HIP_API_ID_hipDevicePrimaryCtxRelease = 158,
198  HIP_API_ID_hipHostGetDevicePointer = 159,
199  HIP_API_ID_hipMemcpyParam2D = 160,
200  HIP_API_ID_hipModuleGetFunction = 161,
201  HIP_API_ID_hipMemsetD32Async = 162,
202  HIP_API_ID_hipGetDevice = 163,
203  HIP_API_ID_hipGetDeviceCount = 164,
204  HIP_API_ID_NUMBER = 165,
205 
206  HIP_API_ID_NONE = HIP_API_ID_NUMBER,
207  HIP_API_ID_hipModuleGetFunctionEx = HIP_API_ID_NUMBER,
208  HIP_API_ID_hipDestroyTextureObject = HIP_API_ID_NUMBER,
209  HIP_API_ID_hipTexRefSetAddress = HIP_API_ID_NUMBER,
210  HIP_API_ID_hipBindTexture2D = HIP_API_ID_NUMBER,
211  HIP_API_ID_hipTexRefGetArray = HIP_API_ID_NUMBER,
212  HIP_API_ID_hipCreateTextureObject = HIP_API_ID_NUMBER,
213  HIP_API_ID_hipBindTextureToMipmappedArray = HIP_API_ID_NUMBER,
214  HIP_API_ID_hipBindTextureToArray = HIP_API_ID_NUMBER,
215  HIP_API_ID_hipTexRefSetFormat = HIP_API_ID_NUMBER,
216  HIP_API_ID_hipMemcpyHtoH = HIP_API_ID_NUMBER,
217  HIP_API_ID_hipGetTextureReference = HIP_API_ID_NUMBER,
218  HIP_API_ID_hipTexRefSetArray = HIP_API_ID_NUMBER,
219  HIP_API_ID_hipHccGetAcceleratorView = HIP_API_ID_NUMBER,
220  HIP_API_ID_hipTexRefSetAddress2D = HIP_API_ID_NUMBER,
221  HIP_API_ID_hipGetTextureObjectResourceViewDesc = HIP_API_ID_NUMBER,
222  HIP_API_ID_hipUnbindTexture = HIP_API_ID_NUMBER,
223  HIP_API_ID_hipTexRefSetFilterMode = HIP_API_ID_NUMBER,
224  HIP_API_ID_hipGetTextureAlignmentOffset = HIP_API_ID_NUMBER,
225  HIP_API_ID_hipCreateSurfaceObject = HIP_API_ID_NUMBER,
226  HIP_API_ID_hipGetChannelDesc = HIP_API_ID_NUMBER,
227  HIP_API_ID_hipTexRefGetAddressMode = HIP_API_ID_NUMBER,
228  HIP_API_ID_hipGetTextureObjectResourceDesc = HIP_API_ID_NUMBER,
229  HIP_API_ID_hipDestroySurfaceObject = HIP_API_ID_NUMBER,
230  HIP_API_ID_hipTexRefSetAddressMode = HIP_API_ID_NUMBER,
231  HIP_API_ID_hipTexRefSetFlags = HIP_API_ID_NUMBER,
232  HIP_API_ID_hipBindTexture = HIP_API_ID_NUMBER,
233  HIP_API_ID_hipHccGetAccelerator = HIP_API_ID_NUMBER,
234  HIP_API_ID_hipTexRefGetAddress = HIP_API_ID_NUMBER,
235  HIP_API_ID_hipGetTextureObjectTextureDesc = HIP_API_ID_NUMBER,
236 };
237 
238 // Return HIP API string
239 static inline const char* hip_api_name(const uint32_t id) {
240  switch(id) {
241  case HIP_API_ID_hipStreamCreateWithPriority: return "hipStreamCreateWithPriority";
242  case HIP_API_ID_hipMemcpyToSymbolAsync: return "hipMemcpyToSymbolAsync";
243  case HIP_API_ID_hipMallocPitch: return "hipMallocPitch";
244  case HIP_API_ID_hipMalloc: return "hipMalloc";
245  case HIP_API_ID_hipMemsetD16: return "hipMemsetD16";
246  case HIP_API_ID_hipDeviceGetName: return "hipDeviceGetName";
247  case HIP_API_ID_hipEventRecord: return "hipEventRecord";
248  case HIP_API_ID_hipCtxSynchronize: return "hipCtxSynchronize";
249  case HIP_API_ID_hipDrvOccupancyMaxActiveBlocksPerMultiprocessor: return "hipDrvOccupancyMaxActiveBlocksPerMultiprocessor";
250  case HIP_API_ID_hipSetDevice: return "hipSetDevice";
251  case HIP_API_ID_hipCtxGetApiVersion: return "hipCtxGetApiVersion";
252  case HIP_API_ID_hipSetupArgument: return "hipSetupArgument";
253  case HIP_API_ID_hipMemcpyFromSymbolAsync: return "hipMemcpyFromSymbolAsync";
254  case HIP_API_ID_hipExtGetLinkTypeAndHopCount: return "hipExtGetLinkTypeAndHopCount";
255  case HIP_API_ID_hipMemcpyDtoD: return "hipMemcpyDtoD";
256  case HIP_API_ID_hipHostFree: return "hipHostFree";
257  case HIP_API_ID_hipMemcpy2DToArray: return "hipMemcpy2DToArray";
258  case HIP_API_ID_hipMemsetD8Async: return "hipMemsetD8Async";
259  case HIP_API_ID_hipCtxGetCacheConfig: return "hipCtxGetCacheConfig";
260  case HIP_API_ID_hipStreamWaitEvent: return "hipStreamWaitEvent";
261  case HIP_API_ID_hipDeviceGetStreamPriorityRange: return "hipDeviceGetStreamPriorityRange";
262  case HIP_API_ID_hipModuleLoad: return "hipModuleLoad";
263  case HIP_API_ID_hipDevicePrimaryCtxSetFlags: return "hipDevicePrimaryCtxSetFlags";
264  case HIP_API_ID_hipLaunchCooperativeKernel: return "hipLaunchCooperativeKernel";
265  case HIP_API_ID_hipLaunchCooperativeKernelMultiDevice: return "hipLaunchCooperativeKernelMultiDevice";
266  case HIP_API_ID_hipMemcpyAsync: return "hipMemcpyAsync";
267  case HIP_API_ID_hipMalloc3DArray: return "hipMalloc3DArray";
268  case HIP_API_ID_hipStreamCreate: return "hipStreamCreate";
269  case HIP_API_ID_hipCtxGetCurrent: return "hipCtxGetCurrent";
270  case HIP_API_ID_hipDevicePrimaryCtxGetState: return "hipDevicePrimaryCtxGetState";
271  case HIP_API_ID_hipEventQuery: return "hipEventQuery";
272  case HIP_API_ID_hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags: return "hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags";
273  case HIP_API_ID_hipEventCreate: return "hipEventCreate";
274  case HIP_API_ID_hipMemGetAddressRange: return "hipMemGetAddressRange";
275  case HIP_API_ID_hipMemcpyFromSymbol: return "hipMemcpyFromSymbol";
276  case HIP_API_ID_hipArrayCreate: return "hipArrayCreate";
277  case HIP_API_ID_hipStreamGetFlags: return "hipStreamGetFlags";
278  case HIP_API_ID_hipMallocArray: return "hipMallocArray";
279  case HIP_API_ID_hipCtxGetSharedMemConfig: return "hipCtxGetSharedMemConfig";
280  case HIP_API_ID_hipMemPtrGetInfo: return "hipMemPtrGetInfo";
281  case HIP_API_ID_hipFuncGetAttribute: return "hipFuncGetAttribute";
282  case HIP_API_ID_hipCtxGetFlags: return "hipCtxGetFlags";
283  case HIP_API_ID_hipStreamDestroy: return "hipStreamDestroy";
284  case HIP_API_ID___hipPushCallConfiguration: return "__hipPushCallConfiguration";
285  case HIP_API_ID_hipMemset3DAsync: return "hipMemset3DAsync";
286  case HIP_API_ID_hipMemcpy3D: return "hipMemcpy3D";
287  case HIP_API_ID_hipInit: return "hipInit";
288  case HIP_API_ID_hipMemcpyAtoH: return "hipMemcpyAtoH";
289  case HIP_API_ID_hipStreamGetPriority: return "hipStreamGetPriority";
290  case HIP_API_ID_hipMemset2D: return "hipMemset2D";
291  case HIP_API_ID_hipMemset2DAsync: return "hipMemset2DAsync";
292  case HIP_API_ID_hipDeviceCanAccessPeer: return "hipDeviceCanAccessPeer";
293  case HIP_API_ID_hipDeviceEnablePeerAccess: return "hipDeviceEnablePeerAccess";
294  case HIP_API_ID_hipLaunchKernel: return "hipLaunchKernel";
295  case HIP_API_ID_hipMemsetD16Async: return "hipMemsetD16Async";
296  case HIP_API_ID_hipModuleUnload: return "hipModuleUnload";
297  case HIP_API_ID_hipHostUnregister: return "hipHostUnregister";
298  case HIP_API_ID_hipProfilerStop: return "hipProfilerStop";
299  case HIP_API_ID_hipLaunchByPtr: return "hipLaunchByPtr";
300  case HIP_API_ID_hipStreamSynchronize: return "hipStreamSynchronize";
301  case HIP_API_ID_hipDeviceSetCacheConfig: return "hipDeviceSetCacheConfig";
302  case HIP_API_ID_hipGetErrorName: return "hipGetErrorName";
303  case HIP_API_ID_hipMemcpyHtoD: return "hipMemcpyHtoD";
304  case HIP_API_ID_hipModuleGetGlobal: return "hipModuleGetGlobal";
305  case HIP_API_ID_hipMemcpyHtoA: return "hipMemcpyHtoA";
306  case HIP_API_ID_hipCtxCreate: return "hipCtxCreate";
307  case HIP_API_ID_hipMemcpy2D: return "hipMemcpy2D";
308  case HIP_API_ID_hipIpcCloseMemHandle: return "hipIpcCloseMemHandle";
309  case HIP_API_ID_hipChooseDevice: return "hipChooseDevice";
310  case HIP_API_ID_hipGetLastError: return "hipGetLastError";
311  case HIP_API_ID_hipDeviceComputeCapability: return "hipDeviceComputeCapability";
312  case HIP_API_ID_hipDeviceGet: return "hipDeviceGet";
313  case HIP_API_ID_hipProfilerStart: return "hipProfilerStart";
314  case HIP_API_ID_hipCtxSetCacheConfig: return "hipCtxSetCacheConfig";
315  case HIP_API_ID_hipFuncSetCacheConfig: return "hipFuncSetCacheConfig";
316  case HIP_API_ID_hipModuleGetTexRef: return "hipModuleGetTexRef";
317  case HIP_API_ID_hipMemcpyPeerAsync: return "hipMemcpyPeerAsync";
318  case HIP_API_ID_hipMemcpyWithStream: return "hipMemcpyWithStream";
319  case HIP_API_ID_hipDevicePrimaryCtxReset: return "hipDevicePrimaryCtxReset";
320  case HIP_API_ID_hipMemcpy3DAsync: return "hipMemcpy3DAsync";
321  case HIP_API_ID_hipEventDestroy: return "hipEventDestroy";
322  case HIP_API_ID_hipCtxPopCurrent: return "hipCtxPopCurrent";
323  case HIP_API_ID_hipGetSymbolAddress: return "hipGetSymbolAddress";
324  case HIP_API_ID_hipHostGetFlags: return "hipHostGetFlags";
325  case HIP_API_ID_hipHostMalloc: return "hipHostMalloc";
326  case HIP_API_ID_hipDriverGetVersion: return "hipDriverGetVersion";
327  case HIP_API_ID_hipMemGetInfo: return "hipMemGetInfo";
328  case HIP_API_ID_hipDeviceReset: return "hipDeviceReset";
329  case HIP_API_ID_hipMemset: return "hipMemset";
330  case HIP_API_ID_hipMemsetD8: return "hipMemsetD8";
331  case HIP_API_ID_hipMemcpyParam2DAsync: return "hipMemcpyParam2DAsync";
332  case HIP_API_ID_hipHostRegister: return "hipHostRegister";
333  case HIP_API_ID_hipCtxSetSharedMemConfig: return "hipCtxSetSharedMemConfig";
334  case HIP_API_ID_hipArray3DCreate: return "hipArray3DCreate";
335  case HIP_API_ID_hipIpcOpenMemHandle: return "hipIpcOpenMemHandle";
336  case HIP_API_ID_hipDeviceSetSharedMemConfig: return "hipDeviceSetSharedMemConfig";
337  case HIP_API_ID_hipCtxDestroy: return "hipCtxDestroy";
338  case HIP_API_ID_hipDeviceGetSharedMemConfig: return "hipDeviceGetSharedMemConfig";
339  case HIP_API_ID_hipMemcpy2DFromArray: return "hipMemcpy2DFromArray";
340  case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags: return "hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags";
341  case HIP_API_ID_hipSetDeviceFlags: return "hipSetDeviceFlags";
342  case HIP_API_ID_hipHccModuleLaunchKernel: return "hipHccModuleLaunchKernel";
343  case HIP_API_ID_hipFree: return "hipFree";
344  case HIP_API_ID_hipOccupancyMaxPotentialBlockSize: return "hipOccupancyMaxPotentialBlockSize";
345  case HIP_API_ID_hipDeviceGetAttribute: return "hipDeviceGetAttribute";
346  case HIP_API_ID_hipMemcpyDtoH: return "hipMemcpyDtoH";
347  case HIP_API_ID_hipCtxDisablePeerAccess: return "hipCtxDisablePeerAccess";
348  case HIP_API_ID_hipMallocManaged: return "hipMallocManaged";
349  case HIP_API_ID_hipDeviceGetByPCIBusId: return "hipDeviceGetByPCIBusId";
350  case HIP_API_ID_hipIpcGetMemHandle: return "hipIpcGetMemHandle";
351  case HIP_API_ID_hipMemcpyHtoDAsync: return "hipMemcpyHtoDAsync";
352  case HIP_API_ID_hipCtxGetDevice: return "hipCtxGetDevice";
353  case HIP_API_ID_hipMemset3D: return "hipMemset3D";
354  case HIP_API_ID_hipModuleLoadData: return "hipModuleLoadData";
355  case HIP_API_ID_hipDeviceTotalMem: return "hipDeviceTotalMem";
356  case HIP_API_ID_hipOccupancyMaxActiveBlocksPerMultiprocessor: return "hipOccupancyMaxActiveBlocksPerMultiprocessor";
357  case HIP_API_ID_hipCtxSetCurrent: return "hipCtxSetCurrent";
358  case HIP_API_ID_hipGetErrorString: return "hipGetErrorString";
359  case HIP_API_ID_hipDevicePrimaryCtxRetain: return "hipDevicePrimaryCtxRetain";
360  case HIP_API_ID_hipDeviceDisablePeerAccess: return "hipDeviceDisablePeerAccess";
361  case HIP_API_ID_hipStreamCreateWithFlags: return "hipStreamCreateWithFlags";
362  case HIP_API_ID_hipMemcpyFromArray: return "hipMemcpyFromArray";
363  case HIP_API_ID_hipMemcpy2DAsync: return "hipMemcpy2DAsync";
364  case HIP_API_ID_hipFuncGetAttributes: return "hipFuncGetAttributes";
365  case HIP_API_ID_hipGetSymbolSize: return "hipGetSymbolSize";
366  case HIP_API_ID_hipEventCreateWithFlags: return "hipEventCreateWithFlags";
367  case HIP_API_ID_hipStreamQuery: return "hipStreamQuery";
368  case HIP_API_ID_hipDeviceGetPCIBusId: return "hipDeviceGetPCIBusId";
369  case HIP_API_ID_hipMemcpy: return "hipMemcpy";
370  case HIP_API_ID_hipPeekAtLastError: return "hipPeekAtLastError";
371  case HIP_API_ID_hipExtLaunchMultiKernelMultiDevice: return "hipExtLaunchMultiKernelMultiDevice";
372  case HIP_API_ID_hipStreamAddCallback: return "hipStreamAddCallback";
373  case HIP_API_ID_hipMemcpyToArray: return "hipMemcpyToArray";
374  case HIP_API_ID_hipMemsetD32: return "hipMemsetD32";
375  case HIP_API_ID_hipExtModuleLaunchKernel: return "hipExtModuleLaunchKernel";
376  case HIP_API_ID_hipDeviceSynchronize: return "hipDeviceSynchronize";
377  case HIP_API_ID_hipDeviceGetCacheConfig: return "hipDeviceGetCacheConfig";
378  case HIP_API_ID_hipMalloc3D: return "hipMalloc3D";
379  case HIP_API_ID_hipPointerGetAttributes: return "hipPointerGetAttributes";
380  case HIP_API_ID_hipMemsetAsync: return "hipMemsetAsync";
381  case HIP_API_ID_hipMemcpyToSymbol: return "hipMemcpyToSymbol";
382  case HIP_API_ID_hipCtxPushCurrent: return "hipCtxPushCurrent";
383  case HIP_API_ID_hipMemcpyPeer: return "hipMemcpyPeer";
384  case HIP_API_ID_hipEventSynchronize: return "hipEventSynchronize";
385  case HIP_API_ID_hipMemcpyDtoDAsync: return "hipMemcpyDtoDAsync";
386  case HIP_API_ID_hipExtMallocWithFlags: return "hipExtMallocWithFlags";
387  case HIP_API_ID_hipCtxEnablePeerAccess: return "hipCtxEnablePeerAccess";
388  case HIP_API_ID_hipMemcpyDtoHAsync: return "hipMemcpyDtoHAsync";
389  case HIP_API_ID_hipModuleLaunchKernel: return "hipModuleLaunchKernel";
390  case HIP_API_ID_hipMemAllocPitch: return "hipMemAllocPitch";
391  case HIP_API_ID_hipMemcpy2DFromArrayAsync: return "hipMemcpy2DFromArrayAsync";
392  case HIP_API_ID_hipDeviceGetLimit: return "hipDeviceGetLimit";
393  case HIP_API_ID_hipModuleLoadDataEx: return "hipModuleLoadDataEx";
394  case HIP_API_ID_hipRuntimeGetVersion: return "hipRuntimeGetVersion";
395  case HIP_API_ID___hipPopCallConfiguration: return "__hipPopCallConfiguration";
396  case HIP_API_ID_hipGetDeviceProperties: return "hipGetDeviceProperties";
397  case HIP_API_ID_hipFreeArray: return "hipFreeArray";
398  case HIP_API_ID_hipEventElapsedTime: return "hipEventElapsedTime";
399  case HIP_API_ID_hipDevicePrimaryCtxRelease: return "hipDevicePrimaryCtxRelease";
400  case HIP_API_ID_hipHostGetDevicePointer: return "hipHostGetDevicePointer";
401  case HIP_API_ID_hipMemcpyParam2D: return "hipMemcpyParam2D";
402  case HIP_API_ID_hipModuleGetFunction: return "hipModuleGetFunction";
403  case HIP_API_ID_hipMemsetD32Async: return "hipMemsetD32Async";
404  case HIP_API_ID_hipGetDevice: return "hipGetDevice";
405  case HIP_API_ID_hipGetDeviceCount: return "hipGetDeviceCount";
406  };
407  return "unknown";
408 };
409 
410 // HIP API callbacks data structure
411 typedef struct hip_api_data_t {
412  uint64_t correlation_id;
413  uint32_t phase;
414  union {
415  struct {
416  hipStream_t* stream;
417  unsigned int flags;
418  int priority;
419  } hipStreamCreateWithPriority;
420  struct {
421  const void* symbolName;
422  const void* src;
423  size_t sizeBytes;
424  size_t offset;
425  hipMemcpyKind kind;
426  hipStream_t stream;
427  } hipMemcpyToSymbolAsync;
428  struct {
429  void** ptr;
430  size_t* pitch;
431  size_t width;
432  size_t height;
433  } hipMallocPitch;
434  struct {
435  void** ptr;
436  size_t size;
437  } hipMalloc;
438  struct {
439  hipDeviceptr_t dest;
440  unsigned short value;
441  size_t count;
442  } hipMemsetD16;
443  struct {
444  char* name;
445  int len;
446  hipDevice_t device;
447  } hipDeviceGetName;
448  struct {
449  hipEvent_t event;
450  hipStream_t stream;
451  } hipEventRecord;
452  struct {
453  int* numBlocks;
454  hipFunction_t f;
455  int blockSize;
456  size_t dynSharedMemPerBlk;
457  } hipDrvOccupancyMaxActiveBlocksPerMultiprocessor;
458  struct {
459  int deviceId;
460  } hipSetDevice;
461  struct {
462  hipCtx_t ctx;
463  int* apiVersion;
464  } hipCtxGetApiVersion;
465  struct {
466  const void* arg;
467  size_t size;
468  size_t offset;
469  } hipSetupArgument;
470  struct {
471  void* dst;
472  const void* symbolName;
473  size_t sizeBytes;
474  size_t offset;
475  hipMemcpyKind kind;
476  hipStream_t stream;
477  } hipMemcpyFromSymbolAsync;
478  struct {
479  int device1;
480  int device2;
481  unsigned int* linktype;
482  unsigned int* hopcount;
483  } hipExtGetLinkTypeAndHopCount;
484  struct {
485  hipDeviceptr_t dst;
486  hipDeviceptr_t src;
487  size_t sizeBytes;
488  } hipMemcpyDtoD;
489  struct {
490  void* ptr;
491  } hipHostFree;
492  struct {
493  hipArray* dst;
494  size_t wOffset;
495  size_t hOffset;
496  const void* src;
497  size_t spitch;
498  size_t width;
499  size_t height;
500  hipMemcpyKind kind;
501  } hipMemcpy2DToArray;
502  struct {
503  hipDeviceptr_t dest;
504  unsigned char value;
505  size_t count;
506  hipStream_t stream;
507  } hipMemsetD8Async;
508  struct {
509  hipFuncCache_t* cacheConfig;
510  } hipCtxGetCacheConfig;
511  struct {
512  hipStream_t stream;
513  hipEvent_t event;
514  unsigned int flags;
515  } hipStreamWaitEvent;
516  struct {
517  int* leastPriority;
518  int* greatestPriority;
519  } hipDeviceGetStreamPriorityRange;
520  struct {
521  hipModule_t* module;
522  const char* fname;
523  } hipModuleLoad;
524  struct {
525  hipDevice_t dev;
526  unsigned int flags;
527  } hipDevicePrimaryCtxSetFlags;
528  struct {
529  const void* f;
530  dim3 gridDim;
531  dim3 blockDimX;
532  void** kernelParams;
533  unsigned int sharedMemBytes;
534  hipStream_t stream;
535  } hipLaunchCooperativeKernel;
536  struct {
537  hipLaunchParams* launchParamsList;
538  int numDevices;
539  unsigned int flags;
540  } hipLaunchCooperativeKernelMultiDevice;
541  struct {
542  void* dst;
543  const void* src;
544  size_t sizeBytes;
545  hipMemcpyKind kind;
546  hipStream_t stream;
547  } hipMemcpyAsync;
548  struct {
549  hipArray** array;
550  const hipChannelFormatDesc* desc;
551  hipExtent extent;
552  unsigned int flags;
553  } hipMalloc3DArray;
554  struct {
555  hipStream_t* stream;
556  } hipStreamCreate;
557  struct {
558  hipCtx_t* ctx;
559  } hipCtxGetCurrent;
560  struct {
561  hipDevice_t dev;
562  unsigned int* flags;
563  int* active;
564  } hipDevicePrimaryCtxGetState;
565  struct {
566  hipEvent_t event;
567  } hipEventQuery;
568  struct {
569  int* numBlocks;
570  hipFunction_t f;
571  int blockSize;
572  size_t dynSharedMemPerBlk;
573  unsigned int flags;
574  } hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
575  struct {
576  hipEvent_t* event;
577  } hipEventCreate;
578  struct {
579  hipDeviceptr_t* pbase;
580  size_t* psize;
581  hipDeviceptr_t dptr;
582  } hipMemGetAddressRange;
583  struct {
584  void* dst;
585  const void* symbolName;
586  size_t sizeBytes;
587  size_t offset;
588  hipMemcpyKind kind;
589  } hipMemcpyFromSymbol;
590  struct {
591  hipArray** pHandle;
592  const HIP_ARRAY_DESCRIPTOR* pAllocateArray;
593  } hipArrayCreate;
594  struct {
595  hipStream_t stream;
596  unsigned int* flags;
597  } hipStreamGetFlags;
598  struct {
599  hipArray** array;
600  const hipChannelFormatDesc* desc;
601  size_t width;
602  size_t height;
603  unsigned int flags;
604  } hipMallocArray;
605  struct {
606  hipSharedMemConfig* pConfig;
607  } hipCtxGetSharedMemConfig;
608  struct {
609  void* ptr;
610  size_t* size;
611  } hipMemPtrGetInfo;
612  struct {
613  int* value;
614  hipFunction_attribute attrib;
615  hipFunction_t hfunc;
616  } hipFuncGetAttribute;
617  struct {
618  unsigned int* flags;
619  } hipCtxGetFlags;
620  struct {
621  hipStream_t stream;
622  } hipStreamDestroy;
623  struct {
624  dim3 gridDim;
625  dim3 blockDim;
626  size_t sharedMem;
627  hipStream_t stream;
628  } __hipPushCallConfiguration;
629  struct {
630  hipPitchedPtr pitchedDevPtr;
631  int value;
632  hipExtent extent;
633  hipStream_t stream;
634  } hipMemset3DAsync;
635  struct {
636  const hipMemcpy3DParms* p;
637  } hipMemcpy3D;
638  struct {
639  unsigned int flags;
640  } hipInit;
641  struct {
642  void* dst;
643  hipArray* srcArray;
644  size_t srcOffset;
645  size_t count;
646  } hipMemcpyAtoH;
647  struct {
648  hipStream_t stream;
649  int* priority;
650  } hipStreamGetPriority;
651  struct {
652  void* dst;
653  size_t pitch;
654  int value;
655  size_t width;
656  size_t height;
657  } hipMemset2D;
658  struct {
659  void* dst;
660  size_t pitch;
661  int value;
662  size_t width;
663  size_t height;
664  hipStream_t stream;
665  } hipMemset2DAsync;
666  struct {
667  int* canAccessPeer;
668  int deviceId;
669  int peerDeviceId;
670  } hipDeviceCanAccessPeer;
671  struct {
672  int peerDeviceId;
673  unsigned int flags;
674  } hipDeviceEnablePeerAccess;
675  struct {
676  const void* function_address;
677  dim3 numBlocks;
678  dim3 dimBlocks;
679  void** args;
680  size_t sharedMemBytes;
681  hipStream_t stream;
682  } hipLaunchKernel;
683  struct {
684  hipDeviceptr_t dest;
685  unsigned short value;
686  size_t count;
687  hipStream_t stream;
688  } hipMemsetD16Async;
689  struct {
690  hipModule_t module;
691  } hipModuleUnload;
692  struct {
693  void* hostPtr;
694  } hipHostUnregister;
695  struct {
696  const void* func;
697  } hipLaunchByPtr;
698  struct {
699  hipStream_t stream;
700  } hipStreamSynchronize;
701  struct {
702  hipFuncCache_t cacheConfig;
703  } hipDeviceSetCacheConfig;
704  struct {
705  hipError_t hip_error;
706  } hipGetErrorName;
707  struct {
708  hipDeviceptr_t dst;
709  void* src;
710  size_t sizeBytes;
711  } hipMemcpyHtoD;
712  struct {
713  hipDeviceptr_t* dptr;
714  size_t* bytes;
715  hipModule_t hmod;
716  const char* name;
717  } hipModuleGetGlobal;
718  struct {
719  hipArray* dstArray;
720  size_t dstOffset;
721  const void* srcHost;
722  size_t count;
723  } hipMemcpyHtoA;
724  struct {
725  hipCtx_t* ctx;
726  unsigned int flags;
727  hipDevice_t device;
728  } hipCtxCreate;
729  struct {
730  void* dst;
731  size_t dpitch;
732  const void* src;
733  size_t spitch;
734  size_t width;
735  size_t height;
736  hipMemcpyKind kind;
737  } hipMemcpy2D;
738  struct {
739  void* devPtr;
740  } hipIpcCloseMemHandle;
741  struct {
742  int* device;
743  const hipDeviceProp_t* prop;
744  } hipChooseDevice;
745  struct {
746  int* major;
747  int* minor;
748  hipDevice_t device;
749  } hipDeviceComputeCapability;
750  struct {
751  hipDevice_t* device;
752  int ordinal;
753  } hipDeviceGet;
754  struct {
755  hipFuncCache_t cacheConfig;
756  } hipCtxSetCacheConfig;
757  struct {
758  const void* func;
759  hipFuncCache_t config;
760  } hipFuncSetCacheConfig;
761  struct {
762  textureReference** texRef;
763  hipModule_t hmod;
764  const char* name;
765  } hipModuleGetTexRef;
766  struct {
767  void* dst;
768  int dstDeviceId;
769  const void* src;
770  int srcDevice;
771  size_t sizeBytes;
772  hipStream_t stream;
773  } hipMemcpyPeerAsync;
774  struct {
775  void* dst;
776  const void* src;
777  size_t sizeBytes;
778  hipMemcpyKind kind;
779  hipStream_t stream;
780  } hipMemcpyWithStream;
781  struct {
782  hipDevice_t dev;
783  } hipDevicePrimaryCtxReset;
784  struct {
785  const hipMemcpy3DParms* p;
786  hipStream_t stream;
787  } hipMemcpy3DAsync;
788  struct {
789  hipEvent_t event;
790  } hipEventDestroy;
791  struct {
792  hipCtx_t* ctx;
793  } hipCtxPopCurrent;
794  struct {
795  void** devPtr;
796  const void* symbolName;
797  } hipGetSymbolAddress;
798  struct {
799  unsigned int* flagsPtr;
800  void* hostPtr;
801  } hipHostGetFlags;
802  struct {
803  void** ptr;
804  size_t size;
805  unsigned int flags;
806  } hipHostMalloc;
807  struct {
808  int* driverVersion;
809  } hipDriverGetVersion;
810  struct {
811  size_t* free;
812  size_t* total;
813  } hipMemGetInfo;
814  struct {
815  void* dst;
816  int value;
817  size_t sizeBytes;
818  } hipMemset;
819  struct {
820  hipDeviceptr_t dest;
821  unsigned char value;
822  size_t count;
823  } hipMemsetD8;
824  struct {
825  const hip_Memcpy2D* pCopy;
826  hipStream_t stream;
827  } hipMemcpyParam2DAsync;
828  struct {
829  void* hostPtr;
830  size_t sizeBytes;
831  unsigned int flags;
832  } hipHostRegister;
833  struct {
834  hipSharedMemConfig config;
835  } hipCtxSetSharedMemConfig;
836  struct {
837  hipArray** array;
838  const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray;
839  } hipArray3DCreate;
840  struct {
841  void** devPtr;
842  hipIpcMemHandle_t handle;
843  unsigned int flags;
844  } hipIpcOpenMemHandle;
845  struct {
846  hipSharedMemConfig config;
847  } hipDeviceSetSharedMemConfig;
848  struct {
849  hipCtx_t ctx;
850  } hipCtxDestroy;
851  struct {
852  hipSharedMemConfig* pConfig;
853  } hipDeviceGetSharedMemConfig;
854  struct {
855  void* dst;
856  size_t dpitch;
857  hipArray_const_t src;
858  size_t wOffset;
859  size_t hOffset;
860  size_t width;
861  size_t height;
862  hipMemcpyKind kind;
863  } hipMemcpy2DFromArray;
864  struct {
865  unsigned int* numBlocks;
866  hipFunction_t f;
867  unsigned int blockSize;
868  size_t dynSharedMemPerBlk;
869  unsigned int flags;
870  } hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;
871  struct {
872  unsigned int flags;
873  } hipSetDeviceFlags;
874  struct {
875  hipFunction_t f;
876  unsigned int globalWorkSizeX;
877  unsigned int globalWorkSizeY;
878  unsigned int globalWorkSizeZ;
879  unsigned int localWorkSizeX;
880  unsigned int localWorkSizeY;
881  unsigned int localWorkSizeZ;
882  size_t sharedMemBytes;
883  hipStream_t hStream;
884  void** kernelParams;
885  void** extra;
886  hipEvent_t startEvent;
887  hipEvent_t stopEvent;
888  } hipHccModuleLaunchKernel;
889  struct {
890  void* ptr;
891  } hipFree;
892  struct {
893  unsigned int* gridSize;
894  unsigned int* blockSize;
895  hipFunction_t f;
896  size_t dynSharedMemPerBlk;
897  unsigned int blockSizeLimit;
898  } hipOccupancyMaxPotentialBlockSize;
899  struct {
900  int* pi;
902  int deviceId;
903  } hipDeviceGetAttribute;
904  struct {
905  void* dst;
906  hipDeviceptr_t src;
907  size_t sizeBytes;
908  } hipMemcpyDtoH;
909  struct {
910  hipCtx_t peerCtx;
911  } hipCtxDisablePeerAccess;
912  struct {
913  void** devPtr;
914  size_t size;
915  unsigned int flags;
916  } hipMallocManaged;
917  struct {
918  int* device;
919  const char* pciBusId;
920  } hipDeviceGetByPCIBusId;
921  struct {
922  hipIpcMemHandle_t* handle;
923  void* devPtr;
924  } hipIpcGetMemHandle;
925  struct {
926  hipDeviceptr_t dst;
927  void* src;
928  size_t sizeBytes;
929  hipStream_t stream;
930  } hipMemcpyHtoDAsync;
931  struct {
932  hipDevice_t* device;
933  } hipCtxGetDevice;
934  struct {
935  hipPitchedPtr pitchedDevPtr;
936  int value;
937  hipExtent extent;
938  } hipMemset3D;
939  struct {
940  hipModule_t* module;
941  const void* image;
942  } hipModuleLoadData;
943  struct {
944  size_t* bytes;
945  hipDevice_t device;
946  } hipDeviceTotalMem;
947  struct {
948  unsigned int* numBlocks;
949  hipFunction_t f;
950  unsigned int blockSize;
951  size_t dynSharedMemPerBlk;
952  } hipOccupancyMaxActiveBlocksPerMultiprocessor;
953  struct {
954  hipCtx_t ctx;
955  } hipCtxSetCurrent;
956  struct {
957  hipError_t hipError;
958  } hipGetErrorString;
959  struct {
960  hipCtx_t* pctx;
961  hipDevice_t dev;
962  } hipDevicePrimaryCtxRetain;
963  struct {
964  int peerDeviceId;
965  } hipDeviceDisablePeerAccess;
966  struct {
967  hipStream_t* stream;
968  unsigned int flags;
969  } hipStreamCreateWithFlags;
970  struct {
971  void* dst;
972  hipArray_const_t srcArray;
973  size_t wOffset;
974  size_t hOffset;
975  size_t count;
976  hipMemcpyKind kind;
977  } hipMemcpyFromArray;
978  struct {
979  void* dst;
980  size_t dpitch;
981  const void* src;
982  size_t spitch;
983  size_t width;
984  size_t height;
985  hipMemcpyKind kind;
986  hipStream_t stream;
987  } hipMemcpy2DAsync;
988  struct {
989  hipFuncAttributes* attr;
990  const void* func;
991  } hipFuncGetAttributes;
992  struct {
993  size_t* size;
994  const void* symbolName;
995  } hipGetSymbolSize;
996  struct {
997  hipEvent_t* event;
998  unsigned int flags;
999  } hipEventCreateWithFlags;
1000  struct {
1001  hipStream_t stream;
1002  } hipStreamQuery;
1003  struct {
1004  char* pciBusId;
1005  int len;
1006  int device;
1007  } hipDeviceGetPCIBusId;
1008  struct {
1009  void* dst;
1010  const void* src;
1011  size_t sizeBytes;
1012  hipMemcpyKind kind;
1013  } hipMemcpy;
1014  struct {
1015  hipLaunchParams* launchParamsList;
1016  int numDevices;
1017  unsigned int flags;
1018  } hipExtLaunchMultiKernelMultiDevice;
1019  struct {
1020  hipStream_t stream;
1021  hipStreamCallback_t callback;
1022  void* userData;
1023  unsigned int flags;
1024  } hipStreamAddCallback;
1025  struct {
1026  hipArray* dst;
1027  size_t wOffset;
1028  size_t hOffset;
1029  const void* src;
1030  size_t count;
1031  hipMemcpyKind kind;
1032  } hipMemcpyToArray;
1033  struct {
1034  hipDeviceptr_t dest;
1035  int value;
1036  size_t count;
1037  } hipMemsetD32;
1038  struct {
1039  hipFunction_t f;
1040  unsigned int globalWorkSizeX;
1041  unsigned int globalWorkSizeY;
1042  unsigned int globalWorkSizeZ;
1043  unsigned int localWorkSizeX;
1044  unsigned int localWorkSizeY;
1045  unsigned int localWorkSizeZ;
1046  size_t sharedMemBytes;
1047  hipStream_t hStream;
1048  void** kernelParams;
1049  void** extra;
1050  hipEvent_t startEvent;
1051  hipEvent_t stopEvent;
1052  unsigned int flags;
1053  } hipExtModuleLaunchKernel;
1054  struct {
1055  hipFuncCache_t* cacheConfig;
1056  } hipDeviceGetCacheConfig;
1057  struct {
1058  hipPitchedPtr* pitchedDevPtr;
1059  hipExtent extent;
1060  } hipMalloc3D;
1061  struct {
1062  hipPointerAttribute_t* attributes;
1063  const void* ptr;
1064  } hipPointerGetAttributes;
1065  struct {
1066  void* dst;
1067  int value;
1068  size_t sizeBytes;
1069  hipStream_t stream;
1070  } hipMemsetAsync;
1071  struct {
1072  const void* symbolName;
1073  const void* src;
1074  size_t sizeBytes;
1075  size_t offset;
1076  hipMemcpyKind kind;
1077  } hipMemcpyToSymbol;
1078  struct {
1079  hipCtx_t ctx;
1080  } hipCtxPushCurrent;
1081  struct {
1082  void* dst;
1083  int dstDeviceId;
1084  const void* src;
1085  int srcDeviceId;
1086  size_t sizeBytes;
1087  } hipMemcpyPeer;
1088  struct {
1089  hipEvent_t event;
1090  } hipEventSynchronize;
1091  struct {
1092  hipDeviceptr_t dst;
1093  hipDeviceptr_t src;
1094  size_t sizeBytes;
1095  hipStream_t stream;
1096  } hipMemcpyDtoDAsync;
1097  struct {
1098  void** ptr;
1099  size_t sizeBytes;
1100  unsigned int flags;
1101  } hipExtMallocWithFlags;
1102  struct {
1103  hipCtx_t peerCtx;
1104  unsigned int flags;
1105  } hipCtxEnablePeerAccess;
1106  struct {
1107  void* dst;
1108  hipDeviceptr_t src;
1109  size_t sizeBytes;
1110  hipStream_t stream;
1111  } hipMemcpyDtoHAsync;
1112  struct {
1113  hipFunction_t f;
1114  unsigned int gridDimX;
1115  unsigned int gridDimY;
1116  unsigned int gridDimZ;
1117  unsigned int blockDimX;
1118  unsigned int blockDimY;
1119  unsigned int blockDimZ;
1120  unsigned int sharedMemBytes;
1121  hipStream_t stream;
1122  void** kernelParams;
1123  void** extra;
1124  } hipModuleLaunchKernel;
1125  struct {
1126  hipDeviceptr_t* dptr;
1127  size_t* pitch;
1128  size_t widthInBytes;
1129  size_t height;
1130  unsigned int elementSizeBytes;
1131  } hipMemAllocPitch;
1132  struct {
1133  void* dst;
1134  size_t dpitch;
1135  hipArray_const_t src;
1136  size_t wOffset;
1137  size_t hOffset;
1138  size_t width;
1139  size_t height;
1140  hipMemcpyKind kind;
1141  hipStream_t stream;
1142  } hipMemcpy2DFromArrayAsync;
1143  struct {
1144  size_t* pValue;
1145  enum hipLimit_t limit;
1146  } hipDeviceGetLimit;
1147  struct {
1148  hipModule_t* module;
1149  const void* image;
1150  unsigned int numOptions;
1151  hipJitOption* options;
1152  void** optionValues;
1153  } hipModuleLoadDataEx;
1154  struct {
1155  int* runtimeVersion;
1156  } hipRuntimeGetVersion;
1157  struct {
1158  dim3 *gridDim;
1159  dim3 *blockDim;
1160  size_t *sharedMem;
1161  hipStream_t *stream;
1162  } __hipPopCallConfiguration;
1163  struct {
1164  hipDeviceProp_t* prop;
1165  int deviceId;
1166  } hipGetDeviceProperties;
1167  struct {
1168  hipArray* array;
1169  } hipFreeArray;
1170  struct {
1171  float* ms;
1172  hipEvent_t start;
1173  hipEvent_t stop;
1174  } hipEventElapsedTime;
1175  struct {
1176  hipDevice_t dev;
1177  } hipDevicePrimaryCtxRelease;
1178  struct {
1179  void** devPtr;
1180  void* hstPtr;
1181  unsigned int flags;
1182  } hipHostGetDevicePointer;
1183  struct {
1184  const hip_Memcpy2D* pCopy;
1185  } hipMemcpyParam2D;
1186  struct {
1187  hipFunction_t* function;
1188  hipModule_t module;
1189  const char* kname;
1190  } hipModuleGetFunction;
1191  struct {
1192  hipDeviceptr_t dst;
1193  int value;
1194  size_t count;
1195  hipStream_t stream;
1196  } hipMemsetD32Async;
1197  struct {
1198  int* deviceId;
1199  } hipGetDevice;
1200  struct {
1201  int* count;
1202  } hipGetDeviceCount;
1203  } args;
1204 } hip_api_data_t;
1205 
1206 // HIP API callbacks args data filling macros
1207 // hipStreamCreateWithPriority[('hipStream_t*', 'stream'), ('unsigned int', 'flags'), ('int', 'priority')]
1208 #define INIT_hipStreamCreateWithPriority_CB_ARGS_DATA(cb_data) { \
1209  cb_data.args.hipStreamCreateWithPriority.stream = stream; \
1210  cb_data.args.hipStreamCreateWithPriority.flags = flags; \
1211  cb_data.args.hipStreamCreateWithPriority.priority = priority; \
1212 };
1213 // hipMemcpyToSymbolAsync[('const void*', 'symbolName'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1214 #define INIT_hipMemcpyToSymbolAsync_CB_ARGS_DATA(cb_data) { \
1215 };
1216 // hipMallocPitch[('void**', 'ptr'), ('size_t*', 'pitch'), ('size_t', 'width'), ('size_t', 'height')]
1217 #define INIT_hipMallocPitch_CB_ARGS_DATA(cb_data) { \
1218  cb_data.args.hipMallocPitch.ptr = ptr; \
1219  cb_data.args.hipMallocPitch.pitch = pitch; \
1220  cb_data.args.hipMallocPitch.width = width; \
1221  cb_data.args.hipMallocPitch.height = height; \
1222 };
1223 // hipMalloc[('void**', 'ptr'), ('size_t', 'size')]
1224 #define INIT_hipMalloc_CB_ARGS_DATA(cb_data) { \
1225  cb_data.args.hipMalloc.ptr = ptr; \
1226  cb_data.args.hipMalloc.size = sizeBytes; \
1227 };
1228 // hipMemsetD16[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count')]
1229 #define INIT_hipMemsetD16_CB_ARGS_DATA(cb_data) { \
1230  cb_data.args.hipMemsetD16.dest = dst; \
1231  cb_data.args.hipMemsetD16.value = value; \
1232  cb_data.args.hipMemsetD16.count = count; \
1233 };
1234 // hipDeviceGetName[('char*', 'name'), ('int', 'len'), ('hipDevice_t', 'device')]
1235 #define INIT_hipDeviceGetName_CB_ARGS_DATA(cb_data) { \
1236  cb_data.args.hipDeviceGetName.name = name; \
1237  cb_data.args.hipDeviceGetName.len = len; \
1238  cb_data.args.hipDeviceGetName.device = device; \
1239 };
1240 // hipEventRecord[('hipEvent_t', 'event'), ('hipStream_t', 'stream')]
1241 #define INIT_hipEventRecord_CB_ARGS_DATA(cb_data) { \
1242  cb_data.args.hipEventRecord.event = event; \
1243  cb_data.args.hipEventRecord.stream = stream; \
1244 };
1245 // hipCtxSynchronize[]
1246 #define INIT_hipCtxSynchronize_CB_ARGS_DATA(cb_data) { \
1247 };
1248 // hipDrvOccupancyMaxActiveBlocksPerMultiprocessor[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk')]
1249 #define INIT_hipDrvOccupancyMaxActiveBlocksPerMultiprocessor_CB_ARGS_DATA(cb_data) { \
1250  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks = numBlocks; \
1251  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessor.f = f; \
1252  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessor.blockSize = blockSize; \
1253  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessor.dynSharedMemPerBlk = dynSharedMemPerBlk; \
1254 };
1255 // hipSetDevice[('int', 'deviceId')]
1256 #define INIT_hipSetDevice_CB_ARGS_DATA(cb_data) { \
1257  cb_data.args.hipSetDevice.deviceId = deviceId; \
1258 };
1259 // hipCtxGetApiVersion[('hipCtx_t', 'ctx'), ('int*', 'apiVersion')]
1260 #define INIT_hipCtxGetApiVersion_CB_ARGS_DATA(cb_data) { \
1261  cb_data.args.hipCtxGetApiVersion.ctx = ctx; \
1262  cb_data.args.hipCtxGetApiVersion.apiVersion = apiVersion; \
1263 };
1264 // hipSetupArgument[('const void*', 'arg'), ('size_t', 'size'), ('size_t', 'offset')]
1265 #define INIT_hipSetupArgument_CB_ARGS_DATA(cb_data) { \
1266  cb_data.args.hipSetupArgument.arg = arg; \
1267  cb_data.args.hipSetupArgument.size = size; \
1268  cb_data.args.hipSetupArgument.offset = offset; \
1269 };
1270 // hipMemcpyFromSymbolAsync[('void*', 'dst'), ('const void*', 'symbolName'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1271 #define INIT_hipMemcpyFromSymbolAsync_CB_ARGS_DATA(cb_data) { \
1272 };
1273 // hipExtGetLinkTypeAndHopCount[('int', 'device1'), ('int', 'device2'), ('unsigned int*', 'linktype'), ('unsigned int*', 'hopcount')]
1274 #define INIT_hipExtGetLinkTypeAndHopCount_CB_ARGS_DATA(cb_data) { \
1275  cb_data.args.hipExtGetLinkTypeAndHopCount.device1 = device1; \
1276  cb_data.args.hipExtGetLinkTypeAndHopCount.device2 = device2; \
1277  cb_data.args.hipExtGetLinkTypeAndHopCount.linktype = linktype; \
1278  cb_data.args.hipExtGetLinkTypeAndHopCount.hopcount = hopcount; \
1279 };
1280 // hipMemcpyDtoD[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
1281 #define INIT_hipMemcpyDtoD_CB_ARGS_DATA(cb_data) { \
1282  cb_data.args.hipMemcpyDtoD.dst = dst; \
1283  cb_data.args.hipMemcpyDtoD.src = src; \
1284  cb_data.args.hipMemcpyDtoD.sizeBytes = sizeBytes; \
1285 };
1286 // hipHostFree[('void*', 'ptr')]
1287 #define INIT_hipHostFree_CB_ARGS_DATA(cb_data) { \
1288  cb_data.args.hipHostFree.ptr = ptr; \
1289 };
1290 // hipMemcpy2DToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
1291 #define INIT_hipMemcpy2DToArray_CB_ARGS_DATA(cb_data) { \
1292  cb_data.args.hipMemcpy2DToArray.dst = dst; \
1293  cb_data.args.hipMemcpy2DToArray.wOffset = wOffset; \
1294  cb_data.args.hipMemcpy2DToArray.hOffset = hOffset; \
1295  cb_data.args.hipMemcpy2DToArray.src = src; \
1296  cb_data.args.hipMemcpy2DToArray.spitch = spitch; \
1297  cb_data.args.hipMemcpy2DToArray.width = width; \
1298  cb_data.args.hipMemcpy2DToArray.height = height; \
1299  cb_data.args.hipMemcpy2DToArray.kind = kind; \
1300 };
1301 // hipMemsetD8Async[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
1302 #define INIT_hipMemsetD8Async_CB_ARGS_DATA(cb_data) { \
1303  cb_data.args.hipMemsetD8Async.dest = dst; \
1304  cb_data.args.hipMemsetD8Async.value = value; \
1305  cb_data.args.hipMemsetD8Async.count = count; \
1306  cb_data.args.hipMemsetD8Async.stream = stream; \
1307 };
1308 // hipCtxGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
1309 #define INIT_hipCtxGetCacheConfig_CB_ARGS_DATA(cb_data) { \
1310  cb_data.args.hipCtxGetCacheConfig.cacheConfig = cacheConfig; \
1311 };
1312 // hipStreamWaitEvent[('hipStream_t', 'stream'), ('hipEvent_t', 'event'), ('unsigned int', 'flags')]
1313 #define INIT_hipStreamWaitEvent_CB_ARGS_DATA(cb_data) { \
1314  cb_data.args.hipStreamWaitEvent.stream = stream; \
1315  cb_data.args.hipStreamWaitEvent.event = event; \
1316  cb_data.args.hipStreamWaitEvent.flags = flags; \
1317 };
1318 // hipDeviceGetStreamPriorityRange[('int*', 'leastPriority'), ('int*', 'greatestPriority')]
1319 #define INIT_hipDeviceGetStreamPriorityRange_CB_ARGS_DATA(cb_data) { \
1320  cb_data.args.hipDeviceGetStreamPriorityRange.leastPriority = leastPriority; \
1321  cb_data.args.hipDeviceGetStreamPriorityRange.greatestPriority = greatestPriority; \
1322 };
1323 // hipModuleLoad[('hipModule_t*', 'module'), ('const char*', 'fname')]
1324 #define INIT_hipModuleLoad_CB_ARGS_DATA(cb_data) { \
1325  cb_data.args.hipModuleLoad.module = module; \
1326  cb_data.args.hipModuleLoad.fname = fname; \
1327 };
1328 // hipDevicePrimaryCtxSetFlags[('hipDevice_t', 'dev'), ('unsigned int', 'flags')]
1329 #define INIT_hipDevicePrimaryCtxSetFlags_CB_ARGS_DATA(cb_data) { \
1330  cb_data.args.hipDevicePrimaryCtxSetFlags.dev = dev; \
1331  cb_data.args.hipDevicePrimaryCtxSetFlags.flags = flags; \
1332 };
1333 // hipLaunchCooperativeKernel[('const void*', 'f'), ('dim3', 'gridDim'), ('dim3', 'blockDimX'), ('void**', 'kernelParams'), ('unsigned int', 'sharedMemBytes'), ('hipStream_t', 'stream')]
1334 #define INIT_hipLaunchCooperativeKernel_CB_ARGS_DATA(cb_data) { \
1335 };
1336 // hipLaunchCooperativeKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
1337 #define INIT_hipLaunchCooperativeKernelMultiDevice_CB_ARGS_DATA(cb_data) { \
1338 };
1339 // hipMemcpyAsync[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1340 #define INIT_hipMemcpyAsync_CB_ARGS_DATA(cb_data) { \
1341  cb_data.args.hipMemcpyAsync.dst = dst; \
1342  cb_data.args.hipMemcpyAsync.src = src; \
1343  cb_data.args.hipMemcpyAsync.sizeBytes = sizeBytes; \
1344  cb_data.args.hipMemcpyAsync.kind = kind; \
1345  cb_data.args.hipMemcpyAsync.stream = stream; \
1346 };
1347 // hipMalloc3DArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'flags')]
1348 #define INIT_hipMalloc3DArray_CB_ARGS_DATA(cb_data) { \
1349  cb_data.args.hipMalloc3DArray.array = array; \
1350  cb_data.args.hipMalloc3DArray.desc = desc; \
1351  cb_data.args.hipMalloc3DArray.extent = extent; \
1352  cb_data.args.hipMalloc3DArray.flags = flags; \
1353 };
1354 // hipStreamCreate[('hipStream_t*', 'stream')]
1355 #define INIT_hipStreamCreate_CB_ARGS_DATA(cb_data) { \
1356  cb_data.args.hipStreamCreate.stream = stream; \
1357 };
1358 // hipCtxGetCurrent[('hipCtx_t*', 'ctx')]
1359 #define INIT_hipCtxGetCurrent_CB_ARGS_DATA(cb_data) { \
1360  cb_data.args.hipCtxGetCurrent.ctx = ctx; \
1361 };
1362 // hipDevicePrimaryCtxGetState[('hipDevice_t', 'dev'), ('unsigned int*', 'flags'), ('int*', 'active')]
1363 #define INIT_hipDevicePrimaryCtxGetState_CB_ARGS_DATA(cb_data) { \
1364  cb_data.args.hipDevicePrimaryCtxGetState.dev = dev; \
1365  cb_data.args.hipDevicePrimaryCtxGetState.flags = flags; \
1366  cb_data.args.hipDevicePrimaryCtxGetState.active = active; \
1367 };
1368 // hipEventQuery[('hipEvent_t', 'event')]
1369 #define INIT_hipEventQuery_CB_ARGS_DATA(cb_data) { \
1370  cb_data.args.hipEventQuery.event = event; \
1371 };
1372 // hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('int*', 'numBlocks'), ('hipFunction_t', 'f'), ('int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk'), ('unsigned int', 'flags')]
1373 #define INIT_hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_CB_ARGS_DATA(cb_data) { \
1374  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks = numBlocks; \
1375  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f = f; \
1376  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize = blockSize; \
1377  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynSharedMemPerBlk = dynSharedMemPerBlk; \
1378  cb_data.args.hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags = flags; \
1379 };
1380 // hipEventCreate[('hipEvent_t*', 'event')]
1381 #define INIT_hipEventCreate_CB_ARGS_DATA(cb_data) { \
1382  cb_data.args.hipEventCreate.event = event; \
1383 };
1384 // hipMemGetAddressRange[('hipDeviceptr_t*', 'pbase'), ('size_t*', 'psize'), ('hipDeviceptr_t', 'dptr')]
1385 #define INIT_hipMemGetAddressRange_CB_ARGS_DATA(cb_data) { \
1386  cb_data.args.hipMemGetAddressRange.pbase = pbase; \
1387  cb_data.args.hipMemGetAddressRange.psize = psize; \
1388  cb_data.args.hipMemGetAddressRange.dptr = dptr; \
1389 };
1390 // hipMemcpyFromSymbol[('void*', 'dst'), ('const void*', 'symbolName'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
1391 #define INIT_hipMemcpyFromSymbol_CB_ARGS_DATA(cb_data) { \
1392 };
1393 // hipArrayCreate[('hipArray**', 'pHandle'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
1394 #define INIT_hipArrayCreate_CB_ARGS_DATA(cb_data) { \
1395  cb_data.args.hipArrayCreate.pHandle = array; \
1396  cb_data.args.hipArrayCreate.pAllocateArray = pAllocateArray; \
1397 };
1398 // hipStreamGetFlags[('hipStream_t', 'stream'), ('unsigned int*', 'flags')]
1399 #define INIT_hipStreamGetFlags_CB_ARGS_DATA(cb_data) { \
1400  cb_data.args.hipStreamGetFlags.stream = stream; \
1401  cb_data.args.hipStreamGetFlags.flags = flags; \
1402 };
1403 // hipMallocArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('size_t', 'width'), ('size_t', 'height'), ('unsigned int', 'flags')]
1404 #define INIT_hipMallocArray_CB_ARGS_DATA(cb_data) { \
1405  cb_data.args.hipMallocArray.array = array; \
1406  cb_data.args.hipMallocArray.desc = desc; \
1407  cb_data.args.hipMallocArray.width = width; \
1408  cb_data.args.hipMallocArray.height = height; \
1409  cb_data.args.hipMallocArray.flags = flags; \
1410 };
1411 // hipCtxGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
1412 #define INIT_hipCtxGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1413  cb_data.args.hipCtxGetSharedMemConfig.pConfig = pConfig; \
1414 };
1415 // hipMemPtrGetInfo[('void*', 'ptr'), ('size_t*', 'size')]
1416 #define INIT_hipMemPtrGetInfo_CB_ARGS_DATA(cb_data) { \
1417  cb_data.args.hipMemPtrGetInfo.ptr = ptr; \
1418  cb_data.args.hipMemPtrGetInfo.size = size; \
1419 };
1420 // hipFuncGetAttribute[('int*', 'value'), ('hipFunction_attribute', 'attrib'), ('hipFunction_t', 'hfunc')]
1421 #define INIT_hipFuncGetAttribute_CB_ARGS_DATA(cb_data) { \
1422  cb_data.args.hipFuncGetAttribute.value = value; \
1423  cb_data.args.hipFuncGetAttribute.attrib = attrib; \
1424  cb_data.args.hipFuncGetAttribute.hfunc = hfunc; \
1425 };
1426 // hipCtxGetFlags[('unsigned int*', 'flags')]
1427 #define INIT_hipCtxGetFlags_CB_ARGS_DATA(cb_data) { \
1428  cb_data.args.hipCtxGetFlags.flags = flags; \
1429 };
1430 // hipStreamDestroy[('hipStream_t', 'stream')]
1431 #define INIT_hipStreamDestroy_CB_ARGS_DATA(cb_data) { \
1432  cb_data.args.hipStreamDestroy.stream = stream; \
1433 };
1434 // __hipPushCallConfiguration[('dim3', 'gridDim'), ('dim3', 'blockDim'), ('size_t', 'sharedMem'), ('hipStream_t', 'stream')]
1435 #define INIT___hipPushCallConfiguration_CB_ARGS_DATA(cb_data) { \
1436 };
1437 // hipMemset3DAsync[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent'), ('hipStream_t', 'stream')]
1438 #define INIT_hipMemset3DAsync_CB_ARGS_DATA(cb_data) { \
1439  cb_data.args.hipMemset3DAsync.pitchedDevPtr = pitchedDevPtr; \
1440  cb_data.args.hipMemset3DAsync.value = value; \
1441  cb_data.args.hipMemset3DAsync.extent = extent; \
1442  cb_data.args.hipMemset3DAsync.stream = stream; \
1443 };
1444 // hipMemcpy3D[('const hipMemcpy3DParms*', 'p')]
1445 #define INIT_hipMemcpy3D_CB_ARGS_DATA(cb_data) { \
1446  cb_data.args.hipMemcpy3D.p = p; \
1447 };
1448 // hipInit[('unsigned int', 'flags')]
1449 #define INIT_hipInit_CB_ARGS_DATA(cb_data) { \
1450  cb_data.args.hipInit.flags = flags; \
1451 };
1452 // hipMemcpyAtoH[('void*', 'dst'), ('hipArray*', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'count')]
1453 #define INIT_hipMemcpyAtoH_CB_ARGS_DATA(cb_data) { \
1454  cb_data.args.hipMemcpyAtoH.dst = dst; \
1455  cb_data.args.hipMemcpyAtoH.srcArray = srcArray; \
1456  cb_data.args.hipMemcpyAtoH.srcOffset = srcOffset; \
1457  cb_data.args.hipMemcpyAtoH.count = count; \
1458 };
1459 // hipStreamGetPriority[('hipStream_t', 'stream'), ('int*', 'priority')]
1460 #define INIT_hipStreamGetPriority_CB_ARGS_DATA(cb_data) { \
1461  cb_data.args.hipStreamGetPriority.stream = stream; \
1462  cb_data.args.hipStreamGetPriority.priority = priority; \
1463 };
1464 // hipMemset2D[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height')]
1465 #define INIT_hipMemset2D_CB_ARGS_DATA(cb_data) { \
1466  cb_data.args.hipMemset2D.dst = dst; \
1467  cb_data.args.hipMemset2D.pitch = pitch; \
1468  cb_data.args.hipMemset2D.value = value; \
1469  cb_data.args.hipMemset2D.width = width; \
1470  cb_data.args.hipMemset2D.height = height; \
1471 };
1472 // hipMemset2DAsync[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height'), ('hipStream_t', 'stream')]
1473 #define INIT_hipMemset2DAsync_CB_ARGS_DATA(cb_data) { \
1474  cb_data.args.hipMemset2DAsync.dst = dst; \
1475  cb_data.args.hipMemset2DAsync.pitch = pitch; \
1476  cb_data.args.hipMemset2DAsync.value = value; \
1477  cb_data.args.hipMemset2DAsync.width = width; \
1478  cb_data.args.hipMemset2DAsync.height = height; \
1479  cb_data.args.hipMemset2DAsync.stream = stream; \
1480 };
1481 // hipDeviceCanAccessPeer[('int*', 'canAccessPeer'), ('int', 'deviceId'), ('int', 'peerDeviceId')]
1482 #define INIT_hipDeviceCanAccessPeer_CB_ARGS_DATA(cb_data) { \
1483  cb_data.args.hipDeviceCanAccessPeer.canAccessPeer = canAccessPeer; \
1484  cb_data.args.hipDeviceCanAccessPeer.deviceId = deviceId; \
1485  cb_data.args.hipDeviceCanAccessPeer.peerDeviceId = peerDeviceId; \
1486 };
1487 // hipDeviceEnablePeerAccess[('int', 'peerDeviceId'), ('unsigned int', 'flags')]
1488 #define INIT_hipDeviceEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
1489  cb_data.args.hipDeviceEnablePeerAccess.peerDeviceId = peerDeviceId; \
1490  cb_data.args.hipDeviceEnablePeerAccess.flags = flags; \
1491 };
1492 // hipLaunchKernel[('const void*', 'function_address'), ('dim3', 'numBlocks'), ('dim3', 'dimBlocks'), ('void**', 'args'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'stream')]
1493 #define INIT_hipLaunchKernel_CB_ARGS_DATA(cb_data) { \
1494  cb_data.args.hipLaunchKernel.function_address = func_addr; \
1495  cb_data.args.hipLaunchKernel.numBlocks = numBlocks; \
1496  cb_data.args.hipLaunchKernel.dimBlocks = dimBlocks; \
1497  cb_data.args.hipLaunchKernel.args = args; \
1498  cb_data.args.hipLaunchKernel.sharedMemBytes = sharedMemBytes; \
1499  cb_data.args.hipLaunchKernel.stream = stream; \
1500 };
1501 // hipMemsetD16Async[('hipDeviceptr_t', 'dest'), ('unsigned short', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
1502 #define INIT_hipMemsetD16Async_CB_ARGS_DATA(cb_data) { \
1503  cb_data.args.hipMemsetD16Async.dest = dst; \
1504  cb_data.args.hipMemsetD16Async.value = value; \
1505  cb_data.args.hipMemsetD16Async.count = count; \
1506  cb_data.args.hipMemsetD16Async.stream = stream; \
1507 };
1508 // hipModuleUnload[('hipModule_t', 'module')]
1509 #define INIT_hipModuleUnload_CB_ARGS_DATA(cb_data) { \
1510  cb_data.args.hipModuleUnload.module = hmod; \
1511 };
1512 // hipHostUnregister[('void*', 'hostPtr')]
1513 #define INIT_hipHostUnregister_CB_ARGS_DATA(cb_data) { \
1514  cb_data.args.hipHostUnregister.hostPtr = hostPtr; \
1515 };
1516 // hipProfilerStop[]
1517 #define INIT_hipProfilerStop_CB_ARGS_DATA(cb_data) { \
1518 };
1519 // hipLaunchByPtr[('const void*', 'func')]
1520 #define INIT_hipLaunchByPtr_CB_ARGS_DATA(cb_data) { \
1521  cb_data.args.hipLaunchByPtr.func = hostFunction; \
1522 };
1523 // hipStreamSynchronize[('hipStream_t', 'stream')]
1524 #define INIT_hipStreamSynchronize_CB_ARGS_DATA(cb_data) { \
1525  cb_data.args.hipStreamSynchronize.stream = stream; \
1526 };
1527 // hipDeviceSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
1528 #define INIT_hipDeviceSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1529  cb_data.args.hipDeviceSetCacheConfig.cacheConfig = cacheConfig; \
1530 };
1531 // hipGetErrorName[('hipError_t', 'hip_error')]
1532 #define INIT_hipGetErrorName_CB_ARGS_DATA(cb_data) { \
1533  cb_data.args.hipGetErrorName.hip_error = hip_error; \
1534 };
1535 // hipMemcpyHtoD[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes')]
1536 #define INIT_hipMemcpyHtoD_CB_ARGS_DATA(cb_data) { \
1537  cb_data.args.hipMemcpyHtoD.dst = dst; \
1538  cb_data.args.hipMemcpyHtoD.src = src; \
1539  cb_data.args.hipMemcpyHtoD.sizeBytes = sizeBytes; \
1540 };
1541 // hipModuleGetGlobal[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'bytes'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
1542 #define INIT_hipModuleGetGlobal_CB_ARGS_DATA(cb_data) { \
1543  cb_data.args.hipModuleGetGlobal.dptr = dptr; \
1544  cb_data.args.hipModuleGetGlobal.bytes = bytes; \
1545  cb_data.args.hipModuleGetGlobal.hmod = hmod; \
1546  cb_data.args.hipModuleGetGlobal.name = name; \
1547 };
1548 // hipMemcpyHtoA[('hipArray*', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
1549 #define INIT_hipMemcpyHtoA_CB_ARGS_DATA(cb_data) { \
1550  cb_data.args.hipMemcpyHtoA.dstArray = dstArray; \
1551  cb_data.args.hipMemcpyHtoA.dstOffset = dstOffset; \
1552  cb_data.args.hipMemcpyHtoA.srcHost = srcHost; \
1553  cb_data.args.hipMemcpyHtoA.count = count; \
1554 };
1555 // hipCtxCreate[('hipCtx_t*', 'ctx'), ('unsigned int', 'flags'), ('hipDevice_t', 'device')]
1556 #define INIT_hipCtxCreate_CB_ARGS_DATA(cb_data) { \
1557  cb_data.args.hipCtxCreate.ctx = ctx; \
1558  cb_data.args.hipCtxCreate.flags = flags; \
1559  cb_data.args.hipCtxCreate.device = device; \
1560 };
1561 // hipMemcpy2D[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
1562 #define INIT_hipMemcpy2D_CB_ARGS_DATA(cb_data) { \
1563  cb_data.args.hipMemcpy2D.dst = dst; \
1564  cb_data.args.hipMemcpy2D.dpitch = dpitch; \
1565  cb_data.args.hipMemcpy2D.src = src; \
1566  cb_data.args.hipMemcpy2D.spitch = spitch; \
1567  cb_data.args.hipMemcpy2D.width = width; \
1568  cb_data.args.hipMemcpy2D.height = height; \
1569  cb_data.args.hipMemcpy2D.kind = kind; \
1570 };
1571 // hipIpcCloseMemHandle[('void*', 'devPtr')]
1572 #define INIT_hipIpcCloseMemHandle_CB_ARGS_DATA(cb_data) { \
1573  cb_data.args.hipIpcCloseMemHandle.devPtr = devPtr; \
1574 };
1575 // hipChooseDevice[('int*', 'device'), ('const hipDeviceProp_t*', 'prop')]
1576 #define INIT_hipChooseDevice_CB_ARGS_DATA(cb_data) { \
1577  cb_data.args.hipChooseDevice.device = device; \
1578  cb_data.args.hipChooseDevice.prop = prop; \
1579 };
1580 // hipGetLastError[]
1581 #define INIT_hipGetLastError_CB_ARGS_DATA(cb_data) { \
1582 };
1583 // hipDeviceComputeCapability[('int*', 'major'), ('int*', 'minor'), ('hipDevice_t', 'device')]
1584 #define INIT_hipDeviceComputeCapability_CB_ARGS_DATA(cb_data) { \
1585  cb_data.args.hipDeviceComputeCapability.major = major; \
1586  cb_data.args.hipDeviceComputeCapability.minor = minor; \
1587  cb_data.args.hipDeviceComputeCapability.device = device; \
1588 };
1589 // hipDeviceGet[('hipDevice_t*', 'device'), ('int', 'ordinal')]
1590 #define INIT_hipDeviceGet_CB_ARGS_DATA(cb_data) { \
1591  cb_data.args.hipDeviceGet.device = device; \
1592  cb_data.args.hipDeviceGet.ordinal = deviceId; \
1593 };
1594 // hipProfilerStart[]
1595 #define INIT_hipProfilerStart_CB_ARGS_DATA(cb_data) { \
1596 };
1597 // hipCtxSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
1598 #define INIT_hipCtxSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1599  cb_data.args.hipCtxSetCacheConfig.cacheConfig = cacheConfig; \
1600 };
1601 // hipFuncSetCacheConfig[('const void*', 'func'), ('hipFuncCache_t', 'config')]
1602 #define INIT_hipFuncSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1603  cb_data.args.hipFuncSetCacheConfig.func = func; \
1604  cb_data.args.hipFuncSetCacheConfig.config = cacheConfig; \
1605 };
1606 // hipModuleGetTexRef[('textureReference**', 'texRef'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
1607 #define INIT_hipModuleGetTexRef_CB_ARGS_DATA(cb_data) { \
1608  cb_data.args.hipModuleGetTexRef.texRef = texRef; \
1609  cb_data.args.hipModuleGetTexRef.hmod = hmod; \
1610  cb_data.args.hipModuleGetTexRef.name = name; \
1611 };
1612 // hipMemcpyPeerAsync[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDevice'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1613 #define INIT_hipMemcpyPeerAsync_CB_ARGS_DATA(cb_data) { \
1614  cb_data.args.hipMemcpyPeerAsync.dst = dst; \
1615  cb_data.args.hipMemcpyPeerAsync.dstDeviceId = dstDevice; \
1616  cb_data.args.hipMemcpyPeerAsync.src = src; \
1617  cb_data.args.hipMemcpyPeerAsync.srcDevice = srcDevice; \
1618  cb_data.args.hipMemcpyPeerAsync.sizeBytes = sizeBytes; \
1619  cb_data.args.hipMemcpyPeerAsync.stream = stream; \
1620 };
1621 // hipMemcpyWithStream[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1622 #define INIT_hipMemcpyWithStream_CB_ARGS_DATA(cb_data) { \
1623  cb_data.args.hipMemcpyWithStream.dst = dst; \
1624  cb_data.args.hipMemcpyWithStream.src = src; \
1625  cb_data.args.hipMemcpyWithStream.sizeBytes = sizeBytes; \
1626  cb_data.args.hipMemcpyWithStream.kind = kind; \
1627  cb_data.args.hipMemcpyWithStream.stream = stream; \
1628 };
1629 // hipDevicePrimaryCtxReset[('hipDevice_t', 'dev')]
1630 #define INIT_hipDevicePrimaryCtxReset_CB_ARGS_DATA(cb_data) { \
1631  cb_data.args.hipDevicePrimaryCtxReset.dev = dev; \
1632 };
1633 // hipMemcpy3DAsync[('const hipMemcpy3DParms*', 'p'), ('hipStream_t', 'stream')]
1634 #define INIT_hipMemcpy3DAsync_CB_ARGS_DATA(cb_data) { \
1635  cb_data.args.hipMemcpy3DAsync.p = p; \
1636  cb_data.args.hipMemcpy3DAsync.stream = stream; \
1637 };
1638 // hipEventDestroy[('hipEvent_t', 'event')]
1639 #define INIT_hipEventDestroy_CB_ARGS_DATA(cb_data) { \
1640  cb_data.args.hipEventDestroy.event = event; \
1641 };
1642 // hipCtxPopCurrent[('hipCtx_t*', 'ctx')]
1643 #define INIT_hipCtxPopCurrent_CB_ARGS_DATA(cb_data) { \
1644  cb_data.args.hipCtxPopCurrent.ctx = ctx; \
1645 };
1646 // hipGetSymbolAddress[('void**', 'devPtr'), ('const void*', 'symbolName')]
1647 #define INIT_hipGetSymbolAddress_CB_ARGS_DATA(cb_data) { \
1648 };
1649 // hipHostGetFlags[('unsigned int*', 'flagsPtr'), ('void*', 'hostPtr')]
1650 #define INIT_hipHostGetFlags_CB_ARGS_DATA(cb_data) { \
1651  cb_data.args.hipHostGetFlags.flagsPtr = flagsPtr; \
1652  cb_data.args.hipHostGetFlags.hostPtr = hostPtr; \
1653 };
1654 // hipHostMalloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
1655 #define INIT_hipHostMalloc_CB_ARGS_DATA(cb_data) { \
1656  cb_data.args.hipHostMalloc.ptr = ptr; \
1657  cb_data.args.hipHostMalloc.size = sizeBytes; \
1658  cb_data.args.hipHostMalloc.flags = flags; \
1659 };
1660 // hipDriverGetVersion[('int*', 'driverVersion')]
1661 #define INIT_hipDriverGetVersion_CB_ARGS_DATA(cb_data) { \
1662  cb_data.args.hipDriverGetVersion.driverVersion = driverVersion; \
1663 };
1664 // hipMemGetInfo[('size_t*', 'free'), ('size_t*', 'total')]
1665 #define INIT_hipMemGetInfo_CB_ARGS_DATA(cb_data) { \
1666  cb_data.args.hipMemGetInfo.free = free; \
1667  cb_data.args.hipMemGetInfo.total = total; \
1668 };
1669 // hipDeviceReset[]
1670 #define INIT_hipDeviceReset_CB_ARGS_DATA(cb_data) { \
1671 };
1672 // hipMemset[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes')]
1673 #define INIT_hipMemset_CB_ARGS_DATA(cb_data) { \
1674  cb_data.args.hipMemset.dst = dst; \
1675  cb_data.args.hipMemset.value = value; \
1676  cb_data.args.hipMemset.sizeBytes = sizeBytes; \
1677 };
1678 // hipMemsetD8[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'count')]
1679 #define INIT_hipMemsetD8_CB_ARGS_DATA(cb_data) { \
1680  cb_data.args.hipMemsetD8.dest = dst; \
1681  cb_data.args.hipMemsetD8.value = value; \
1682  cb_data.args.hipMemsetD8.count = count; \
1683 };
1684 // hipMemcpyParam2DAsync[('const hip_Memcpy2D*', 'pCopy'), ('hipStream_t', 'stream')]
1685 #define INIT_hipMemcpyParam2DAsync_CB_ARGS_DATA(cb_data) { \
1686  cb_data.args.hipMemcpyParam2DAsync.pCopy = pCopy; \
1687  cb_data.args.hipMemcpyParam2DAsync.stream = stream; \
1688 };
1689 // hipHostRegister[('void*', 'hostPtr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
1690 #define INIT_hipHostRegister_CB_ARGS_DATA(cb_data) { \
1691  cb_data.args.hipHostRegister.hostPtr = hostPtr; \
1692  cb_data.args.hipHostRegister.sizeBytes = sizeBytes; \
1693  cb_data.args.hipHostRegister.flags = flags; \
1694 };
1695 // hipCtxSetSharedMemConfig[('hipSharedMemConfig', 'config')]
1696 #define INIT_hipCtxSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1697  cb_data.args.hipCtxSetSharedMemConfig.config = config; \
1698 };
1699 // hipArray3DCreate[('hipArray**', 'array'), ('const HIP_ARRAY3D_DESCRIPTOR*', 'pAllocateArray')]
1700 #define INIT_hipArray3DCreate_CB_ARGS_DATA(cb_data) { \
1701  cb_data.args.hipArray3DCreate.array = array; \
1702  cb_data.args.hipArray3DCreate.pAllocateArray = pAllocateArray; \
1703 };
1704 // hipIpcOpenMemHandle[('void**', 'devPtr'), ('hipIpcMemHandle_t', 'handle'), ('unsigned int', 'flags')]
1705 #define INIT_hipIpcOpenMemHandle_CB_ARGS_DATA(cb_data) { \
1706  cb_data.args.hipIpcOpenMemHandle.devPtr = devPtr; \
1707  cb_data.args.hipIpcOpenMemHandle.handle = handle; \
1708  cb_data.args.hipIpcOpenMemHandle.flags = flags; \
1709 };
1710 // hipDeviceSetSharedMemConfig[('hipSharedMemConfig', 'config')]
1711 #define INIT_hipDeviceSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1712  cb_data.args.hipDeviceSetSharedMemConfig.config = config; \
1713 };
1714 // hipCtxDestroy[('hipCtx_t', 'ctx')]
1715 #define INIT_hipCtxDestroy_CB_ARGS_DATA(cb_data) { \
1716  cb_data.args.hipCtxDestroy.ctx = ctx; \
1717 };
1718 // hipDeviceGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
1719 #define INIT_hipDeviceGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1720  cb_data.args.hipDeviceGetSharedMemConfig.pConfig = pConfig; \
1721 };
1722 // hipMemcpy2DFromArray[('void*', 'dst'), ('size_t', 'dpitch'), ('hipArray_const_t', 'src'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
1723 #define INIT_hipMemcpy2DFromArray_CB_ARGS_DATA(cb_data) { \
1724  cb_data.args.hipMemcpy2DFromArray.dst = dst; \
1725  cb_data.args.hipMemcpy2DFromArray.dpitch = dpitch; \
1726  cb_data.args.hipMemcpy2DFromArray.src = src; \
1727  cb_data.args.hipMemcpy2DFromArray.wOffset = wOffset; \
1728  cb_data.args.hipMemcpy2DFromArray.hOffset = hOffset; \
1729  cb_data.args.hipMemcpy2DFromArray.width = width; \
1730  cb_data.args.hipMemcpy2DFromArray.height = height; \
1731  cb_data.args.hipMemcpy2DFromArray.kind = kind; \
1732 };
1733 // hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags[('unsigned int*', 'numBlocks'), ('hipFunction_t', 'f'), ('unsigned int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk'), ('unsigned int', 'flags')]
1734 #define INIT_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_CB_ARGS_DATA(cb_data) { \
1735  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.numBlocks = numBlocks; \
1736  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.f = f; \
1737  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.blockSize = blockSize; \
1738  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.dynSharedMemPerBlk = dynSharedMemPerBlk; \
1739  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.flags = flags; \
1740 };
1741 // hipSetDeviceFlags[('unsigned int', 'flags')]
1742 #define INIT_hipSetDeviceFlags_CB_ARGS_DATA(cb_data) { \
1743  cb_data.args.hipSetDeviceFlags.flags = flags; \
1744 };
1745 // hipHccModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'localWorkSizeX'), ('unsigned int', 'localWorkSizeY'), ('unsigned int', 'localWorkSizeZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent')]
1746 #define INIT_hipHccModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
1747  cb_data.args.hipHccModuleLaunchKernel.f = f; \
1748  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeX = globalWorkSizeX; \
1749  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeY = globalWorkSizeY; \
1750  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeZ = globalWorkSizeZ; \
1751  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeX = localWorkSizeX; \
1752  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeY = localWorkSizeY; \
1753  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeZ = localWorkSizeZ; \
1754  cb_data.args.hipHccModuleLaunchKernel.sharedMemBytes = sharedMemBytes; \
1755  cb_data.args.hipHccModuleLaunchKernel.hStream = hStream; \
1756  cb_data.args.hipHccModuleLaunchKernel.kernelParams = kernelParams; \
1757  cb_data.args.hipHccModuleLaunchKernel.extra = extra; \
1758  cb_data.args.hipHccModuleLaunchKernel.startEvent = startEvent; \
1759  cb_data.args.hipHccModuleLaunchKernel.stopEvent = stopEvent; \
1760 };
1761 // hipFree[('void*', 'ptr')]
1762 #define INIT_hipFree_CB_ARGS_DATA(cb_data) { \
1763  cb_data.args.hipFree.ptr = ptr; \
1764 };
1765 // hipOccupancyMaxPotentialBlockSize[('unsigned int*', 'gridSize'), ('unsigned int*', 'blockSize'), ('hipFunction_t', 'f'), ('size_t', 'dynSharedMemPerBlk'), ('unsigned int', 'blockSizeLimit')]
1766 #define INIT_hipOccupancyMaxPotentialBlockSize_CB_ARGS_DATA(cb_data) { \
1767  cb_data.args.hipOccupancyMaxPotentialBlockSize.gridSize = gridSize; \
1768  cb_data.args.hipOccupancyMaxPotentialBlockSize.blockSize = blockSize; \
1769  cb_data.args.hipOccupancyMaxPotentialBlockSize.f = f; \
1770  cb_data.args.hipOccupancyMaxPotentialBlockSize.dynSharedMemPerBlk = dynSharedMemPerBlk; \
1771  cb_data.args.hipOccupancyMaxPotentialBlockSize.blockSizeLimit = blockSizeLimit; \
1772 };
1773 // hipDeviceGetAttribute[('int*', 'pi'), ('hipDeviceAttribute_t', 'attr'), ('int', 'deviceId')]
1774 #define INIT_hipDeviceGetAttribute_CB_ARGS_DATA(cb_data) { \
1775  cb_data.args.hipDeviceGetAttribute.pi = pi; \
1776  cb_data.args.hipDeviceGetAttribute.attr = attr; \
1777  cb_data.args.hipDeviceGetAttribute.deviceId = device; \
1778 };
1779 // hipMemcpyDtoH[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
1780 #define INIT_hipMemcpyDtoH_CB_ARGS_DATA(cb_data) { \
1781  cb_data.args.hipMemcpyDtoH.dst = dst; \
1782  cb_data.args.hipMemcpyDtoH.src = src; \
1783  cb_data.args.hipMemcpyDtoH.sizeBytes = sizeBytes; \
1784 };
1785 // hipCtxDisablePeerAccess[('hipCtx_t', 'peerCtx')]
1786 #define INIT_hipCtxDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
1787  cb_data.args.hipCtxDisablePeerAccess.peerCtx = peerCtx; \
1788 };
1789 // hipMallocManaged[('void**', 'devPtr'), ('size_t', 'size'), ('unsigned int', 'flags')]
1790 #define INIT_hipMallocManaged_CB_ARGS_DATA(cb_data) { \
1791  cb_data.args.hipMallocManaged.devPtr = devPtr; \
1792  cb_data.args.hipMallocManaged.size = size; \
1793  cb_data.args.hipMallocManaged.flags = flags; \
1794 };
1795 // hipDeviceGetByPCIBusId[('int*', 'device'), ('const char*', 'pciBusId')]
1796 #define INIT_hipDeviceGetByPCIBusId_CB_ARGS_DATA(cb_data) { \
1797  cb_data.args.hipDeviceGetByPCIBusId.device = device; \
1798  cb_data.args.hipDeviceGetByPCIBusId.pciBusId = pciBusId; \
1799 };
1800 // hipIpcGetMemHandle[('hipIpcMemHandle_t*', 'handle'), ('void*', 'devPtr')]
1801 #define INIT_hipIpcGetMemHandle_CB_ARGS_DATA(cb_data) { \
1802  cb_data.args.hipIpcGetMemHandle.handle = handle; \
1803  cb_data.args.hipIpcGetMemHandle.devPtr = devPtr; \
1804 };
1805 // hipMemcpyHtoDAsync[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1806 #define INIT_hipMemcpyHtoDAsync_CB_ARGS_DATA(cb_data) { \
1807  cb_data.args.hipMemcpyHtoDAsync.dst = dst; \
1808  cb_data.args.hipMemcpyHtoDAsync.src = src; \
1809  cb_data.args.hipMemcpyHtoDAsync.sizeBytes = sizeBytes; \
1810  cb_data.args.hipMemcpyHtoDAsync.stream = stream; \
1811 };
1812 // hipCtxGetDevice[('hipDevice_t*', 'device')]
1813 #define INIT_hipCtxGetDevice_CB_ARGS_DATA(cb_data) { \
1814  cb_data.args.hipCtxGetDevice.device = device; \
1815 };
1816 // hipMemset3D[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent')]
1817 #define INIT_hipMemset3D_CB_ARGS_DATA(cb_data) { \
1818  cb_data.args.hipMemset3D.pitchedDevPtr = pitchedDevPtr; \
1819  cb_data.args.hipMemset3D.value = value; \
1820  cb_data.args.hipMemset3D.extent = extent; \
1821 };
1822 // hipModuleLoadData[('hipModule_t*', 'module'), ('const void*', 'image')]
1823 #define INIT_hipModuleLoadData_CB_ARGS_DATA(cb_data) { \
1824  cb_data.args.hipModuleLoadData.module = module; \
1825  cb_data.args.hipModuleLoadData.image = image; \
1826 };
1827 // hipDeviceTotalMem[('size_t*', 'bytes'), ('hipDevice_t', 'device')]
1828 #define INIT_hipDeviceTotalMem_CB_ARGS_DATA(cb_data) { \
1829  cb_data.args.hipDeviceTotalMem.bytes = bytes; \
1830  cb_data.args.hipDeviceTotalMem.device = device; \
1831 };
1832 // hipOccupancyMaxActiveBlocksPerMultiprocessor[('unsigned int*', 'numBlocks'), ('hipFunction_t', 'f'), ('unsigned int', 'blockSize'), ('size_t', 'dynSharedMemPerBlk')]
1833 #define INIT_hipOccupancyMaxActiveBlocksPerMultiprocessor_CB_ARGS_DATA(cb_data) { \
1834  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.numBlocks = numBlocks; \
1835  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.f = f; \
1836  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.blockSize = blockSize; \
1837  cb_data.args.hipOccupancyMaxActiveBlocksPerMultiprocessor.dynSharedMemPerBlk = dynSharedMemPerBlk; \
1838 };
1839 // hipCtxSetCurrent[('hipCtx_t', 'ctx')]
1840 #define INIT_hipCtxSetCurrent_CB_ARGS_DATA(cb_data) { \
1841  cb_data.args.hipCtxSetCurrent.ctx = ctx; \
1842 };
1843 // hipGetErrorString[('hipError_t', 'hipError')]
1844 #define INIT_hipGetErrorString_CB_ARGS_DATA(cb_data) { \
1845  cb_data.args.hipGetErrorString.hipError = hip_error; \
1846 };
1847 // hipDevicePrimaryCtxRetain[('hipCtx_t*', 'pctx'), ('hipDevice_t', 'dev')]
1848 #define INIT_hipDevicePrimaryCtxRetain_CB_ARGS_DATA(cb_data) { \
1849  cb_data.args.hipDevicePrimaryCtxRetain.pctx = pctx; \
1850  cb_data.args.hipDevicePrimaryCtxRetain.dev = dev; \
1851 };
1852 // hipDeviceDisablePeerAccess[('int', 'peerDeviceId')]
1853 #define INIT_hipDeviceDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
1854  cb_data.args.hipDeviceDisablePeerAccess.peerDeviceId = peerDeviceId; \
1855 };
1856 // hipStreamCreateWithFlags[('hipStream_t*', 'stream'), ('unsigned int', 'flags')]
1857 #define INIT_hipStreamCreateWithFlags_CB_ARGS_DATA(cb_data) { \
1858  cb_data.args.hipStreamCreateWithFlags.stream = stream; \
1859  cb_data.args.hipStreamCreateWithFlags.flags = flags; \
1860 };
1861 // hipMemcpyFromArray[('void*', 'dst'), ('hipArray_const_t', 'srcArray'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
1862 #define INIT_hipMemcpyFromArray_CB_ARGS_DATA(cb_data) { \
1863  cb_data.args.hipMemcpyFromArray.dst = dst; \
1864  cb_data.args.hipMemcpyFromArray.srcArray = srcArray; \
1865  cb_data.args.hipMemcpyFromArray.wOffset = wOffset; \
1866  cb_data.args.hipMemcpyFromArray.hOffset = hOffset; \
1867  cb_data.args.hipMemcpyFromArray.count = count; \
1868  cb_data.args.hipMemcpyFromArray.kind = kind; \
1869 };
1870 // hipMemcpy2DAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1871 #define INIT_hipMemcpy2DAsync_CB_ARGS_DATA(cb_data) { \
1872  cb_data.args.hipMemcpy2DAsync.dst = dst; \
1873  cb_data.args.hipMemcpy2DAsync.dpitch = dpitch; \
1874  cb_data.args.hipMemcpy2DAsync.src = src; \
1875  cb_data.args.hipMemcpy2DAsync.spitch = spitch; \
1876  cb_data.args.hipMemcpy2DAsync.width = width; \
1877  cb_data.args.hipMemcpy2DAsync.height = height; \
1878  cb_data.args.hipMemcpy2DAsync.kind = kind; \
1879  cb_data.args.hipMemcpy2DAsync.stream = stream; \
1880 };
1881 // hipFuncGetAttributes[('hipFuncAttributes*', 'attr'), ('const void*', 'func')]
1882 #define INIT_hipFuncGetAttributes_CB_ARGS_DATA(cb_data) { \
1883  cb_data.args.hipFuncGetAttributes.attr = attr; \
1884  cb_data.args.hipFuncGetAttributes.func = func; \
1885 };
1886 // hipGetSymbolSize[('size_t*', 'size'), ('const void*', 'symbolName')]
1887 #define INIT_hipGetSymbolSize_CB_ARGS_DATA(cb_data) { \
1888 };
1889 // hipEventCreateWithFlags[('hipEvent_t*', 'event'), ('unsigned int', 'flags')]
1890 #define INIT_hipEventCreateWithFlags_CB_ARGS_DATA(cb_data) { \
1891  cb_data.args.hipEventCreateWithFlags.event = event; \
1892  cb_data.args.hipEventCreateWithFlags.flags = flags; \
1893 };
1894 // hipStreamQuery[('hipStream_t', 'stream')]
1895 #define INIT_hipStreamQuery_CB_ARGS_DATA(cb_data) { \
1896  cb_data.args.hipStreamQuery.stream = stream; \
1897 };
1898 // hipDeviceGetPCIBusId[('char*', 'pciBusId'), ('int', 'len'), ('int', 'device')]
1899 #define INIT_hipDeviceGetPCIBusId_CB_ARGS_DATA(cb_data) { \
1900  cb_data.args.hipDeviceGetPCIBusId.pciBusId = pciBusId; \
1901  cb_data.args.hipDeviceGetPCIBusId.len = len; \
1902  cb_data.args.hipDeviceGetPCIBusId.device = device; \
1903 };
1904 // hipMemcpy[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind')]
1905 #define INIT_hipMemcpy_CB_ARGS_DATA(cb_data) { \
1906  cb_data.args.hipMemcpy.dst = dst; \
1907  cb_data.args.hipMemcpy.src = src; \
1908  cb_data.args.hipMemcpy.sizeBytes = sizeBytes; \
1909  cb_data.args.hipMemcpy.kind = kind; \
1910 };
1911 // hipPeekAtLastError[]
1912 #define INIT_hipPeekAtLastError_CB_ARGS_DATA(cb_data) { \
1913 };
1914 // hipExtLaunchMultiKernelMultiDevice[('hipLaunchParams*', 'launchParamsList'), ('int', 'numDevices'), ('unsigned int', 'flags')]
1915 #define INIT_hipExtLaunchMultiKernelMultiDevice_CB_ARGS_DATA(cb_data) { \
1916 };
1917 // hipStreamAddCallback[('hipStream_t', 'stream'), ('hipStreamCallback_t', 'callback'), ('void*', 'userData'), ('unsigned int', 'flags')]
1918 #define INIT_hipStreamAddCallback_CB_ARGS_DATA(cb_data) { \
1919  cb_data.args.hipStreamAddCallback.stream = stream; \
1920  cb_data.args.hipStreamAddCallback.callback = callback; \
1921  cb_data.args.hipStreamAddCallback.userData = userData; \
1922  cb_data.args.hipStreamAddCallback.flags = flags; \
1923 };
1924 // hipMemcpyToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
1925 #define INIT_hipMemcpyToArray_CB_ARGS_DATA(cb_data) { \
1926  cb_data.args.hipMemcpyToArray.dst = dst; \
1927  cb_data.args.hipMemcpyToArray.wOffset = wOffset; \
1928  cb_data.args.hipMemcpyToArray.hOffset = hOffset; \
1929  cb_data.args.hipMemcpyToArray.src = src; \
1930  cb_data.args.hipMemcpyToArray.count = count; \
1931  cb_data.args.hipMemcpyToArray.kind = kind; \
1932 };
1933 // hipMemsetD32[('hipDeviceptr_t', 'dest'), ('int', 'value'), ('size_t', 'count')]
1934 #define INIT_hipMemsetD32_CB_ARGS_DATA(cb_data) { \
1935  cb_data.args.hipMemsetD32.dest = dst; \
1936  cb_data.args.hipMemsetD32.value = value; \
1937  cb_data.args.hipMemsetD32.count = count; \
1938 };
1939 // hipExtModuleLaunchKernel[('hipFunction_t', 'f'), ('unsigned int', 'globalWorkSizeX'), ('unsigned int', 'globalWorkSizeY'), ('unsigned int', 'globalWorkSizeZ'), ('unsigned int', 'localWorkSizeX'), ('unsigned int', 'localWorkSizeY'), ('unsigned int', 'localWorkSizeZ'), ('size_t', 'sharedMemBytes'), ('hipStream_t', 'hStream'), ('void**', 'kernelParams'), ('void**', 'extra'), ('hipEvent_t', 'startEvent'), ('hipEvent_t', 'stopEvent'), ('unsigned int', 'flags')]
1940 #define INIT_hipExtModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
1941  cb_data.args.hipExtModuleLaunchKernel.f = f; \
1942  cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeX = globalWorkSizeX; \
1943  cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeY = globalWorkSizeY; \
1944  cb_data.args.hipExtModuleLaunchKernel.globalWorkSizeZ = globalWorkSizeZ; \
1945  cb_data.args.hipExtModuleLaunchKernel.localWorkSizeX = localWorkSizeX; \
1946  cb_data.args.hipExtModuleLaunchKernel.localWorkSizeY = localWorkSizeY; \
1947  cb_data.args.hipExtModuleLaunchKernel.localWorkSizeZ = localWorkSizeZ; \
1948  cb_data.args.hipExtModuleLaunchKernel.sharedMemBytes = sharedMemBytes; \
1949  cb_data.args.hipExtModuleLaunchKernel.hStream = hStream; \
1950  cb_data.args.hipExtModuleLaunchKernel.kernelParams = kernelParams; \
1951  cb_data.args.hipExtModuleLaunchKernel.extra = extra; \
1952  cb_data.args.hipExtModuleLaunchKernel.startEvent = startEvent; \
1953  cb_data.args.hipExtModuleLaunchKernel.stopEvent = stopEvent; \
1954  cb_data.args.hipExtModuleLaunchKernel.flags = flags; \
1955 };
1956 // hipDeviceSynchronize[]
1957 #define INIT_hipDeviceSynchronize_CB_ARGS_DATA(cb_data) { \
1958 };
1959 // hipDeviceGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
1960 #define INIT_hipDeviceGetCacheConfig_CB_ARGS_DATA(cb_data) { \
1961  cb_data.args.hipDeviceGetCacheConfig.cacheConfig = cacheConfig; \
1962 };
1963 // hipMalloc3D[('hipPitchedPtr*', 'pitchedDevPtr'), ('hipExtent', 'extent')]
1964 #define INIT_hipMalloc3D_CB_ARGS_DATA(cb_data) { \
1965  cb_data.args.hipMalloc3D.pitchedDevPtr = pitchedDevPtr; \
1966  cb_data.args.hipMalloc3D.extent = extent; \
1967 };
1968 // hipPointerGetAttributes[('hipPointerAttribute_t*', 'attributes'), ('const void*', 'ptr')]
1969 #define INIT_hipPointerGetAttributes_CB_ARGS_DATA(cb_data) { \
1970  cb_data.args.hipPointerGetAttributes.attributes = attributes; \
1971  cb_data.args.hipPointerGetAttributes.ptr = ptr; \
1972 };
1973 // hipMemsetAsync[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1974 #define INIT_hipMemsetAsync_CB_ARGS_DATA(cb_data) { \
1975  cb_data.args.hipMemsetAsync.dst = dst; \
1976  cb_data.args.hipMemsetAsync.value = value; \
1977  cb_data.args.hipMemsetAsync.sizeBytes = sizeBytes; \
1978  cb_data.args.hipMemsetAsync.stream = stream; \
1979 };
1980 // hipMemcpyToSymbol[('const void*', 'symbolName'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
1981 #define INIT_hipMemcpyToSymbol_CB_ARGS_DATA(cb_data) { \
1982 };
1983 // hipCtxPushCurrent[('hipCtx_t', 'ctx')]
1984 #define INIT_hipCtxPushCurrent_CB_ARGS_DATA(cb_data) { \
1985  cb_data.args.hipCtxPushCurrent.ctx = ctx; \
1986 };
1987 // hipMemcpyPeer[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDeviceId'), ('size_t', 'sizeBytes')]
1988 #define INIT_hipMemcpyPeer_CB_ARGS_DATA(cb_data) { \
1989  cb_data.args.hipMemcpyPeer.dst = dst; \
1990  cb_data.args.hipMemcpyPeer.dstDeviceId = dstDevice; \
1991  cb_data.args.hipMemcpyPeer.src = src; \
1992  cb_data.args.hipMemcpyPeer.srcDeviceId = srcDevice; \
1993  cb_data.args.hipMemcpyPeer.sizeBytes = sizeBytes; \
1994 };
1995 // hipEventSynchronize[('hipEvent_t', 'event')]
1996 #define INIT_hipEventSynchronize_CB_ARGS_DATA(cb_data) { \
1997  cb_data.args.hipEventSynchronize.event = event; \
1998 };
1999 // hipMemcpyDtoDAsync[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
2000 #define INIT_hipMemcpyDtoDAsync_CB_ARGS_DATA(cb_data) { \
2001  cb_data.args.hipMemcpyDtoDAsync.dst = dst; \
2002  cb_data.args.hipMemcpyDtoDAsync.src = src; \
2003  cb_data.args.hipMemcpyDtoDAsync.sizeBytes = sizeBytes; \
2004  cb_data.args.hipMemcpyDtoDAsync.stream = stream; \
2005 };
2006 // hipExtMallocWithFlags[('void**', 'ptr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
2007 #define INIT_hipExtMallocWithFlags_CB_ARGS_DATA(cb_data) { \
2008  cb_data.args.hipExtMallocWithFlags.ptr = ptr; \
2009  cb_data.args.hipExtMallocWithFlags.sizeBytes = sizeBytes; \
2010  cb_data.args.hipExtMallocWithFlags.flags = flags; \
2011 };
2012 // hipCtxEnablePeerAccess[('hipCtx_t', 'peerCtx'), ('unsigned int', 'flags')]
2013 #define INIT_hipCtxEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
2014  cb_data.args.hipCtxEnablePeerAccess.peerCtx = peerCtx; \
2015  cb_data.args.hipCtxEnablePeerAccess.flags = flags; \
2016 };
2017 // hipMemcpyDtoHAsync[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
2018 #define INIT_hipMemcpyDtoHAsync_CB_ARGS_DATA(cb_data) { \
2019  cb_data.args.hipMemcpyDtoHAsync.dst = dst; \
2020  cb_data.args.hipMemcpyDtoHAsync.src = src; \
2021  cb_data.args.hipMemcpyDtoHAsync.sizeBytes = sizeBytes; \
2022  cb_data.args.hipMemcpyDtoHAsync.stream = stream; \
2023 };
2024 // 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')]
2025 #define INIT_hipModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
2026  cb_data.args.hipModuleLaunchKernel.f = f; \
2027  cb_data.args.hipModuleLaunchKernel.gridDimX = gridDimX; \
2028  cb_data.args.hipModuleLaunchKernel.gridDimY = gridDimY; \
2029  cb_data.args.hipModuleLaunchKernel.gridDimZ = gridDimZ; \
2030  cb_data.args.hipModuleLaunchKernel.blockDimX = blockDimX; \
2031  cb_data.args.hipModuleLaunchKernel.blockDimY = blockDimY; \
2032  cb_data.args.hipModuleLaunchKernel.blockDimZ = blockDimZ; \
2033  cb_data.args.hipModuleLaunchKernel.sharedMemBytes = sharedMemBytes; \
2034  cb_data.args.hipModuleLaunchKernel.stream = hStream; \
2035  cb_data.args.hipModuleLaunchKernel.kernelParams = kernelParams; \
2036  cb_data.args.hipModuleLaunchKernel.extra = extra; \
2037 };
2038 // hipMemAllocPitch[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'pitch'), ('size_t', 'widthInBytes'), ('size_t', 'height'), ('unsigned int', 'elementSizeBytes')]
2039 #define INIT_hipMemAllocPitch_CB_ARGS_DATA(cb_data) { \
2040  cb_data.args.hipMemAllocPitch.dptr = dptr; \
2041  cb_data.args.hipMemAllocPitch.pitch = pitch; \
2042  cb_data.args.hipMemAllocPitch.widthInBytes = widthInBytes; \
2043  cb_data.args.hipMemAllocPitch.height = height; \
2044  cb_data.args.hipMemAllocPitch.elementSizeBytes = elementSizeBytes; \
2045 };
2046 // 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')]
2047 #define INIT_hipMemcpy2DFromArrayAsync_CB_ARGS_DATA(cb_data) { \
2048  cb_data.args.hipMemcpy2DFromArrayAsync.dst = dst; \
2049  cb_data.args.hipMemcpy2DFromArrayAsync.dpitch = dpitch; \
2050  cb_data.args.hipMemcpy2DFromArrayAsync.src = src; \
2051  cb_data.args.hipMemcpy2DFromArrayAsync.wOffset = wOffset; \
2052  cb_data.args.hipMemcpy2DFromArrayAsync.hOffset = hOffset; \
2053  cb_data.args.hipMemcpy2DFromArrayAsync.width = width; \
2054  cb_data.args.hipMemcpy2DFromArrayAsync.height = height; \
2055  cb_data.args.hipMemcpy2DFromArrayAsync.kind = kind; \
2056  cb_data.args.hipMemcpy2DFromArrayAsync.stream = stream; \
2057 };
2058 // hipDeviceGetLimit[('size_t*', 'pValue'), ('hipLimit_t', 'limit')]
2059 #define INIT_hipDeviceGetLimit_CB_ARGS_DATA(cb_data) { \
2060  cb_data.args.hipDeviceGetLimit.pValue = pValue; \
2061  cb_data.args.hipDeviceGetLimit.limit = limit; \
2062 };
2063 // hipModuleLoadDataEx[('hipModule_t*', 'module'), ('const void*', 'image'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
2064 #define INIT_hipModuleLoadDataEx_CB_ARGS_DATA(cb_data) { \
2065  cb_data.args.hipModuleLoadDataEx.module = module; \
2066  cb_data.args.hipModuleLoadDataEx.image = image; \
2067  cb_data.args.hipModuleLoadDataEx.numOptions = numOptions; \
2068  cb_data.args.hipModuleLoadDataEx.options = options; \
2069  cb_data.args.hipModuleLoadDataEx.optionValues = optionValues; \
2070 };
2071 // hipRuntimeGetVersion[('int*', 'runtimeVersion')]
2072 #define INIT_hipRuntimeGetVersion_CB_ARGS_DATA(cb_data) { \
2073  cb_data.args.hipRuntimeGetVersion.runtimeVersion = runtimeVersion; \
2074 };
2075 // __hipPopCallConfiguration[('dim3', '*gridDim'), ('dim3', '*blockDim'), ('size_t', '*sharedMem'), ('hipStream_t', '*stream')]
2076 #define INIT___hipPopCallConfiguration_CB_ARGS_DATA(cb_data) { \
2077 };
2078 // hipGetDeviceProperties[('hipDeviceProp_t*', 'prop'), ('int', 'deviceId')]
2079 #define INIT_hipGetDeviceProperties_CB_ARGS_DATA(cb_data) { \
2080  cb_data.args.hipGetDeviceProperties.prop = props; \
2081  cb_data.args.hipGetDeviceProperties.deviceId = device; \
2082 };
2083 // hipFreeArray[('hipArray*', 'array')]
2084 #define INIT_hipFreeArray_CB_ARGS_DATA(cb_data) { \
2085  cb_data.args.hipFreeArray.array = array; \
2086 };
2087 // hipEventElapsedTime[('float*', 'ms'), ('hipEvent_t', 'start'), ('hipEvent_t', 'stop')]
2088 #define INIT_hipEventElapsedTime_CB_ARGS_DATA(cb_data) { \
2089  cb_data.args.hipEventElapsedTime.ms = ms; \
2090  cb_data.args.hipEventElapsedTime.start = start; \
2091  cb_data.args.hipEventElapsedTime.stop = stop; \
2092 };
2093 // hipDevicePrimaryCtxRelease[('hipDevice_t', 'dev')]
2094 #define INIT_hipDevicePrimaryCtxRelease_CB_ARGS_DATA(cb_data) { \
2095  cb_data.args.hipDevicePrimaryCtxRelease.dev = dev; \
2096 };
2097 // hipHostGetDevicePointer[('void**', 'devPtr'), ('void*', 'hstPtr'), ('unsigned int', 'flags')]
2098 #define INIT_hipHostGetDevicePointer_CB_ARGS_DATA(cb_data) { \
2099  cb_data.args.hipHostGetDevicePointer.devPtr = devicePointer; \
2100  cb_data.args.hipHostGetDevicePointer.hstPtr = hostPointer; \
2101  cb_data.args.hipHostGetDevicePointer.flags = flags; \
2102 };
2103 // hipMemcpyParam2D[('const hip_Memcpy2D*', 'pCopy')]
2104 #define INIT_hipMemcpyParam2D_CB_ARGS_DATA(cb_data) { \
2105  cb_data.args.hipMemcpyParam2D.pCopy = pCopy; \
2106 };
2107 // hipModuleGetFunction[('hipFunction_t*', 'function'), ('hipModule_t', 'module'), ('const char*', 'kname')]
2108 #define INIT_hipModuleGetFunction_CB_ARGS_DATA(cb_data) { \
2109  cb_data.args.hipModuleGetFunction.function = hfunc; \
2110  cb_data.args.hipModuleGetFunction.module = hmod; \
2111  cb_data.args.hipModuleGetFunction.kname = name; \
2112 };
2113 // hipMemsetD32Async[('hipDeviceptr_t', 'dst'), ('int', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
2114 #define INIT_hipMemsetD32Async_CB_ARGS_DATA(cb_data) { \
2115  cb_data.args.hipMemsetD32Async.dst = dst; \
2116  cb_data.args.hipMemsetD32Async.value = value; \
2117  cb_data.args.hipMemsetD32Async.count = count; \
2118  cb_data.args.hipMemsetD32Async.stream = stream; \
2119 };
2120 // hipGetDevice[('int*', 'deviceId')]
2121 #define INIT_hipGetDevice_CB_ARGS_DATA(cb_data) { \
2122  cb_data.args.hipGetDevice.deviceId = deviceId; \
2123 };
2124 // hipGetDeviceCount[('int*', 'count')]
2125 #define INIT_hipGetDeviceCount_CB_ARGS_DATA(cb_data) { \
2126  cb_data.args.hipGetDeviceCount.count = count; \
2127 };
2128 #define INIT_CB_ARGS_DATA(cb_id, cb_data) INIT_##cb_id##_CB_ARGS_DATA(cb_data)
2129 #endif // _HIP_PROF_STR_H
Definition: hip_runtime_api.h:283
Definition: driver_types.h:241
Definition: hip_runtime_api.h:151
Definition: hip_module.cpp:108
Definition: hip_runtime_api.h:121
Definition: hip_hcc_internal.h:910
Definition: texture_types.h:74
Definition: driver_types.h:78
hipDeviceAttribute_t
Definition: hip_runtime_api.h:279
Definition: hip_runtime_api.h:274
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition: hip_runtime_api.h:848
Definition: driver_types.h:69
Definition: driver_types.h:254
Definition: driver_types.h:62
Definition: driver_types.h:234
hipFuncCache_t
Definition: hip_runtime_api.h:250
Definition: hip_runtime_api.h:83
hipSharedMemConfig
Definition: hip_runtime_api.h:261
Definition: driver_types.h:38
Definition: hip_hcc_internal.h:732
Definition: hip_hcc_internal.h:556
Definition: driver_types.h:91
Definition: hip_runtime_api.h:106
Definition: hip_hcc_internal.h:405
Definition: hip_prof_str.h:411