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