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