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 #include <sstream>
5 #include <string>
6 
7 // Dummy API primitives
8 #define INIT_NONE_CB_ARGS_DATA(cb_data) {};
9 #define INIT_hipModuleGetFunctionEx_CB_ARGS_DATA(cb_data) {};
10 #define INIT_hipTexRefSetAddress_CB_ARGS_DATA(cb_data) {};
11 #define INIT_hipBindTexture2D_CB_ARGS_DATA(cb_data) {};
12 #define INIT_hipCreateTextureObject_CB_ARGS_DATA(cb_data) {};
13 #define INIT_hipBindTextureToArray_CB_ARGS_DATA(cb_data) {};
14 #define INIT_hipTexRefSetFormat_CB_ARGS_DATA(cb_data) {};
15 #define INIT_hipMemcpyHtoH_CB_ARGS_DATA(cb_data) {};
16 #define INIT_hipHccGetAcceleratorView_CB_ARGS_DATA(cb_data) {};
17 #define INIT_hipDestroyTextureObject_CB_ARGS_DATA(cb_data) {};
18 #define INIT_hipTexRefSetArray_CB_ARGS_DATA(cb_data) {};
19 #define INIT_hipBindTextureToMipmappedArray_CB_ARGS_DATA(cb_data) {};
20 #define INIT_hipTexRefSetAddress2D_CB_ARGS_DATA(cb_data) {};
21 #define INIT_hipGetTextureObjectResourceViewDesc_CB_ARGS_DATA(cb_data) {};
22 #define INIT_hipUnbindTexture_CB_ARGS_DATA(cb_data) {};
23 #define INIT_hipTexRefSetFilterMode_CB_ARGS_DATA(cb_data) {};
24 #define INIT_hipCreateSurfaceObject_CB_ARGS_DATA(cb_data) {};
25 #define INIT_hipGetChannelDesc_CB_ARGS_DATA(cb_data) {};
26 #define INIT_hipGetTextureObjectResourceDesc_CB_ARGS_DATA(cb_data) {};
27 #define INIT_hipExtModuleLaunchKernel_CB_ARGS_DATA(cb_data) {};
28 #define INIT_hipGetTextureAlignmentOffset_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_hipTexRefSetAddressMode_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_hipGetTextureObjectTextureDesc_CB_ARGS_DATA(cb_data) {};
36 
37 // HIP API callbacks ID enumaration
38 enum hip_api_id_t {
39  HIP_API_ID_hipStreamCreateWithPriority = 0,
40  HIP_API_ID_hipMemcpyToSymbolAsync = 1,
41  HIP_API_ID_hipMallocPitch = 2,
42  HIP_API_ID_hipMalloc = 3,
43  HIP_API_ID_hipDeviceGetName = 4,
44  HIP_API_ID_hipEventRecord = 5,
45  HIP_API_ID_hipCtxSynchronize = 6,
46  HIP_API_ID_hipSetDevice = 7,
47  HIP_API_ID_hipCtxGetApiVersion = 8,
48  HIP_API_ID_hipSetupArgument = 9,
49  HIP_API_ID_hipMemcpyFromSymbolAsync = 10,
50  HIP_API_ID_hipExtGetLinkTypeAndHopCount = 11,
51  HIP_API_ID_hipMemcpyDtoD = 12,
52  HIP_API_ID_hipHostFree = 13,
53  HIP_API_ID_hipMemcpy2DToArray = 14,
54  HIP_API_ID_hipCtxGetCacheConfig = 15,
55  HIP_API_ID_hipStreamWaitEvent = 16,
56  HIP_API_ID_hipDeviceGetStreamPriorityRange = 17,
57  HIP_API_ID_hipModuleLoad = 18,
58  HIP_API_ID_hipDevicePrimaryCtxSetFlags = 19,
59  HIP_API_ID_hipMemcpyAsync = 20,
60  HIP_API_ID_hipMalloc3DArray = 21,
61  HIP_API_ID_hipStreamCreate = 22,
62  HIP_API_ID_hipCtxGetCurrent = 23,
63  HIP_API_ID_hipDevicePrimaryCtxGetState = 24,
64  HIP_API_ID_hipEventQuery = 25,
65  HIP_API_ID_hipEventCreate = 26,
66  HIP_API_ID_hipMemGetAddressRange = 27,
67  HIP_API_ID_hipMemcpyFromSymbol = 28,
68  HIP_API_ID_hipArrayCreate = 29,
69  HIP_API_ID_hipStreamGetFlags = 30,
70  HIP_API_ID_hipMallocArray = 31,
71  HIP_API_ID_hipCtxGetSharedMemConfig = 32,
72  HIP_API_ID_hipMemPtrGetInfo = 33,
73  HIP_API_ID_hipCtxGetFlags = 34,
74  HIP_API_ID_hipStreamDestroy = 35,
75  HIP_API_ID_hipMemset3DAsync = 36,
76  HIP_API_ID_hipMemcpy3D = 37,
77  HIP_API_ID_hipInit = 38,
78  HIP_API_ID_hipMemcpyAtoH = 39,
79  HIP_API_ID_hipStreamGetPriority = 40,
80  HIP_API_ID_hipMemset2D = 41,
81  HIP_API_ID_hipMemset2DAsync = 42,
82  HIP_API_ID_hipDeviceCanAccessPeer = 43,
83  HIP_API_ID_hipDeviceEnablePeerAccess = 44,
84  HIP_API_ID_hipModuleUnload = 45,
85  HIP_API_ID_hipHostUnregister = 46,
86  HIP_API_ID_hipProfilerStop = 47,
87  HIP_API_ID_hipLaunchByPtr = 48,
88  HIP_API_ID_hipStreamSynchronize = 49,
89  HIP_API_ID_hipDeviceSetCacheConfig = 50,
90  HIP_API_ID_hipGetErrorName = 51,
91  HIP_API_ID_hipMemcpyHtoD = 52,
92  HIP_API_ID_hipModuleGetGlobal = 53,
93  HIP_API_ID_hipMemcpyHtoA = 54,
94  HIP_API_ID_hipCtxCreate = 55,
95  HIP_API_ID_hipMemcpy2D = 56,
96  HIP_API_ID_hipIpcCloseMemHandle = 57,
97  HIP_API_ID_hipChooseDevice = 58,
98  HIP_API_ID_hipDeviceSetSharedMemConfig = 59,
99  HIP_API_ID_hipDeviceComputeCapability = 60,
100  HIP_API_ID_hipDeviceGet = 61,
101  HIP_API_ID_hipProfilerStart = 62,
102  HIP_API_ID_hipCtxSetCacheConfig = 63,
103  HIP_API_ID_hipFuncSetCacheConfig = 64,
104  HIP_API_ID_hipMemcpyPeerAsync = 65,
105  HIP_API_ID_hipEventElapsedTime = 66,
106  HIP_API_ID_hipDevicePrimaryCtxReset = 67,
107  HIP_API_ID_hipEventDestroy = 68,
108  HIP_API_ID_hipCtxPopCurrent = 69,
109  HIP_API_ID_hipGetSymbolAddress = 70,
110  HIP_API_ID_hipHostGetFlags = 71,
111  HIP_API_ID_hipHostMalloc = 72,
112  HIP_API_ID_hipDriverGetVersion = 73,
113  HIP_API_ID_hipMemGetInfo = 74,
114  HIP_API_ID_hipDeviceReset = 75,
115  HIP_API_ID_hipMemset = 76,
116  HIP_API_ID_hipMemsetD8 = 77,
117  HIP_API_ID_hipHostRegister = 78,
118  HIP_API_ID_hipCtxSetSharedMemConfig = 79,
119  HIP_API_ID_hipArray3DCreate = 80,
120  HIP_API_ID_hipIpcOpenMemHandle = 81,
121  HIP_API_ID_hipGetLastError = 82,
122  HIP_API_ID_hipCtxDestroy = 83,
123  HIP_API_ID_hipDeviceGetSharedMemConfig = 84,
124  HIP_API_ID_hipSetDeviceFlags = 85,
125  HIP_API_ID_hipHccModuleLaunchKernel = 86,
126  HIP_API_ID_hipFree = 87,
127  HIP_API_ID_hipDeviceGetAttribute = 88,
128  HIP_API_ID_hipMemcpyDtoH = 89,
129  HIP_API_ID_hipCtxDisablePeerAccess = 90,
130  HIP_API_ID_hipMallocManaged = 91,
131  HIP_API_ID_hipDeviceGetByPCIBusId = 92,
132  HIP_API_ID_hipIpcGetMemHandle = 93,
133  HIP_API_ID_hipMemcpyHtoDAsync = 94,
134  HIP_API_ID_hipCtxGetDevice = 95,
135  HIP_API_ID_hipMemset3D = 96,
136  HIP_API_ID_hipModuleLoadData = 97,
137  HIP_API_ID_hipDeviceTotalMem = 98,
138  HIP_API_ID_hipCtxSetCurrent = 99,
139  HIP_API_ID_hipGetErrorString = 100,
140  HIP_API_ID_hipDevicePrimaryCtxRetain = 101,
141  HIP_API_ID_hipDeviceDisablePeerAccess = 102,
142  HIP_API_ID_hipStreamCreateWithFlags = 103,
143  HIP_API_ID_hipMemcpyFromArray = 104,
144  HIP_API_ID_hipMemcpy2DAsync = 105,
145  HIP_API_ID_hipGetSymbolSize = 106,
146  HIP_API_ID_hipEventCreateWithFlags = 107,
147  HIP_API_ID_hipStreamQuery = 108,
148  HIP_API_ID_hipDeviceGetPCIBusId = 109,
149  HIP_API_ID_hipMemcpy = 110,
150  HIP_API_ID_hipPeekAtLastError = 111,
151  HIP_API_ID_hipStreamAddCallback = 112,
152  HIP_API_ID_hipMemcpyToArray = 113,
153  HIP_API_ID_hipMemsetD32 = 114,
154  HIP_API_ID_hipDeviceSynchronize = 115,
155  HIP_API_ID_hipDeviceGetCacheConfig = 116,
156  HIP_API_ID_hipMalloc3D = 117,
157  HIP_API_ID_hipPointerGetAttributes = 118,
158  HIP_API_ID_hipMemsetAsync = 119,
159  HIP_API_ID_hipMemcpyToSymbol = 120,
160  HIP_API_ID_hipCtxPushCurrent = 121,
161  HIP_API_ID_hipMemcpyPeer = 122,
162  HIP_API_ID_hipEventSynchronize = 123,
163  HIP_API_ID_hipMemcpyDtoDAsync = 124,
164  HIP_API_ID_hipExtMallocWithFlags = 125,
165  HIP_API_ID_hipCtxEnablePeerAccess = 126,
166  HIP_API_ID_hipMemcpyDtoHAsync = 127,
167  HIP_API_ID_hipModuleLaunchKernel = 128,
168  HIP_API_ID_hipModuleGetTexRef = 129,
169  HIP_API_ID_hipDeviceGetLimit = 130,
170  HIP_API_ID_hipModuleLoadDataEx = 131,
171  HIP_API_ID_hipRuntimeGetVersion = 132,
172  HIP_API_ID_hipGetDeviceProperties = 133,
173  HIP_API_ID_hipFreeArray = 134,
174  HIP_API_ID_hipDevicePrimaryCtxRelease = 135,
175  HIP_API_ID_hipHostGetDevicePointer = 136,
176  HIP_API_ID_hipMemcpyParam2D = 137,
177  HIP_API_ID_hipModuleGetFunction = 138,
178  HIP_API_ID_hipMemsetD32Async = 139,
179  HIP_API_ID_hipGetDevice = 140,
180  HIP_API_ID_hipGetDeviceCount = 141,
181  HIP_API_ID_NUMBER = 142,
182  HIP_API_ID_ANY = 143,
183 
184  HIP_API_ID_NONE = HIP_API_ID_NUMBER,
185  HIP_API_ID_hipModuleGetFunctionEx = HIP_API_ID_NUMBER,
186  HIP_API_ID_hipTexRefSetAddress = HIP_API_ID_NUMBER,
187  HIP_API_ID_hipBindTexture2D = HIP_API_ID_NUMBER,
188  HIP_API_ID_hipCreateTextureObject = HIP_API_ID_NUMBER,
189  HIP_API_ID_hipBindTextureToArray = HIP_API_ID_NUMBER,
190  HIP_API_ID_hipTexRefSetFormat = HIP_API_ID_NUMBER,
191  HIP_API_ID_hipMemcpyHtoH = HIP_API_ID_NUMBER,
192  HIP_API_ID_hipHccGetAcceleratorView = HIP_API_ID_NUMBER,
193  HIP_API_ID_hipDestroyTextureObject = HIP_API_ID_NUMBER,
194  HIP_API_ID_hipTexRefSetArray = HIP_API_ID_NUMBER,
195  HIP_API_ID_hipBindTextureToMipmappedArray = HIP_API_ID_NUMBER,
196  HIP_API_ID_hipTexRefSetAddress2D = HIP_API_ID_NUMBER,
197  HIP_API_ID_hipGetTextureObjectResourceViewDesc = HIP_API_ID_NUMBER,
198  HIP_API_ID_hipUnbindTexture = HIP_API_ID_NUMBER,
199  HIP_API_ID_hipTexRefSetFilterMode = HIP_API_ID_NUMBER,
200  HIP_API_ID_hipCreateSurfaceObject = HIP_API_ID_NUMBER,
201  HIP_API_ID_hipGetChannelDesc = HIP_API_ID_NUMBER,
202  HIP_API_ID_hipGetTextureObjectResourceDesc = HIP_API_ID_NUMBER,
203  HIP_API_ID_hipExtModuleLaunchKernel = HIP_API_ID_NUMBER,
204  HIP_API_ID_hipGetTextureAlignmentOffset = HIP_API_ID_NUMBER,
205  HIP_API_ID_hipDestroySurfaceObject = HIP_API_ID_NUMBER,
206  HIP_API_ID_hipGetTextureReference = HIP_API_ID_NUMBER,
207  HIP_API_ID_hipTexRefSetAddressMode = HIP_API_ID_NUMBER,
208  HIP_API_ID_hipTexRefSetFlags = HIP_API_ID_NUMBER,
209  HIP_API_ID_hipBindTexture = HIP_API_ID_NUMBER,
210  HIP_API_ID_hipHccGetAccelerator = HIP_API_ID_NUMBER,
211  HIP_API_ID_hipGetTextureObjectTextureDesc = HIP_API_ID_NUMBER,
212 };
213 
214 // Return HIP API string
215 static const char* hip_api_name(const uint32_t& id) {
216  switch(id) {
217  case HIP_API_ID_hipStreamCreateWithPriority: return "hipStreamCreateWithPriority";
218  case HIP_API_ID_hipMemcpyToSymbolAsync: return "hipMemcpyToSymbolAsync";
219  case HIP_API_ID_hipMallocPitch: return "hipMallocPitch";
220  case HIP_API_ID_hipMalloc: return "hipMalloc";
221  case HIP_API_ID_hipDeviceGetName: return "hipDeviceGetName";
222  case HIP_API_ID_hipEventRecord: return "hipEventRecord";
223  case HIP_API_ID_hipCtxSynchronize: return "hipCtxSynchronize";
224  case HIP_API_ID_hipSetDevice: return "hipSetDevice";
225  case HIP_API_ID_hipCtxGetApiVersion: return "hipCtxGetApiVersion";
226  case HIP_API_ID_hipSetupArgument: return "hipSetupArgument";
227  case HIP_API_ID_hipMemcpyFromSymbolAsync: return "hipMemcpyFromSymbolAsync";
228  case HIP_API_ID_hipExtGetLinkTypeAndHopCount: return "hipExtGetLinkTypeAndHopCount";
229  case HIP_API_ID_hipMemcpyDtoD: return "hipMemcpyDtoD";
230  case HIP_API_ID_hipHostFree: return "hipHostFree";
231  case HIP_API_ID_hipMemcpy2DToArray: return "hipMemcpy2DToArray";
232  case HIP_API_ID_hipCtxGetCacheConfig: return "hipCtxGetCacheConfig";
233  case HIP_API_ID_hipStreamWaitEvent: return "hipStreamWaitEvent";
234  case HIP_API_ID_hipDeviceGetStreamPriorityRange: return "hipDeviceGetStreamPriorityRange";
235  case HIP_API_ID_hipModuleLoad: return "hipModuleLoad";
236  case HIP_API_ID_hipDevicePrimaryCtxSetFlags: return "hipDevicePrimaryCtxSetFlags";
237  case HIP_API_ID_hipMemcpyAsync: return "hipMemcpyAsync";
238  case HIP_API_ID_hipMalloc3DArray: return "hipMalloc3DArray";
239  case HIP_API_ID_hipStreamCreate: return "hipStreamCreate";
240  case HIP_API_ID_hipCtxGetCurrent: return "hipCtxGetCurrent";
241  case HIP_API_ID_hipDevicePrimaryCtxGetState: return "hipDevicePrimaryCtxGetState";
242  case HIP_API_ID_hipEventQuery: return "hipEventQuery";
243  case HIP_API_ID_hipEventCreate: return "hipEventCreate";
244  case HIP_API_ID_hipMemGetAddressRange: return "hipMemGetAddressRange";
245  case HIP_API_ID_hipMemcpyFromSymbol: return "hipMemcpyFromSymbol";
246  case HIP_API_ID_hipArrayCreate: return "hipArrayCreate";
247  case HIP_API_ID_hipStreamGetFlags: return "hipStreamGetFlags";
248  case HIP_API_ID_hipMallocArray: return "hipMallocArray";
249  case HIP_API_ID_hipCtxGetSharedMemConfig: return "hipCtxGetSharedMemConfig";
250  case HIP_API_ID_hipMemPtrGetInfo: return "hipMemPtrGetInfo";
251  case HIP_API_ID_hipCtxGetFlags: return "hipCtxGetFlags";
252  case HIP_API_ID_hipStreamDestroy: return "hipStreamDestroy";
253  case HIP_API_ID_hipMemset3DAsync: return "hipMemset3DAsync";
254  case HIP_API_ID_hipMemcpy3D: return "hipMemcpy3D";
255  case HIP_API_ID_hipInit: return "hipInit";
256  case HIP_API_ID_hipMemcpyAtoH: return "hipMemcpyAtoH";
257  case HIP_API_ID_hipStreamGetPriority: return "hipStreamGetPriority";
258  case HIP_API_ID_hipMemset2D: return "hipMemset2D";
259  case HIP_API_ID_hipMemset2DAsync: return "hipMemset2DAsync";
260  case HIP_API_ID_hipDeviceCanAccessPeer: return "hipDeviceCanAccessPeer";
261  case HIP_API_ID_hipDeviceEnablePeerAccess: return "hipDeviceEnablePeerAccess";
262  case HIP_API_ID_hipModuleUnload: return "hipModuleUnload";
263  case HIP_API_ID_hipHostUnregister: return "hipHostUnregister";
264  case HIP_API_ID_hipProfilerStop: return "hipProfilerStop";
265  case HIP_API_ID_hipLaunchByPtr: return "hipLaunchByPtr";
266  case HIP_API_ID_hipStreamSynchronize: return "hipStreamSynchronize";
267  case HIP_API_ID_hipDeviceSetCacheConfig: return "hipDeviceSetCacheConfig";
268  case HIP_API_ID_hipGetErrorName: return "hipGetErrorName";
269  case HIP_API_ID_hipMemcpyHtoD: return "hipMemcpyHtoD";
270  case HIP_API_ID_hipModuleGetGlobal: return "hipModuleGetGlobal";
271  case HIP_API_ID_hipMemcpyHtoA: return "hipMemcpyHtoA";
272  case HIP_API_ID_hipCtxCreate: return "hipCtxCreate";
273  case HIP_API_ID_hipMemcpy2D: return "hipMemcpy2D";
274  case HIP_API_ID_hipIpcCloseMemHandle: return "hipIpcCloseMemHandle";
275  case HIP_API_ID_hipChooseDevice: return "hipChooseDevice";
276  case HIP_API_ID_hipDeviceSetSharedMemConfig: return "hipDeviceSetSharedMemConfig";
277  case HIP_API_ID_hipDeviceComputeCapability: return "hipDeviceComputeCapability";
278  case HIP_API_ID_hipDeviceGet: return "hipDeviceGet";
279  case HIP_API_ID_hipProfilerStart: return "hipProfilerStart";
280  case HIP_API_ID_hipCtxSetCacheConfig: return "hipCtxSetCacheConfig";
281  case HIP_API_ID_hipFuncSetCacheConfig: return "hipFuncSetCacheConfig";
282  case HIP_API_ID_hipMemcpyPeerAsync: return "hipMemcpyPeerAsync";
283  case HIP_API_ID_hipEventElapsedTime: return "hipEventElapsedTime";
284  case HIP_API_ID_hipDevicePrimaryCtxReset: return "hipDevicePrimaryCtxReset";
285  case HIP_API_ID_hipEventDestroy: return "hipEventDestroy";
286  case HIP_API_ID_hipCtxPopCurrent: return "hipCtxPopCurrent";
287  case HIP_API_ID_hipGetSymbolAddress: return "hipGetSymbolAddress";
288  case HIP_API_ID_hipHostGetFlags: return "hipHostGetFlags";
289  case HIP_API_ID_hipHostMalloc: return "hipHostMalloc";
290  case HIP_API_ID_hipDriverGetVersion: return "hipDriverGetVersion";
291  case HIP_API_ID_hipMemGetInfo: return "hipMemGetInfo";
292  case HIP_API_ID_hipDeviceReset: return "hipDeviceReset";
293  case HIP_API_ID_hipMemset: return "hipMemset";
294  case HIP_API_ID_hipMemsetD8: return "hipMemsetD8";
295  case HIP_API_ID_hipHostRegister: return "hipHostRegister";
296  case HIP_API_ID_hipCtxSetSharedMemConfig: return "hipCtxSetSharedMemConfig";
297  case HIP_API_ID_hipArray3DCreate: return "hipArray3DCreate";
298  case HIP_API_ID_hipIpcOpenMemHandle: return "hipIpcOpenMemHandle";
299  case HIP_API_ID_hipGetLastError: return "hipGetLastError";
300  case HIP_API_ID_hipCtxDestroy: return "hipCtxDestroy";
301  case HIP_API_ID_hipDeviceGetSharedMemConfig: return "hipDeviceGetSharedMemConfig";
302  case HIP_API_ID_hipSetDeviceFlags: return "hipSetDeviceFlags";
303  case HIP_API_ID_hipHccModuleLaunchKernel: return "hipHccModuleLaunchKernel";
304  case HIP_API_ID_hipFree: return "hipFree";
305  case HIP_API_ID_hipDeviceGetAttribute: return "hipDeviceGetAttribute";
306  case HIP_API_ID_hipMemcpyDtoH: return "hipMemcpyDtoH";
307  case HIP_API_ID_hipCtxDisablePeerAccess: return "hipCtxDisablePeerAccess";
308  case HIP_API_ID_hipMallocManaged: return "hipMallocManaged";
309  case HIP_API_ID_hipDeviceGetByPCIBusId: return "hipDeviceGetByPCIBusId";
310  case HIP_API_ID_hipIpcGetMemHandle: return "hipIpcGetMemHandle";
311  case HIP_API_ID_hipMemcpyHtoDAsync: return "hipMemcpyHtoDAsync";
312  case HIP_API_ID_hipCtxGetDevice: return "hipCtxGetDevice";
313  case HIP_API_ID_hipMemset3D: return "hipMemset3D";
314  case HIP_API_ID_hipModuleLoadData: return "hipModuleLoadData";
315  case HIP_API_ID_hipDeviceTotalMem: return "hipDeviceTotalMem";
316  case HIP_API_ID_hipCtxSetCurrent: return "hipCtxSetCurrent";
317  case HIP_API_ID_hipGetErrorString: return "hipGetErrorString";
318  case HIP_API_ID_hipDevicePrimaryCtxRetain: return "hipDevicePrimaryCtxRetain";
319  case HIP_API_ID_hipDeviceDisablePeerAccess: return "hipDeviceDisablePeerAccess";
320  case HIP_API_ID_hipStreamCreateWithFlags: return "hipStreamCreateWithFlags";
321  case HIP_API_ID_hipMemcpyFromArray: return "hipMemcpyFromArray";
322  case HIP_API_ID_hipMemcpy2DAsync: return "hipMemcpy2DAsync";
323  case HIP_API_ID_hipGetSymbolSize: return "hipGetSymbolSize";
324  case HIP_API_ID_hipEventCreateWithFlags: return "hipEventCreateWithFlags";
325  case HIP_API_ID_hipStreamQuery: return "hipStreamQuery";
326  case HIP_API_ID_hipDeviceGetPCIBusId: return "hipDeviceGetPCIBusId";
327  case HIP_API_ID_hipMemcpy: return "hipMemcpy";
328  case HIP_API_ID_hipPeekAtLastError: return "hipPeekAtLastError";
329  case HIP_API_ID_hipStreamAddCallback: return "hipStreamAddCallback";
330  case HIP_API_ID_hipMemcpyToArray: return "hipMemcpyToArray";
331  case HIP_API_ID_hipMemsetD32: return "hipMemsetD32";
332  case HIP_API_ID_hipDeviceSynchronize: return "hipDeviceSynchronize";
333  case HIP_API_ID_hipDeviceGetCacheConfig: return "hipDeviceGetCacheConfig";
334  case HIP_API_ID_hipMalloc3D: return "hipMalloc3D";
335  case HIP_API_ID_hipPointerGetAttributes: return "hipPointerGetAttributes";
336  case HIP_API_ID_hipMemsetAsync: return "hipMemsetAsync";
337  case HIP_API_ID_hipMemcpyToSymbol: return "hipMemcpyToSymbol";
338  case HIP_API_ID_hipCtxPushCurrent: return "hipCtxPushCurrent";
339  case HIP_API_ID_hipMemcpyPeer: return "hipMemcpyPeer";
340  case HIP_API_ID_hipEventSynchronize: return "hipEventSynchronize";
341  case HIP_API_ID_hipMemcpyDtoDAsync: return "hipMemcpyDtoDAsync";
342  case HIP_API_ID_hipExtMallocWithFlags: return "hipExtMallocWithFlags";
343  case HIP_API_ID_hipCtxEnablePeerAccess: return "hipCtxEnablePeerAccess";
344  case HIP_API_ID_hipMemcpyDtoHAsync: return "hipMemcpyDtoHAsync";
345  case HIP_API_ID_hipModuleLaunchKernel: return "hipModuleLaunchKernel";
346  case HIP_API_ID_hipModuleGetTexRef: return "hipModuleGetTexRef";
347  case HIP_API_ID_hipDeviceGetLimit: return "hipDeviceGetLimit";
348  case HIP_API_ID_hipModuleLoadDataEx: return "hipModuleLoadDataEx";
349  case HIP_API_ID_hipRuntimeGetVersion: return "hipRuntimeGetVersion";
350  case HIP_API_ID_hipGetDeviceProperties: return "hipGetDeviceProperties";
351  case HIP_API_ID_hipFreeArray: return "hipFreeArray";
352  case HIP_API_ID_hipDevicePrimaryCtxRelease: return "hipDevicePrimaryCtxRelease";
353  case HIP_API_ID_hipHostGetDevicePointer: return "hipHostGetDevicePointer";
354  case HIP_API_ID_hipMemcpyParam2D: return "hipMemcpyParam2D";
355  case HIP_API_ID_hipModuleGetFunction: return "hipModuleGetFunction";
356  case HIP_API_ID_hipMemsetD32Async: return "hipMemsetD32Async";
357  case HIP_API_ID_hipGetDevice: return "hipGetDevice";
358  case HIP_API_ID_hipGetDeviceCount: return "hipGetDeviceCount";
359  };
360  return "unknown";
361 };
362 
363 // HIP API callbacks data structure
364 struct hip_api_data_t {
365  uint64_t correlation_id;
366  uint32_t phase;
367  union {
368  struct {
369  hipStream_t* stream;
370  unsigned int flags;
371  int priority;
372  } hipStreamCreateWithPriority;
373  struct {
374  const void* symbolName;
375  const void* src;
376  size_t sizeBytes;
377  size_t offset;
378  hipMemcpyKind kind;
379  hipStream_t stream;
380  } hipMemcpyToSymbolAsync;
381  struct {
382  void** ptr;
383  size_t* pitch;
384  size_t width;
385  size_t height;
386  } hipMallocPitch;
387  struct {
388  void** ptr;
389  size_t size;
390  } hipMalloc;
391  struct {
392  char* name;
393  int len;
394  hipDevice_t device;
395  } hipDeviceGetName;
396  struct {
397  hipEvent_t event;
398  hipStream_t stream;
399  } hipEventRecord;
400  struct {
401  int deviceId;
402  } hipSetDevice;
403  struct {
404  hipCtx_t ctx;
405  int* apiVersion;
406  } hipCtxGetApiVersion;
407  struct {
408  const void* arg;
409  size_t size;
410  size_t offset;
411  } hipSetupArgument;
412  struct {
413  void* dst;
414  const void* symbolName;
415  size_t sizeBytes;
416  size_t offset;
417  hipMemcpyKind kind;
418  hipStream_t stream;
419  } hipMemcpyFromSymbolAsync;
420  struct {
421  int device1;
422  int device2;
423  unsigned int* linktype;
424  unsigned int* hopcount;
425  } hipExtGetLinkTypeAndHopCount;
426  struct {
427  hipDeviceptr_t dst;
428  hipDeviceptr_t src;
429  size_t sizeBytes;
430  } hipMemcpyDtoD;
431  struct {
432  void* ptr;
433  } hipHostFree;
434  struct {
435  hipArray* dst;
436  size_t wOffset;
437  size_t hOffset;
438  const void* src;
439  size_t spitch;
440  size_t width;
441  size_t height;
442  hipMemcpyKind kind;
443  } hipMemcpy2DToArray;
444  struct {
445  hipFuncCache_t* cacheConfig;
446  } hipCtxGetCacheConfig;
447  struct {
448  hipStream_t stream;
449  hipEvent_t event;
450  unsigned int flags;
451  } hipStreamWaitEvent;
452  struct {
453  int* leastPriority;
454  int* greatestPriority;
455  } hipDeviceGetStreamPriorityRange;
456  struct {
457  hipModule_t* module;
458  const char* fname;
459  } hipModuleLoad;
460  struct {
461  hipDevice_t dev;
462  unsigned int flags;
463  } hipDevicePrimaryCtxSetFlags;
464  struct {
465  void* dst;
466  const void* src;
467  size_t sizeBytes;
468  hipMemcpyKind kind;
469  hipStream_t stream;
470  } hipMemcpyAsync;
471  struct {
472  hipArray** array;
473  const hipChannelFormatDesc* desc;
474  hipExtent extent;
475  unsigned int flags;
476  } hipMalloc3DArray;
477  struct {
478  hipStream_t* stream;
479  } hipStreamCreate;
480  struct {
481  hipCtx_t* ctx;
482  } hipCtxGetCurrent;
483  struct {
484  hipDevice_t dev;
485  unsigned int* flags;
486  int* active;
487  } hipDevicePrimaryCtxGetState;
488  struct {
489  hipEvent_t event;
490  } hipEventQuery;
491  struct {
492  hipEvent_t* event;
493  } hipEventCreate;
494  struct {
495  hipDeviceptr_t* pbase;
496  size_t* psize;
497  hipDeviceptr_t dptr;
498  } hipMemGetAddressRange;
499  struct {
500  void* dst;
501  const void* symbolName;
502  size_t sizeBytes;
503  size_t offset;
504  hipMemcpyKind kind;
505  } hipMemcpyFromSymbol;
506  struct {
507  hipArray** pHandle;
508  const HIP_ARRAY_DESCRIPTOR* pAllocateArray;
509  } hipArrayCreate;
510  struct {
511  hipStream_t stream;
512  unsigned int* flags;
513  } hipStreamGetFlags;
514  struct {
515  hipArray** array;
516  const hipChannelFormatDesc* desc;
517  size_t width;
518  size_t height;
519  unsigned int flags;
520  } hipMallocArray;
521  struct {
522  hipSharedMemConfig* pConfig;
523  } hipCtxGetSharedMemConfig;
524  struct {
525  void* ptr;
526  size_t* size;
527  } hipMemPtrGetInfo;
528  struct {
529  unsigned int* flags;
530  } hipCtxGetFlags;
531  struct {
532  hipStream_t stream;
533  } hipStreamDestroy;
534  struct {
535  hipPitchedPtr pitchedDevPtr;
536  int value;
537  hipExtent extent;
538  hipStream_t stream;
539  } hipMemset3DAsync;
540  struct {
541  const hipMemcpy3DParms* p;
542  } hipMemcpy3D;
543  struct {
544  unsigned int flags;
545  } hipInit;
546  struct {
547  void* dst;
548  hipArray* srcArray;
549  size_t srcOffset;
550  size_t count;
551  } hipMemcpyAtoH;
552  struct {
553  hipStream_t stream;
554  int* priority;
555  } hipStreamGetPriority;
556  struct {
557  void* dst;
558  size_t pitch;
559  int value;
560  size_t width;
561  size_t height;
562  } hipMemset2D;
563  struct {
564  void* dst;
565  size_t pitch;
566  int value;
567  size_t width;
568  size_t height;
569  hipStream_t stream;
570  } hipMemset2DAsync;
571  struct {
572  int* canAccessPeer;
573  int deviceId;
574  int peerDeviceId;
575  } hipDeviceCanAccessPeer;
576  struct {
577  int peerDeviceId;
578  unsigned int flags;
579  } hipDeviceEnablePeerAccess;
580  struct {
581  hipModule_t module;
582  } hipModuleUnload;
583  struct {
584  void* hostPtr;
585  } hipHostUnregister;
586  struct {
587  const void* func;
588  } hipLaunchByPtr;
589  struct {
590  hipStream_t stream;
591  } hipStreamSynchronize;
592  struct {
593  hipFuncCache_t cacheConfig;
594  } hipDeviceSetCacheConfig;
595  struct {
596  hipError_t hip_error;
597  } hipGetErrorName;
598  struct {
599  hipDeviceptr_t dst;
600  void* src;
601  size_t sizeBytes;
602  } hipMemcpyHtoD;
603  struct {
604  hipDeviceptr_t* dptr;
605  size_t* bytes;
606  hipModule_t hmod;
607  const char* name;
608  } hipModuleGetGlobal;
609  struct {
610  hipArray* dstArray;
611  size_t dstOffset;
612  const void* srcHost;
613  size_t count;
614  } hipMemcpyHtoA;
615  struct {
616  hipCtx_t* ctx;
617  unsigned int flags;
618  hipDevice_t device;
619  } hipCtxCreate;
620  struct {
621  void* dst;
622  size_t dpitch;
623  const void* src;
624  size_t spitch;
625  size_t width;
626  size_t height;
627  hipMemcpyKind kind;
628  } hipMemcpy2D;
629  struct {
630  void* devPtr;
631  } hipIpcCloseMemHandle;
632  struct {
633  int* device;
634  const hipDeviceProp_t* prop;
635  } hipChooseDevice;
636  struct {
637  hipSharedMemConfig config;
638  } hipDeviceSetSharedMemConfig;
639  struct {
640  int* major;
641  int* minor;
642  hipDevice_t device;
643  } hipDeviceComputeCapability;
644  struct {
645  hipDevice_t* device;
646  int ordinal;
647  } hipDeviceGet;
648  struct {
649  hipFuncCache_t cacheConfig;
650  } hipCtxSetCacheConfig;
651  struct {
652  const void* func;
653  hipFuncCache_t config;
654  } hipFuncSetCacheConfig;
655  struct {
656  void* dst;
657  int dstDeviceId;
658  const void* src;
659  int srcDevice;
660  size_t sizeBytes;
661  hipStream_t stream;
662  } hipMemcpyPeerAsync;
663  struct {
664  float* ms;
665  hipEvent_t start;
666  hipEvent_t stop;
667  } hipEventElapsedTime;
668  struct {
669  hipDevice_t dev;
670  } hipDevicePrimaryCtxReset;
671  struct {
672  hipEvent_t event;
673  } hipEventDestroy;
674  struct {
675  hipCtx_t* ctx;
676  } hipCtxPopCurrent;
677  struct {
678  void** devPtr;
679  const void* symbolName;
680  } hipGetSymbolAddress;
681  struct {
682  unsigned int* flagsPtr;
683  void* hostPtr;
684  } hipHostGetFlags;
685  struct {
686  void** ptr;
687  size_t size;
688  unsigned int flags;
689  } hipHostMalloc;
690  struct {
691  int* driverVersion;
692  } hipDriverGetVersion;
693  struct {
694  size_t* free;
695  size_t* total;
696  } hipMemGetInfo;
697  struct {
698  void* dst;
699  int value;
700  size_t sizeBytes;
701  } hipMemset;
702  struct {
703  hipDeviceptr_t dest;
704  unsigned char value;
705  size_t sizeBytes;
706  } hipMemsetD8;
707  struct {
708  void* hostPtr;
709  size_t sizeBytes;
710  unsigned int flags;
711  } hipHostRegister;
712  struct {
713  hipSharedMemConfig config;
714  } hipCtxSetSharedMemConfig;
715  struct {
716  hipArray** array;
717  const HIP_ARRAY_DESCRIPTOR* pAllocateArray;
718  } hipArray3DCreate;
719  struct {
720  void** devPtr;
721  hipIpcMemHandle_t handle;
722  unsigned int flags;
723  } hipIpcOpenMemHandle;
724  struct {
725  hipCtx_t ctx;
726  } hipCtxDestroy;
727  struct {
728  hipSharedMemConfig* pConfig;
729  } hipDeviceGetSharedMemConfig;
730  struct {
731  unsigned int flags;
732  } hipSetDeviceFlags;
733  struct {
734  hipFunction_t f;
735  unsigned int globalWorkSizeX;
736  unsigned int globalWorkSizeY;
737  unsigned int globalWorkSizeZ;
738  unsigned int localWorkSizeX;
739  unsigned int localWorkSizeY;
740  unsigned int localWorkSizeZ;
741  size_t sharedMemBytes;
742  hipStream_t hStream;
743  void** kernelParams;
744  void** extra;
745  hipEvent_t startEvent;
746  hipEvent_t stopEvent;
747  } hipHccModuleLaunchKernel;
748  struct {
749  void* ptr;
750  } hipFree;
751  struct {
752  int* pi;
753  hipDeviceAttribute_t attr;
754  int deviceId;
755  } hipDeviceGetAttribute;
756  struct {
757  void* dst;
758  hipDeviceptr_t src;
759  size_t sizeBytes;
760  } hipMemcpyDtoH;
761  struct {
762  hipCtx_t peerCtx;
763  } hipCtxDisablePeerAccess;
764  struct {
765  void** devPtr;
766  size_t size;
767  unsigned int flags;
768  } hipMallocManaged;
769  struct {
770  int* device;
771  const char* pciBusId;
772  } hipDeviceGetByPCIBusId;
773  struct {
774  hipIpcMemHandle_t* handle;
775  void* devPtr;
776  } hipIpcGetMemHandle;
777  struct {
778  hipDeviceptr_t dst;
779  void* src;
780  size_t sizeBytes;
781  hipStream_t stream;
782  } hipMemcpyHtoDAsync;
783  struct {
784  hipDevice_t* device;
785  } hipCtxGetDevice;
786  struct {
787  hipPitchedPtr pitchedDevPtr;
788  int value;
789  hipExtent extent;
790  } hipMemset3D;
791  struct {
792  hipModule_t* module;
793  const void* image;
794  } hipModuleLoadData;
795  struct {
796  size_t* bytes;
797  hipDevice_t device;
798  } hipDeviceTotalMem;
799  struct {
800  hipCtx_t ctx;
801  } hipCtxSetCurrent;
802  struct {
803  hipError_t hipError;
804  } hipGetErrorString;
805  struct {
806  hipCtx_t* pctx;
807  hipDevice_t dev;
808  } hipDevicePrimaryCtxRetain;
809  struct {
810  int peerDeviceId;
811  } hipDeviceDisablePeerAccess;
812  struct {
813  hipStream_t* stream;
814  unsigned int flags;
815  } hipStreamCreateWithFlags;
816  struct {
817  void* dst;
818  hipArray_const_t srcArray;
819  size_t wOffset;
820  size_t hOffset;
821  size_t count;
822  hipMemcpyKind kind;
823  } hipMemcpyFromArray;
824  struct {
825  void* dst;
826  size_t dpitch;
827  const void* src;
828  size_t spitch;
829  size_t width;
830  size_t height;
831  hipMemcpyKind kind;
832  hipStream_t stream;
833  } hipMemcpy2DAsync;
834  struct {
835  size_t* size;
836  const void* symbolName;
837  } hipGetSymbolSize;
838  struct {
839  hipEvent_t* event;
840  unsigned int flags;
841  } hipEventCreateWithFlags;
842  struct {
843  hipStream_t stream;
844  } hipStreamQuery;
845  struct {
846  char* pciBusId;
847  int len;
848  int device;
849  } hipDeviceGetPCIBusId;
850  struct {
851  void* dst;
852  const void* src;
853  size_t sizeBytes;
854  hipMemcpyKind kind;
855  } hipMemcpy;
856  struct {
857  hipStream_t stream;
858  hipStreamCallback_t callback;
859  void* userData;
860  unsigned int flags;
861  } hipStreamAddCallback;
862  struct {
863  hipArray* dst;
864  size_t wOffset;
865  size_t hOffset;
866  const void* src;
867  size_t count;
868  hipMemcpyKind kind;
869  } hipMemcpyToArray;
870  struct {
871  hipDeviceptr_t dest;
872  int value;
873  size_t count;
874  } hipMemsetD32;
875  struct {
876  hipFuncCache_t* cacheConfig;
877  } hipDeviceGetCacheConfig;
878  struct {
879  hipPitchedPtr* pitchedDevPtr;
880  hipExtent extent;
881  } hipMalloc3D;
882  struct {
883  hipPointerAttribute_t* attributes;
884  const void* ptr;
885  } hipPointerGetAttributes;
886  struct {
887  void* dst;
888  int value;
889  size_t sizeBytes;
890  hipStream_t stream;
891  } hipMemsetAsync;
892  struct {
893  const void* symbolName;
894  const void* src;
895  size_t sizeBytes;
896  size_t offset;
897  hipMemcpyKind kind;
898  } hipMemcpyToSymbol;
899  struct {
900  hipCtx_t ctx;
901  } hipCtxPushCurrent;
902  struct {
903  void* dst;
904  int dstDeviceId;
905  const void* src;
906  int srcDeviceId;
907  size_t sizeBytes;
908  } hipMemcpyPeer;
909  struct {
910  hipEvent_t event;
911  } hipEventSynchronize;
912  struct {
913  hipDeviceptr_t dst;
914  hipDeviceptr_t src;
915  size_t sizeBytes;
916  hipStream_t stream;
917  } hipMemcpyDtoDAsync;
918  struct {
919  void** ptr;
920  size_t sizeBytes;
921  unsigned int flags;
922  } hipExtMallocWithFlags;
923  struct {
924  hipCtx_t peerCtx;
925  unsigned int flags;
926  } hipCtxEnablePeerAccess;
927  struct {
928  void* dst;
929  hipDeviceptr_t src;
930  size_t sizeBytes;
931  hipStream_t stream;
932  } hipMemcpyDtoHAsync;
933  struct {
934  hipFunction_t f;
935  unsigned int gridDimX;
936  unsigned int gridDimY;
937  unsigned int gridDimZ;
938  unsigned int blockDimX;
939  unsigned int blockDimY;
940  unsigned int blockDimZ;
941  unsigned int sharedMemBytes;
942  hipStream_t stream;
943  void** kernelParams;
944  void** extra;
945  } hipModuleLaunchKernel;
946  struct {
947  textureReference** texRef;
948  hipModule_t hmod;
949  const char* name;
950  } hipModuleGetTexRef;
951  struct {
952  size_t* pValue;
953  hipLimit_t limit;
954  } hipDeviceGetLimit;
955  struct {
956  hipModule_t* module;
957  const void* image;
958  unsigned int numOptions;
959  hipJitOption* options;
960  void** optionValues;
961  } hipModuleLoadDataEx;
962  struct {
963  int* runtimeVersion;
964  } hipRuntimeGetVersion;
965  struct {
966  hipDeviceProp_t* prop;
967  int deviceId;
968  } hipGetDeviceProperties;
969  struct {
970  hipArray* array;
971  } hipFreeArray;
972  struct {
973  hipDevice_t dev;
974  } hipDevicePrimaryCtxRelease;
975  struct {
976  void** devPtr;
977  void* hstPtr;
978  unsigned int flags;
979  } hipHostGetDevicePointer;
980  struct {
981  const hip_Memcpy2D* pCopy;
982  } hipMemcpyParam2D;
983  struct {
984  hipFunction_t* function;
985  hipModule_t module;
986  const char* kname;
987  } hipModuleGetFunction;
988  struct {
989  hipDeviceptr_t dst;
990  int value;
991  size_t count;
992  hipStream_t stream;
993  } hipMemsetD32Async;
994  struct {
995  int* deviceId;
996  } hipGetDevice;
997  struct {
998  int* count;
999  } hipGetDeviceCount;
1000  } args;
1001 };
1002 
1003 // HIP API callbacks args data filling macros
1004 // hipStreamCreateWithPriority[('hipStream_t*', 'stream'), ('unsigned int', 'flags'), ('int', 'priority')]
1005 #define INIT_hipStreamCreateWithPriority_CB_ARGS_DATA(cb_data) { \
1006  cb_data.args.hipStreamCreateWithPriority.stream = stream; \
1007  cb_data.args.hipStreamCreateWithPriority.flags = flags; \
1008  cb_data.args.hipStreamCreateWithPriority.priority = priority; \
1009 };
1010 // hipMemcpyToSymbolAsync[('const void*', 'symbolName'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1011 #define INIT_hipMemcpyToSymbolAsync_CB_ARGS_DATA(cb_data) { \
1012 };
1013 // hipMallocPitch[('void**', 'ptr'), ('size_t*', 'pitch'), ('size_t', 'width'), ('size_t', 'height')]
1014 #define INIT_hipMallocPitch_CB_ARGS_DATA(cb_data) { \
1015  cb_data.args.hipMallocPitch.ptr = ptr; \
1016  cb_data.args.hipMallocPitch.pitch = pitch; \
1017  cb_data.args.hipMallocPitch.width = width; \
1018  cb_data.args.hipMallocPitch.height = height; \
1019 };
1020 // hipMalloc[('void**', 'ptr'), ('size_t', 'size')]
1021 #define INIT_hipMalloc_CB_ARGS_DATA(cb_data) { \
1022  cb_data.args.hipMalloc.ptr = ptr; \
1023  cb_data.args.hipMalloc.size = sizeBytes; \
1024 };
1025 // hipDeviceGetName[('char*', 'name'), ('int', 'len'), ('hipDevice_t', 'device')]
1026 #define INIT_hipDeviceGetName_CB_ARGS_DATA(cb_data) { \
1027  cb_data.args.hipDeviceGetName.name = name; \
1028  cb_data.args.hipDeviceGetName.len = len; \
1029  cb_data.args.hipDeviceGetName.device = device; \
1030 };
1031 // hipEventRecord[('hipEvent_t', 'event'), ('hipStream_t', 'stream')]
1032 #define INIT_hipEventRecord_CB_ARGS_DATA(cb_data) { \
1033  cb_data.args.hipEventRecord.event = event; \
1034  cb_data.args.hipEventRecord.stream = stream; \
1035 };
1036 // hipCtxSynchronize[]
1037 #define INIT_hipCtxSynchronize_CB_ARGS_DATA(cb_data) { \
1038 };
1039 // hipSetDevice[('int', 'deviceId')]
1040 #define INIT_hipSetDevice_CB_ARGS_DATA(cb_data) { \
1041  cb_data.args.hipSetDevice.deviceId = deviceId; \
1042 };
1043 // hipCtxGetApiVersion[('hipCtx_t', 'ctx'), ('int*', 'apiVersion')]
1044 #define INIT_hipCtxGetApiVersion_CB_ARGS_DATA(cb_data) { \
1045  cb_data.args.hipCtxGetApiVersion.ctx = ctx; \
1046  cb_data.args.hipCtxGetApiVersion.apiVersion = apiVersion; \
1047 };
1048 // hipSetupArgument[('const void*', 'arg'), ('size_t', 'size'), ('size_t', 'offset')]
1049 #define INIT_hipSetupArgument_CB_ARGS_DATA(cb_data) { \
1050  cb_data.args.hipSetupArgument.arg = arg; \
1051  cb_data.args.hipSetupArgument.size = size; \
1052  cb_data.args.hipSetupArgument.offset = offset; \
1053 };
1054 // hipMemcpyFromSymbolAsync[('void*', 'dst'), ('const void*', 'symbolName'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1055 #define INIT_hipMemcpyFromSymbolAsync_CB_ARGS_DATA(cb_data) { \
1056 };
1057 // hipExtGetLinkTypeAndHopCount[('int', 'device1'), ('int', 'device2'), ('unsigned int*', 'linktype'), ('unsigned int*', 'hopcount')]
1058 #define INIT_hipExtGetLinkTypeAndHopCount_CB_ARGS_DATA(cb_data) { \
1059  cb_data.args.hipExtGetLinkTypeAndHopCount.device1 = device1; \
1060  cb_data.args.hipExtGetLinkTypeAndHopCount.device2 = device2; \
1061  cb_data.args.hipExtGetLinkTypeAndHopCount.linktype = linktype; \
1062  cb_data.args.hipExtGetLinkTypeAndHopCount.hopcount = hopcount; \
1063 };
1064 // hipMemcpyDtoD[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
1065 #define INIT_hipMemcpyDtoD_CB_ARGS_DATA(cb_data) { \
1066  cb_data.args.hipMemcpyDtoD.dst = dst; \
1067  cb_data.args.hipMemcpyDtoD.src = src; \
1068  cb_data.args.hipMemcpyDtoD.sizeBytes = sizeBytes; \
1069 };
1070 // hipHostFree[('void*', 'ptr')]
1071 #define INIT_hipHostFree_CB_ARGS_DATA(cb_data) { \
1072  cb_data.args.hipHostFree.ptr = ptr; \
1073 };
1074 // hipMemcpy2DToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
1075 #define INIT_hipMemcpy2DToArray_CB_ARGS_DATA(cb_data) { \
1076  cb_data.args.hipMemcpy2DToArray.dst = dst; \
1077  cb_data.args.hipMemcpy2DToArray.wOffset = wOffset; \
1078  cb_data.args.hipMemcpy2DToArray.hOffset = hOffset; \
1079  cb_data.args.hipMemcpy2DToArray.src = src; \
1080  cb_data.args.hipMemcpy2DToArray.spitch = spitch; \
1081  cb_data.args.hipMemcpy2DToArray.width = width; \
1082  cb_data.args.hipMemcpy2DToArray.height = height; \
1083  cb_data.args.hipMemcpy2DToArray.kind = kind; \
1084 };
1085 // hipCtxGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
1086 #define INIT_hipCtxGetCacheConfig_CB_ARGS_DATA(cb_data) { \
1087  cb_data.args.hipCtxGetCacheConfig.cacheConfig = cacheConfig; \
1088 };
1089 // hipStreamWaitEvent[('hipStream_t', 'stream'), ('hipEvent_t', 'event'), ('unsigned int', 'flags')]
1090 #define INIT_hipStreamWaitEvent_CB_ARGS_DATA(cb_data) { \
1091  cb_data.args.hipStreamWaitEvent.stream = stream; \
1092  cb_data.args.hipStreamWaitEvent.event = event; \
1093  cb_data.args.hipStreamWaitEvent.flags = flags; \
1094 };
1095 // hipDeviceGetStreamPriorityRange[('int*', 'leastPriority'), ('int*', 'greatestPriority')]
1096 #define INIT_hipDeviceGetStreamPriorityRange_CB_ARGS_DATA(cb_data) { \
1097  cb_data.args.hipDeviceGetStreamPriorityRange.leastPriority = leastPriority; \
1098  cb_data.args.hipDeviceGetStreamPriorityRange.greatestPriority = greatestPriority; \
1099 };
1100 // hipModuleLoad[('hipModule_t*', 'module'), ('const char*', 'fname')]
1101 #define INIT_hipModuleLoad_CB_ARGS_DATA(cb_data) { \
1102  cb_data.args.hipModuleLoad.module = module; \
1103  cb_data.args.hipModuleLoad.fname = fname; \
1104 };
1105 // hipDevicePrimaryCtxSetFlags[('hipDevice_t', 'dev'), ('unsigned int', 'flags')]
1106 #define INIT_hipDevicePrimaryCtxSetFlags_CB_ARGS_DATA(cb_data) { \
1107  cb_data.args.hipDevicePrimaryCtxSetFlags.dev = dev; \
1108  cb_data.args.hipDevicePrimaryCtxSetFlags.flags = flags; \
1109 };
1110 // hipMemcpyAsync[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1111 #define INIT_hipMemcpyAsync_CB_ARGS_DATA(cb_data) { \
1112  cb_data.args.hipMemcpyAsync.dst = dst; \
1113  cb_data.args.hipMemcpyAsync.src = src; \
1114  cb_data.args.hipMemcpyAsync.sizeBytes = sizeBytes; \
1115  cb_data.args.hipMemcpyAsync.kind = kind; \
1116  cb_data.args.hipMemcpyAsync.stream = stream; \
1117 };
1118 // hipMalloc3DArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('hipExtent', 'extent'), ('unsigned int', 'flags')]
1119 #define INIT_hipMalloc3DArray_CB_ARGS_DATA(cb_data) { \
1120  cb_data.args.hipMalloc3DArray.array = array; \
1121  cb_data.args.hipMalloc3DArray.desc = desc; \
1122  cb_data.args.hipMalloc3DArray.extent = extent; \
1123  cb_data.args.hipMalloc3DArray.flags = flags; \
1124 };
1125 // hipStreamCreate[('hipStream_t*', 'stream')]
1126 #define INIT_hipStreamCreate_CB_ARGS_DATA(cb_data) { \
1127  cb_data.args.hipStreamCreate.stream = stream; \
1128 };
1129 // hipCtxGetCurrent[('hipCtx_t*', 'ctx')]
1130 #define INIT_hipCtxGetCurrent_CB_ARGS_DATA(cb_data) { \
1131  cb_data.args.hipCtxGetCurrent.ctx = ctx; \
1132 };
1133 // hipDevicePrimaryCtxGetState[('hipDevice_t', 'dev'), ('unsigned int*', 'flags'), ('int*', 'active')]
1134 #define INIT_hipDevicePrimaryCtxGetState_CB_ARGS_DATA(cb_data) { \
1135  cb_data.args.hipDevicePrimaryCtxGetState.dev = dev; \
1136  cb_data.args.hipDevicePrimaryCtxGetState.flags = flags; \
1137  cb_data.args.hipDevicePrimaryCtxGetState.active = active; \
1138 };
1139 // hipEventQuery[('hipEvent_t', 'event')]
1140 #define INIT_hipEventQuery_CB_ARGS_DATA(cb_data) { \
1141  cb_data.args.hipEventQuery.event = event; \
1142 };
1143 // hipEventCreate[('hipEvent_t*', 'event')]
1144 #define INIT_hipEventCreate_CB_ARGS_DATA(cb_data) { \
1145  cb_data.args.hipEventCreate.event = event; \
1146 };
1147 // hipMemGetAddressRange[('hipDeviceptr_t*', 'pbase'), ('size_t*', 'psize'), ('hipDeviceptr_t', 'dptr')]
1148 #define INIT_hipMemGetAddressRange_CB_ARGS_DATA(cb_data) { \
1149  cb_data.args.hipMemGetAddressRange.pbase = pbase; \
1150  cb_data.args.hipMemGetAddressRange.psize = psize; \
1151  cb_data.args.hipMemGetAddressRange.dptr = dptr; \
1152 };
1153 // hipMemcpyFromSymbol[('void*', 'dst'), ('const void*', 'symbolName'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
1154 #define INIT_hipMemcpyFromSymbol_CB_ARGS_DATA(cb_data) { \
1155 };
1156 // hipArrayCreate[('hipArray**', 'pHandle'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
1157 #define INIT_hipArrayCreate_CB_ARGS_DATA(cb_data) { \
1158  cb_data.args.hipArrayCreate.pHandle = array; \
1159  cb_data.args.hipArrayCreate.pAllocateArray = pAllocateArray; \
1160 };
1161 // hipStreamGetFlags[('hipStream_t', 'stream'), ('unsigned int*', 'flags')]
1162 #define INIT_hipStreamGetFlags_CB_ARGS_DATA(cb_data) { \
1163  cb_data.args.hipStreamGetFlags.stream = stream; \
1164  cb_data.args.hipStreamGetFlags.flags = flags; \
1165 };
1166 // hipMallocArray[('hipArray**', 'array'), ('const hipChannelFormatDesc*', 'desc'), ('size_t', 'width'), ('size_t', 'height'), ('unsigned int', 'flags')]
1167 #define INIT_hipMallocArray_CB_ARGS_DATA(cb_data) { \
1168  cb_data.args.hipMallocArray.array = array; \
1169  cb_data.args.hipMallocArray.desc = desc; \
1170  cb_data.args.hipMallocArray.width = width; \
1171  cb_data.args.hipMallocArray.height = height; \
1172  cb_data.args.hipMallocArray.flags = flags; \
1173 };
1174 // hipCtxGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
1175 #define INIT_hipCtxGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1176  cb_data.args.hipCtxGetSharedMemConfig.pConfig = pConfig; \
1177 };
1178 // hipMemPtrGetInfo[('void*', 'ptr'), ('size_t*', 'size')]
1179 #define INIT_hipMemPtrGetInfo_CB_ARGS_DATA(cb_data) { \
1180  cb_data.args.hipMemPtrGetInfo.ptr = ptr; \
1181  cb_data.args.hipMemPtrGetInfo.size = size; \
1182 };
1183 // hipCtxGetFlags[('unsigned int*', 'flags')]
1184 #define INIT_hipCtxGetFlags_CB_ARGS_DATA(cb_data) { \
1185  cb_data.args.hipCtxGetFlags.flags = flags; \
1186 };
1187 // hipStreamDestroy[('hipStream_t', 'stream')]
1188 #define INIT_hipStreamDestroy_CB_ARGS_DATA(cb_data) { \
1189  cb_data.args.hipStreamDestroy.stream = stream; \
1190 };
1191 // hipMemset3DAsync[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent'), ('hipStream_t', 'stream')]
1192 #define INIT_hipMemset3DAsync_CB_ARGS_DATA(cb_data) { \
1193  cb_data.args.hipMemset3DAsync.pitchedDevPtr = pitchedDevPtr; \
1194  cb_data.args.hipMemset3DAsync.value = value; \
1195  cb_data.args.hipMemset3DAsync.extent = extent; \
1196  cb_data.args.hipMemset3DAsync.stream = stream; \
1197 };
1198 // hipMemcpy3D[('const hipMemcpy3DParms*', 'p')]
1199 #define INIT_hipMemcpy3D_CB_ARGS_DATA(cb_data) { \
1200  cb_data.args.hipMemcpy3D.p = p; \
1201 };
1202 // hipInit[('unsigned int', 'flags')]
1203 #define INIT_hipInit_CB_ARGS_DATA(cb_data) { \
1204  cb_data.args.hipInit.flags = flags; \
1205 };
1206 // hipMemcpyAtoH[('void*', 'dst'), ('hipArray*', 'srcArray'), ('size_t', 'srcOffset'), ('size_t', 'count')]
1207 #define INIT_hipMemcpyAtoH_CB_ARGS_DATA(cb_data) { \
1208  cb_data.args.hipMemcpyAtoH.dst = dst; \
1209  cb_data.args.hipMemcpyAtoH.srcArray = srcArray; \
1210  cb_data.args.hipMemcpyAtoH.srcOffset = srcOffset; \
1211  cb_data.args.hipMemcpyAtoH.count = count; \
1212 };
1213 // hipStreamGetPriority[('hipStream_t', 'stream'), ('int*', 'priority')]
1214 #define INIT_hipStreamGetPriority_CB_ARGS_DATA(cb_data) { \
1215  cb_data.args.hipStreamGetPriority.stream = stream; \
1216  cb_data.args.hipStreamGetPriority.priority = priority; \
1217 };
1218 // hipMemset2D[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height')]
1219 #define INIT_hipMemset2D_CB_ARGS_DATA(cb_data) { \
1220  cb_data.args.hipMemset2D.dst = dst; \
1221  cb_data.args.hipMemset2D.pitch = pitch; \
1222  cb_data.args.hipMemset2D.value = value; \
1223  cb_data.args.hipMemset2D.width = width; \
1224  cb_data.args.hipMemset2D.height = height; \
1225 };
1226 // hipMemset2DAsync[('void*', 'dst'), ('size_t', 'pitch'), ('int', 'value'), ('size_t', 'width'), ('size_t', 'height'), ('hipStream_t', 'stream')]
1227 #define INIT_hipMemset2DAsync_CB_ARGS_DATA(cb_data) { \
1228  cb_data.args.hipMemset2DAsync.dst = dst; \
1229  cb_data.args.hipMemset2DAsync.pitch = pitch; \
1230  cb_data.args.hipMemset2DAsync.value = value; \
1231  cb_data.args.hipMemset2DAsync.width = width; \
1232  cb_data.args.hipMemset2DAsync.height = height; \
1233  cb_data.args.hipMemset2DAsync.stream = stream; \
1234 };
1235 // hipDeviceCanAccessPeer[('int*', 'canAccessPeer'), ('int', 'deviceId'), ('int', 'peerDeviceId')]
1236 #define INIT_hipDeviceCanAccessPeer_CB_ARGS_DATA(cb_data) { \
1237  cb_data.args.hipDeviceCanAccessPeer.canAccessPeer = canAccessPeer; \
1238  cb_data.args.hipDeviceCanAccessPeer.deviceId = deviceId; \
1239  cb_data.args.hipDeviceCanAccessPeer.peerDeviceId = peerDeviceId; \
1240 };
1241 // hipDeviceEnablePeerAccess[('int', 'peerDeviceId'), ('unsigned int', 'flags')]
1242 #define INIT_hipDeviceEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
1243  cb_data.args.hipDeviceEnablePeerAccess.peerDeviceId = peerDeviceId; \
1244  cb_data.args.hipDeviceEnablePeerAccess.flags = flags; \
1245 };
1246 // hipModuleUnload[('hipModule_t', 'module')]
1247 #define INIT_hipModuleUnload_CB_ARGS_DATA(cb_data) { \
1248  cb_data.args.hipModuleUnload.module = hmod; \
1249 };
1250 // hipHostUnregister[('void*', 'hostPtr')]
1251 #define INIT_hipHostUnregister_CB_ARGS_DATA(cb_data) { \
1252  cb_data.args.hipHostUnregister.hostPtr = hostPtr; \
1253 };
1254 // hipProfilerStop[]
1255 #define INIT_hipProfilerStop_CB_ARGS_DATA(cb_data) { \
1256 };
1257 // hipLaunchByPtr[('const void*', 'func')]
1258 #define INIT_hipLaunchByPtr_CB_ARGS_DATA(cb_data) { \
1259  cb_data.args.hipLaunchByPtr.func = hostFunction; \
1260 };
1261 // hipStreamSynchronize[('hipStream_t', 'stream')]
1262 #define INIT_hipStreamSynchronize_CB_ARGS_DATA(cb_data) { \
1263  cb_data.args.hipStreamSynchronize.stream = stream; \
1264 };
1265 // hipDeviceSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
1266 #define INIT_hipDeviceSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1267  cb_data.args.hipDeviceSetCacheConfig.cacheConfig = cacheConfig; \
1268 };
1269 // hipGetErrorName[('hipError_t', 'hip_error')]
1270 #define INIT_hipGetErrorName_CB_ARGS_DATA(cb_data) { \
1271  cb_data.args.hipGetErrorName.hip_error = hip_error; \
1272 };
1273 // hipMemcpyHtoD[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes')]
1274 #define INIT_hipMemcpyHtoD_CB_ARGS_DATA(cb_data) { \
1275  cb_data.args.hipMemcpyHtoD.dst = dst; \
1276  cb_data.args.hipMemcpyHtoD.src = src; \
1277  cb_data.args.hipMemcpyHtoD.sizeBytes = sizeBytes; \
1278 };
1279 // hipModuleGetGlobal[('hipDeviceptr_t*', 'dptr'), ('size_t*', 'bytes'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
1280 #define INIT_hipModuleGetGlobal_CB_ARGS_DATA(cb_data) { \
1281  cb_data.args.hipModuleGetGlobal.dptr = dptr; \
1282  cb_data.args.hipModuleGetGlobal.bytes = bytes; \
1283  cb_data.args.hipModuleGetGlobal.hmod = hmod; \
1284  cb_data.args.hipModuleGetGlobal.name = name; \
1285 };
1286 // hipMemcpyHtoA[('hipArray*', 'dstArray'), ('size_t', 'dstOffset'), ('const void*', 'srcHost'), ('size_t', 'count')]
1287 #define INIT_hipMemcpyHtoA_CB_ARGS_DATA(cb_data) { \
1288  cb_data.args.hipMemcpyHtoA.dstArray = dstArray; \
1289  cb_data.args.hipMemcpyHtoA.dstOffset = dstOffset; \
1290  cb_data.args.hipMemcpyHtoA.srcHost = srcHost; \
1291  cb_data.args.hipMemcpyHtoA.count = count; \
1292 };
1293 // hipCtxCreate[('hipCtx_t*', 'ctx'), ('unsigned int', 'flags'), ('hipDevice_t', 'device')]
1294 #define INIT_hipCtxCreate_CB_ARGS_DATA(cb_data) { \
1295  cb_data.args.hipCtxCreate.ctx = ctx; \
1296  cb_data.args.hipCtxCreate.flags = flags; \
1297  cb_data.args.hipCtxCreate.device = device; \
1298 };
1299 // hipMemcpy2D[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind')]
1300 #define INIT_hipMemcpy2D_CB_ARGS_DATA(cb_data) { \
1301  cb_data.args.hipMemcpy2D.dst = dst; \
1302  cb_data.args.hipMemcpy2D.dpitch = dpitch; \
1303  cb_data.args.hipMemcpy2D.src = src; \
1304  cb_data.args.hipMemcpy2D.spitch = spitch; \
1305  cb_data.args.hipMemcpy2D.width = width; \
1306  cb_data.args.hipMemcpy2D.height = height; \
1307  cb_data.args.hipMemcpy2D.kind = kind; \
1308 };
1309 // hipIpcCloseMemHandle[('void*', 'devPtr')]
1310 #define INIT_hipIpcCloseMemHandle_CB_ARGS_DATA(cb_data) { \
1311  cb_data.args.hipIpcCloseMemHandle.devPtr = devPtr; \
1312 };
1313 // hipChooseDevice[('int*', 'device'), ('const hipDeviceProp_t*', 'prop')]
1314 #define INIT_hipChooseDevice_CB_ARGS_DATA(cb_data) { \
1315  cb_data.args.hipChooseDevice.device = device; \
1316  cb_data.args.hipChooseDevice.prop = prop; \
1317 };
1318 // hipDeviceSetSharedMemConfig[('hipSharedMemConfig', 'config')]
1319 #define INIT_hipDeviceSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1320  cb_data.args.hipDeviceSetSharedMemConfig.config = config; \
1321 };
1322 // hipDeviceComputeCapability[('int*', 'major'), ('int*', 'minor'), ('hipDevice_t', 'device')]
1323 #define INIT_hipDeviceComputeCapability_CB_ARGS_DATA(cb_data) { \
1324  cb_data.args.hipDeviceComputeCapability.major = major; \
1325  cb_data.args.hipDeviceComputeCapability.minor = minor; \
1326  cb_data.args.hipDeviceComputeCapability.device = device; \
1327 };
1328 // hipDeviceGet[('hipDevice_t*', 'device'), ('int', 'ordinal')]
1329 #define INIT_hipDeviceGet_CB_ARGS_DATA(cb_data) { \
1330  cb_data.args.hipDeviceGet.device = device; \
1331  cb_data.args.hipDeviceGet.ordinal = deviceId; \
1332 };
1333 // hipProfilerStart[]
1334 #define INIT_hipProfilerStart_CB_ARGS_DATA(cb_data) { \
1335 };
1336 // hipCtxSetCacheConfig[('hipFuncCache_t', 'cacheConfig')]
1337 #define INIT_hipCtxSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1338  cb_data.args.hipCtxSetCacheConfig.cacheConfig = cacheConfig; \
1339 };
1340 // hipFuncSetCacheConfig[('const void*', 'func'), ('hipFuncCache_t', 'config')]
1341 #define INIT_hipFuncSetCacheConfig_CB_ARGS_DATA(cb_data) { \
1342  cb_data.args.hipFuncSetCacheConfig.func = func; \
1343  cb_data.args.hipFuncSetCacheConfig.config = cacheConfig; \
1344 };
1345 // hipMemcpyPeerAsync[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDevice'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1346 #define INIT_hipMemcpyPeerAsync_CB_ARGS_DATA(cb_data) { \
1347  cb_data.args.hipMemcpyPeerAsync.dst = dst; \
1348  cb_data.args.hipMemcpyPeerAsync.dstDeviceId = dstDevice; \
1349  cb_data.args.hipMemcpyPeerAsync.src = src; \
1350  cb_data.args.hipMemcpyPeerAsync.srcDevice = srcDevice; \
1351  cb_data.args.hipMemcpyPeerAsync.sizeBytes = sizeBytes; \
1352  cb_data.args.hipMemcpyPeerAsync.stream = stream; \
1353 };
1354 // hipEventElapsedTime[('float*', 'ms'), ('hipEvent_t', 'start'), ('hipEvent_t', 'stop')]
1355 #define INIT_hipEventElapsedTime_CB_ARGS_DATA(cb_data) { \
1356  cb_data.args.hipEventElapsedTime.ms = ms; \
1357  cb_data.args.hipEventElapsedTime.start = start; \
1358  cb_data.args.hipEventElapsedTime.stop = stop; \
1359 };
1360 // hipDevicePrimaryCtxReset[('hipDevice_t', 'dev')]
1361 #define INIT_hipDevicePrimaryCtxReset_CB_ARGS_DATA(cb_data) { \
1362  cb_data.args.hipDevicePrimaryCtxReset.dev = dev; \
1363 };
1364 // hipEventDestroy[('hipEvent_t', 'event')]
1365 #define INIT_hipEventDestroy_CB_ARGS_DATA(cb_data) { \
1366  cb_data.args.hipEventDestroy.event = event; \
1367 };
1368 // hipCtxPopCurrent[('hipCtx_t*', 'ctx')]
1369 #define INIT_hipCtxPopCurrent_CB_ARGS_DATA(cb_data) { \
1370  cb_data.args.hipCtxPopCurrent.ctx = ctx; \
1371 };
1372 // hipGetSymbolAddress[('void**', 'devPtr'), ('const void*', 'symbolName')]
1373 #define INIT_hipGetSymbolAddress_CB_ARGS_DATA(cb_data) { \
1374 };
1375 // hipHostGetFlags[('unsigned int*', 'flagsPtr'), ('void*', 'hostPtr')]
1376 #define INIT_hipHostGetFlags_CB_ARGS_DATA(cb_data) { \
1377  cb_data.args.hipHostGetFlags.flagsPtr = flagsPtr; \
1378  cb_data.args.hipHostGetFlags.hostPtr = hostPtr; \
1379 };
1380 // hipHostMalloc[('void**', 'ptr'), ('size_t', 'size'), ('unsigned int', 'flags')]
1381 #define INIT_hipHostMalloc_CB_ARGS_DATA(cb_data) { \
1382  cb_data.args.hipHostMalloc.ptr = ptr; \
1383  cb_data.args.hipHostMalloc.size = sizeBytes; \
1384  cb_data.args.hipHostMalloc.flags = flags; \
1385 };
1386 // hipDriverGetVersion[('int*', 'driverVersion')]
1387 #define INIT_hipDriverGetVersion_CB_ARGS_DATA(cb_data) { \
1388  cb_data.args.hipDriverGetVersion.driverVersion = driverVersion; \
1389 };
1390 // hipMemGetInfo[('size_t*', 'free'), ('size_t*', 'total')]
1391 #define INIT_hipMemGetInfo_CB_ARGS_DATA(cb_data) { \
1392  cb_data.args.hipMemGetInfo.free = free; \
1393  cb_data.args.hipMemGetInfo.total = total; \
1394 };
1395 // hipDeviceReset[]
1396 #define INIT_hipDeviceReset_CB_ARGS_DATA(cb_data) { \
1397 };
1398 // hipMemset[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes')]
1399 #define INIT_hipMemset_CB_ARGS_DATA(cb_data) { \
1400  cb_data.args.hipMemset.dst = dst; \
1401  cb_data.args.hipMemset.value = value; \
1402  cb_data.args.hipMemset.sizeBytes = sizeBytes; \
1403 };
1404 // hipMemsetD8[('hipDeviceptr_t', 'dest'), ('unsigned char', 'value'), ('size_t', 'sizeBytes')]
1405 #define INIT_hipMemsetD8_CB_ARGS_DATA(cb_data) { \
1406  cb_data.args.hipMemsetD8.dest = dst; \
1407  cb_data.args.hipMemsetD8.value = value; \
1408  cb_data.args.hipMemsetD8.sizeBytes = sizeBytes; \
1409 };
1410 // hipHostRegister[('void*', 'hostPtr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
1411 #define INIT_hipHostRegister_CB_ARGS_DATA(cb_data) { \
1412  cb_data.args.hipHostRegister.hostPtr = hostPtr; \
1413  cb_data.args.hipHostRegister.sizeBytes = sizeBytes; \
1414  cb_data.args.hipHostRegister.flags = flags; \
1415 };
1416 // hipCtxSetSharedMemConfig[('hipSharedMemConfig', 'config')]
1417 #define INIT_hipCtxSetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1418  cb_data.args.hipCtxSetSharedMemConfig.config = config; \
1419 };
1420 // hipArray3DCreate[('hipArray**', 'array'), ('const HIP_ARRAY_DESCRIPTOR*', 'pAllocateArray')]
1421 #define INIT_hipArray3DCreate_CB_ARGS_DATA(cb_data) { \
1422  cb_data.args.hipArray3DCreate.array = array; \
1423  cb_data.args.hipArray3DCreate.pAllocateArray = pAllocateArray; \
1424 };
1425 // hipIpcOpenMemHandle[('void**', 'devPtr'), ('hipIpcMemHandle_t', 'handle'), ('unsigned int', 'flags')]
1426 #define INIT_hipIpcOpenMemHandle_CB_ARGS_DATA(cb_data) { \
1427  cb_data.args.hipIpcOpenMemHandle.devPtr = devPtr; \
1428  cb_data.args.hipIpcOpenMemHandle.handle = handle; \
1429  cb_data.args.hipIpcOpenMemHandle.flags = flags; \
1430 };
1431 // hipGetLastError[]
1432 #define INIT_hipGetLastError_CB_ARGS_DATA(cb_data) { \
1433 };
1434 // hipCtxDestroy[('hipCtx_t', 'ctx')]
1435 #define INIT_hipCtxDestroy_CB_ARGS_DATA(cb_data) { \
1436  cb_data.args.hipCtxDestroy.ctx = ctx; \
1437 };
1438 // hipDeviceGetSharedMemConfig[('hipSharedMemConfig*', 'pConfig')]
1439 #define INIT_hipDeviceGetSharedMemConfig_CB_ARGS_DATA(cb_data) { \
1440  cb_data.args.hipDeviceGetSharedMemConfig.pConfig = pConfig; \
1441 };
1442 // hipSetDeviceFlags[('unsigned int', 'flags')]
1443 #define INIT_hipSetDeviceFlags_CB_ARGS_DATA(cb_data) { \
1444  cb_data.args.hipSetDeviceFlags.flags = flags; \
1445 };
1446 // 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')]
1447 #define INIT_hipHccModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
1448  cb_data.args.hipHccModuleLaunchKernel.f = f; \
1449  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeX = globalWorkSizeX; \
1450  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeY = globalWorkSizeY; \
1451  cb_data.args.hipHccModuleLaunchKernel.globalWorkSizeZ = globalWorkSizeZ; \
1452  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeX = localWorkSizeX; \
1453  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeY = localWorkSizeY; \
1454  cb_data.args.hipHccModuleLaunchKernel.localWorkSizeZ = localWorkSizeZ; \
1455  cb_data.args.hipHccModuleLaunchKernel.sharedMemBytes = sharedMemBytes; \
1456  cb_data.args.hipHccModuleLaunchKernel.hStream = hStream; \
1457  cb_data.args.hipHccModuleLaunchKernel.kernelParams = kernelParams; \
1458  cb_data.args.hipHccModuleLaunchKernel.extra = extra; \
1459  cb_data.args.hipHccModuleLaunchKernel.startEvent = startEvent; \
1460  cb_data.args.hipHccModuleLaunchKernel.stopEvent = stopEvent; \
1461 };
1462 // hipFree[('void*', 'ptr')]
1463 #define INIT_hipFree_CB_ARGS_DATA(cb_data) { \
1464  cb_data.args.hipFree.ptr = ptr; \
1465 };
1466 // hipDeviceGetAttribute[('int*', 'pi'), ('hipDeviceAttribute_t', 'attr'), ('int', 'deviceId')]
1467 #define INIT_hipDeviceGetAttribute_CB_ARGS_DATA(cb_data) { \
1468  cb_data.args.hipDeviceGetAttribute.pi = pi; \
1469  cb_data.args.hipDeviceGetAttribute.attr = attr; \
1470  cb_data.args.hipDeviceGetAttribute.deviceId = device; \
1471 };
1472 // hipMemcpyDtoH[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes')]
1473 #define INIT_hipMemcpyDtoH_CB_ARGS_DATA(cb_data) { \
1474  cb_data.args.hipMemcpyDtoH.dst = dst; \
1475  cb_data.args.hipMemcpyDtoH.src = src; \
1476  cb_data.args.hipMemcpyDtoH.sizeBytes = sizeBytes; \
1477 };
1478 // hipCtxDisablePeerAccess[('hipCtx_t', 'peerCtx')]
1479 #define INIT_hipCtxDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
1480  cb_data.args.hipCtxDisablePeerAccess.peerCtx = peerCtx; \
1481 };
1482 // hipMallocManaged[('void**', 'devPtr'), ('size_t', 'size'), ('unsigned int', 'flags')]
1483 #define INIT_hipMallocManaged_CB_ARGS_DATA(cb_data) { \
1484  cb_data.args.hipMallocManaged.devPtr = devPtr; \
1485  cb_data.args.hipMallocManaged.size = size; \
1486  cb_data.args.hipMallocManaged.flags = flags; \
1487 };
1488 // hipDeviceGetByPCIBusId[('int*', 'device'), ('const char*', 'pciBusId')]
1489 #define INIT_hipDeviceGetByPCIBusId_CB_ARGS_DATA(cb_data) { \
1490  cb_data.args.hipDeviceGetByPCIBusId.device = device; \
1491  cb_data.args.hipDeviceGetByPCIBusId.pciBusId = pciBusId; \
1492 };
1493 // hipIpcGetMemHandle[('hipIpcMemHandle_t*', 'handle'), ('void*', 'devPtr')]
1494 #define INIT_hipIpcGetMemHandle_CB_ARGS_DATA(cb_data) { \
1495  cb_data.args.hipIpcGetMemHandle.handle = handle; \
1496  cb_data.args.hipIpcGetMemHandle.devPtr = devPtr; \
1497 };
1498 // hipMemcpyHtoDAsync[('hipDeviceptr_t', 'dst'), ('void*', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1499 #define INIT_hipMemcpyHtoDAsync_CB_ARGS_DATA(cb_data) { \
1500  cb_data.args.hipMemcpyHtoDAsync.dst = dst; \
1501  cb_data.args.hipMemcpyHtoDAsync.src = src; \
1502  cb_data.args.hipMemcpyHtoDAsync.sizeBytes = sizeBytes; \
1503  cb_data.args.hipMemcpyHtoDAsync.stream = stream; \
1504 };
1505 // hipCtxGetDevice[('hipDevice_t*', 'device')]
1506 #define INIT_hipCtxGetDevice_CB_ARGS_DATA(cb_data) { \
1507  cb_data.args.hipCtxGetDevice.device = device; \
1508 };
1509 // hipMemset3D[('hipPitchedPtr', 'pitchedDevPtr'), ('int', 'value'), ('hipExtent', 'extent')]
1510 #define INIT_hipMemset3D_CB_ARGS_DATA(cb_data) { \
1511  cb_data.args.hipMemset3D.pitchedDevPtr = pitchedDevPtr; \
1512  cb_data.args.hipMemset3D.value = value; \
1513  cb_data.args.hipMemset3D.extent = extent; \
1514 };
1515 // hipModuleLoadData[('hipModule_t*', 'module'), ('const void*', 'image')]
1516 #define INIT_hipModuleLoadData_CB_ARGS_DATA(cb_data) { \
1517  cb_data.args.hipModuleLoadData.module = module; \
1518  cb_data.args.hipModuleLoadData.image = image; \
1519 };
1520 // hipDeviceTotalMem[('size_t*', 'bytes'), ('hipDevice_t', 'device')]
1521 #define INIT_hipDeviceTotalMem_CB_ARGS_DATA(cb_data) { \
1522  cb_data.args.hipDeviceTotalMem.bytes = bytes; \
1523  cb_data.args.hipDeviceTotalMem.device = device; \
1524 };
1525 // hipCtxSetCurrent[('hipCtx_t', 'ctx')]
1526 #define INIT_hipCtxSetCurrent_CB_ARGS_DATA(cb_data) { \
1527  cb_data.args.hipCtxSetCurrent.ctx = ctx; \
1528 };
1529 // hipGetErrorString[('hipError_t', 'hipError')]
1530 #define INIT_hipGetErrorString_CB_ARGS_DATA(cb_data) { \
1531  cb_data.args.hipGetErrorString.hipError = hip_error; \
1532 };
1533 // hipDevicePrimaryCtxRetain[('hipCtx_t*', 'pctx'), ('hipDevice_t', 'dev')]
1534 #define INIT_hipDevicePrimaryCtxRetain_CB_ARGS_DATA(cb_data) { \
1535  cb_data.args.hipDevicePrimaryCtxRetain.pctx = pctx; \
1536  cb_data.args.hipDevicePrimaryCtxRetain.dev = dev; \
1537 };
1538 // hipDeviceDisablePeerAccess[('int', 'peerDeviceId')]
1539 #define INIT_hipDeviceDisablePeerAccess_CB_ARGS_DATA(cb_data) { \
1540  cb_data.args.hipDeviceDisablePeerAccess.peerDeviceId = peerDeviceId; \
1541 };
1542 // hipStreamCreateWithFlags[('hipStream_t*', 'stream'), ('unsigned int', 'flags')]
1543 #define INIT_hipStreamCreateWithFlags_CB_ARGS_DATA(cb_data) { \
1544  cb_data.args.hipStreamCreateWithFlags.stream = stream; \
1545  cb_data.args.hipStreamCreateWithFlags.flags = flags; \
1546 };
1547 // hipMemcpyFromArray[('void*', 'dst'), ('hipArray_const_t', 'srcArray'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
1548 #define INIT_hipMemcpyFromArray_CB_ARGS_DATA(cb_data) { \
1549  cb_data.args.hipMemcpyFromArray.dst = dst; \
1550  cb_data.args.hipMemcpyFromArray.srcArray = srcArray; \
1551  cb_data.args.hipMemcpyFromArray.wOffset = wOffset; \
1552  cb_data.args.hipMemcpyFromArray.hOffset = hOffset; \
1553  cb_data.args.hipMemcpyFromArray.count = count; \
1554  cb_data.args.hipMemcpyFromArray.kind = kind; \
1555 };
1556 // hipMemcpy2DAsync[('void*', 'dst'), ('size_t', 'dpitch'), ('const void*', 'src'), ('size_t', 'spitch'), ('size_t', 'width'), ('size_t', 'height'), ('hipMemcpyKind', 'kind'), ('hipStream_t', 'stream')]
1557 #define INIT_hipMemcpy2DAsync_CB_ARGS_DATA(cb_data) { \
1558  cb_data.args.hipMemcpy2DAsync.dst = dst; \
1559  cb_data.args.hipMemcpy2DAsync.dpitch = dpitch; \
1560  cb_data.args.hipMemcpy2DAsync.src = src; \
1561  cb_data.args.hipMemcpy2DAsync.spitch = spitch; \
1562  cb_data.args.hipMemcpy2DAsync.width = width; \
1563  cb_data.args.hipMemcpy2DAsync.height = height; \
1564  cb_data.args.hipMemcpy2DAsync.kind = kind; \
1565  cb_data.args.hipMemcpy2DAsync.stream = stream; \
1566 };
1567 // hipGetSymbolSize[('size_t*', 'size'), ('const void*', 'symbolName')]
1568 #define INIT_hipGetSymbolSize_CB_ARGS_DATA(cb_data) { \
1569 };
1570 // hipEventCreateWithFlags[('hipEvent_t*', 'event'), ('unsigned int', 'flags')]
1571 #define INIT_hipEventCreateWithFlags_CB_ARGS_DATA(cb_data) { \
1572  cb_data.args.hipEventCreateWithFlags.event = event; \
1573  cb_data.args.hipEventCreateWithFlags.flags = flags; \
1574 };
1575 // hipStreamQuery[('hipStream_t', 'stream')]
1576 #define INIT_hipStreamQuery_CB_ARGS_DATA(cb_data) { \
1577  cb_data.args.hipStreamQuery.stream = stream; \
1578 };
1579 // hipDeviceGetPCIBusId[('char*', 'pciBusId'), ('int', 'len'), ('int', 'device')]
1580 #define INIT_hipDeviceGetPCIBusId_CB_ARGS_DATA(cb_data) { \
1581  cb_data.args.hipDeviceGetPCIBusId.pciBusId = pciBusId; \
1582  cb_data.args.hipDeviceGetPCIBusId.len = len; \
1583  cb_data.args.hipDeviceGetPCIBusId.device = device; \
1584 };
1585 // hipMemcpy[('void*', 'dst'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('hipMemcpyKind', 'kind')]
1586 #define INIT_hipMemcpy_CB_ARGS_DATA(cb_data) { \
1587  cb_data.args.hipMemcpy.dst = dst; \
1588  cb_data.args.hipMemcpy.src = src; \
1589  cb_data.args.hipMemcpy.sizeBytes = sizeBytes; \
1590  cb_data.args.hipMemcpy.kind = kind; \
1591 };
1592 // hipPeekAtLastError[]
1593 #define INIT_hipPeekAtLastError_CB_ARGS_DATA(cb_data) { \
1594 };
1595 // hipStreamAddCallback[('hipStream_t', 'stream'), ('hipStreamCallback_t', 'callback'), ('void*', 'userData'), ('unsigned int', 'flags')]
1596 #define INIT_hipStreamAddCallback_CB_ARGS_DATA(cb_data) { \
1597  cb_data.args.hipStreamAddCallback.stream = stream; \
1598  cb_data.args.hipStreamAddCallback.callback = callback; \
1599  cb_data.args.hipStreamAddCallback.userData = userData; \
1600  cb_data.args.hipStreamAddCallback.flags = flags; \
1601 };
1602 // hipMemcpyToArray[('hipArray*', 'dst'), ('size_t', 'wOffset'), ('size_t', 'hOffset'), ('const void*', 'src'), ('size_t', 'count'), ('hipMemcpyKind', 'kind')]
1603 #define INIT_hipMemcpyToArray_CB_ARGS_DATA(cb_data) { \
1604  cb_data.args.hipMemcpyToArray.dst = dst; \
1605  cb_data.args.hipMemcpyToArray.wOffset = wOffset; \
1606  cb_data.args.hipMemcpyToArray.hOffset = hOffset; \
1607  cb_data.args.hipMemcpyToArray.src = src; \
1608  cb_data.args.hipMemcpyToArray.count = count; \
1609  cb_data.args.hipMemcpyToArray.kind = kind; \
1610 };
1611 // hipMemsetD32[('hipDeviceptr_t', 'dest'), ('int', 'value'), ('size_t', 'count')]
1612 #define INIT_hipMemsetD32_CB_ARGS_DATA(cb_data) { \
1613  cb_data.args.hipMemsetD32.dest = dst; \
1614  cb_data.args.hipMemsetD32.value = value; \
1615  cb_data.args.hipMemsetD32.count = count; \
1616 };
1617 // hipDeviceSynchronize[]
1618 #define INIT_hipDeviceSynchronize_CB_ARGS_DATA(cb_data) { \
1619 };
1620 // hipDeviceGetCacheConfig[('hipFuncCache_t*', 'cacheConfig')]
1621 #define INIT_hipDeviceGetCacheConfig_CB_ARGS_DATA(cb_data) { \
1622  cb_data.args.hipDeviceGetCacheConfig.cacheConfig = cacheConfig; \
1623 };
1624 // hipMalloc3D[('hipPitchedPtr*', 'pitchedDevPtr'), ('hipExtent', 'extent')]
1625 #define INIT_hipMalloc3D_CB_ARGS_DATA(cb_data) { \
1626  cb_data.args.hipMalloc3D.pitchedDevPtr = pitchedDevPtr; \
1627  cb_data.args.hipMalloc3D.extent = extent; \
1628 };
1629 // hipPointerGetAttributes[('hipPointerAttribute_t*', 'attributes'), ('const void*', 'ptr')]
1630 #define INIT_hipPointerGetAttributes_CB_ARGS_DATA(cb_data) { \
1631  cb_data.args.hipPointerGetAttributes.attributes = attributes; \
1632  cb_data.args.hipPointerGetAttributes.ptr = ptr; \
1633 };
1634 // hipMemsetAsync[('void*', 'dst'), ('int', 'value'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1635 #define INIT_hipMemsetAsync_CB_ARGS_DATA(cb_data) { \
1636  cb_data.args.hipMemsetAsync.dst = dst; \
1637  cb_data.args.hipMemsetAsync.value = value; \
1638  cb_data.args.hipMemsetAsync.sizeBytes = sizeBytes; \
1639  cb_data.args.hipMemsetAsync.stream = stream; \
1640 };
1641 // hipMemcpyToSymbol[('const void*', 'symbolName'), ('const void*', 'src'), ('size_t', 'sizeBytes'), ('size_t', 'offset'), ('hipMemcpyKind', 'kind')]
1642 #define INIT_hipMemcpyToSymbol_CB_ARGS_DATA(cb_data) { \
1643 };
1644 // hipCtxPushCurrent[('hipCtx_t', 'ctx')]
1645 #define INIT_hipCtxPushCurrent_CB_ARGS_DATA(cb_data) { \
1646  cb_data.args.hipCtxPushCurrent.ctx = ctx; \
1647 };
1648 // hipMemcpyPeer[('void*', 'dst'), ('int', 'dstDeviceId'), ('const void*', 'src'), ('int', 'srcDeviceId'), ('size_t', 'sizeBytes')]
1649 #define INIT_hipMemcpyPeer_CB_ARGS_DATA(cb_data) { \
1650  cb_data.args.hipMemcpyPeer.dst = dst; \
1651  cb_data.args.hipMemcpyPeer.dstDeviceId = dstDevice; \
1652  cb_data.args.hipMemcpyPeer.src = src; \
1653  cb_data.args.hipMemcpyPeer.srcDeviceId = srcDevice; \
1654  cb_data.args.hipMemcpyPeer.sizeBytes = sizeBytes; \
1655 };
1656 // hipEventSynchronize[('hipEvent_t', 'event')]
1657 #define INIT_hipEventSynchronize_CB_ARGS_DATA(cb_data) { \
1658  cb_data.args.hipEventSynchronize.event = event; \
1659 };
1660 // hipMemcpyDtoDAsync[('hipDeviceptr_t', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1661 #define INIT_hipMemcpyDtoDAsync_CB_ARGS_DATA(cb_data) { \
1662  cb_data.args.hipMemcpyDtoDAsync.dst = dst; \
1663  cb_data.args.hipMemcpyDtoDAsync.src = src; \
1664  cb_data.args.hipMemcpyDtoDAsync.sizeBytes = sizeBytes; \
1665  cb_data.args.hipMemcpyDtoDAsync.stream = stream; \
1666 };
1667 // hipExtMallocWithFlags[('void**', 'ptr'), ('size_t', 'sizeBytes'), ('unsigned int', 'flags')]
1668 #define INIT_hipExtMallocWithFlags_CB_ARGS_DATA(cb_data) { \
1669  cb_data.args.hipExtMallocWithFlags.ptr = ptr; \
1670  cb_data.args.hipExtMallocWithFlags.sizeBytes = sizeBytes; \
1671  cb_data.args.hipExtMallocWithFlags.flags = flags; \
1672 };
1673 // hipCtxEnablePeerAccess[('hipCtx_t', 'peerCtx'), ('unsigned int', 'flags')]
1674 #define INIT_hipCtxEnablePeerAccess_CB_ARGS_DATA(cb_data) { \
1675  cb_data.args.hipCtxEnablePeerAccess.peerCtx = peerCtx; \
1676  cb_data.args.hipCtxEnablePeerAccess.flags = flags; \
1677 };
1678 // hipMemcpyDtoHAsync[('void*', 'dst'), ('hipDeviceptr_t', 'src'), ('size_t', 'sizeBytes'), ('hipStream_t', 'stream')]
1679 #define INIT_hipMemcpyDtoHAsync_CB_ARGS_DATA(cb_data) { \
1680  cb_data.args.hipMemcpyDtoHAsync.dst = dst; \
1681  cb_data.args.hipMemcpyDtoHAsync.src = src; \
1682  cb_data.args.hipMemcpyDtoHAsync.sizeBytes = sizeBytes; \
1683  cb_data.args.hipMemcpyDtoHAsync.stream = stream; \
1684 };
1685 // 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')]
1686 #define INIT_hipModuleLaunchKernel_CB_ARGS_DATA(cb_data) { \
1687  cb_data.args.hipModuleLaunchKernel.f = f; \
1688  cb_data.args.hipModuleLaunchKernel.gridDimX = gridDimX; \
1689  cb_data.args.hipModuleLaunchKernel.gridDimY = gridDimY; \
1690  cb_data.args.hipModuleLaunchKernel.gridDimZ = gridDimZ; \
1691  cb_data.args.hipModuleLaunchKernel.blockDimX = blockDimX; \
1692  cb_data.args.hipModuleLaunchKernel.blockDimY = blockDimY; \
1693  cb_data.args.hipModuleLaunchKernel.blockDimZ = blockDimZ; \
1694  cb_data.args.hipModuleLaunchKernel.sharedMemBytes = sharedMemBytes; \
1695  cb_data.args.hipModuleLaunchKernel.stream = hStream; \
1696  cb_data.args.hipModuleLaunchKernel.kernelParams = kernelParams; \
1697  cb_data.args.hipModuleLaunchKernel.extra = extra; \
1698 };
1699 // hipModuleGetTexRef[('textureReference**', 'texRef'), ('hipModule_t', 'hmod'), ('const char*', 'name')]
1700 #define INIT_hipModuleGetTexRef_CB_ARGS_DATA(cb_data) { \
1701  cb_data.args.hipModuleGetTexRef.texRef = texRef; \
1702  cb_data.args.hipModuleGetTexRef.hmod = hmod; \
1703  cb_data.args.hipModuleGetTexRef.name = name; \
1704 };
1705 // hipDeviceGetLimit[('size_t*', 'pValue'), ('hipLimit_t', 'limit')]
1706 #define INIT_hipDeviceGetLimit_CB_ARGS_DATA(cb_data) { \
1707  cb_data.args.hipDeviceGetLimit.pValue = pValue; \
1708  cb_data.args.hipDeviceGetLimit.limit = limit; \
1709 };
1710 // hipModuleLoadDataEx[('hipModule_t*', 'module'), ('const void*', 'image'), ('unsigned int', 'numOptions'), ('hipJitOption*', 'options'), ('void**', 'optionValues')]
1711 #define INIT_hipModuleLoadDataEx_CB_ARGS_DATA(cb_data) { \
1712  cb_data.args.hipModuleLoadDataEx.module = module; \
1713  cb_data.args.hipModuleLoadDataEx.image = image; \
1714  cb_data.args.hipModuleLoadDataEx.numOptions = numOptions; \
1715  cb_data.args.hipModuleLoadDataEx.options = options; \
1716  cb_data.args.hipModuleLoadDataEx.optionValues = optionValues; \
1717 };
1718 // hipRuntimeGetVersion[('int*', 'runtimeVersion')]
1719 #define INIT_hipRuntimeGetVersion_CB_ARGS_DATA(cb_data) { \
1720  cb_data.args.hipRuntimeGetVersion.runtimeVersion = runtimeVersion; \
1721 };
1722 // hipGetDeviceProperties[('hipDeviceProp_t*', 'prop'), ('int', 'deviceId')]
1723 #define INIT_hipGetDeviceProperties_CB_ARGS_DATA(cb_data) { \
1724  cb_data.args.hipGetDeviceProperties.prop = props; \
1725  cb_data.args.hipGetDeviceProperties.deviceId = device; \
1726 };
1727 // hipFreeArray[('hipArray*', 'array')]
1728 #define INIT_hipFreeArray_CB_ARGS_DATA(cb_data) { \
1729  cb_data.args.hipFreeArray.array = array; \
1730 };
1731 // hipDevicePrimaryCtxRelease[('hipDevice_t', 'dev')]
1732 #define INIT_hipDevicePrimaryCtxRelease_CB_ARGS_DATA(cb_data) { \
1733  cb_data.args.hipDevicePrimaryCtxRelease.dev = dev; \
1734 };
1735 // hipHostGetDevicePointer[('void**', 'devPtr'), ('void*', 'hstPtr'), ('unsigned int', 'flags')]
1736 #define INIT_hipHostGetDevicePointer_CB_ARGS_DATA(cb_data) { \
1737  cb_data.args.hipHostGetDevicePointer.devPtr = devicePointer; \
1738  cb_data.args.hipHostGetDevicePointer.hstPtr = hostPointer; \
1739  cb_data.args.hipHostGetDevicePointer.flags = flags; \
1740 };
1741 // hipMemcpyParam2D[('const hip_Memcpy2D*', 'pCopy')]
1742 #define INIT_hipMemcpyParam2D_CB_ARGS_DATA(cb_data) { \
1743  cb_data.args.hipMemcpyParam2D.pCopy = pCopy; \
1744 };
1745 // hipModuleGetFunction[('hipFunction_t*', 'function'), ('hipModule_t', 'module'), ('const char*', 'kname')]
1746 #define INIT_hipModuleGetFunction_CB_ARGS_DATA(cb_data) { \
1747  cb_data.args.hipModuleGetFunction.function = hfunc; \
1748  cb_data.args.hipModuleGetFunction.module = hmod; \
1749  cb_data.args.hipModuleGetFunction.kname = name; \
1750 };
1751 // hipMemsetD32Async[('hipDeviceptr_t', 'dst'), ('int', 'value'), ('size_t', 'count'), ('hipStream_t', 'stream')]
1752 #define INIT_hipMemsetD32Async_CB_ARGS_DATA(cb_data) { \
1753  cb_data.args.hipMemsetD32Async.dst = dst; \
1754  cb_data.args.hipMemsetD32Async.value = value; \
1755  cb_data.args.hipMemsetD32Async.count = count; \
1756  cb_data.args.hipMemsetD32Async.stream = stream; \
1757 };
1758 // hipGetDevice[('int*', 'deviceId')]
1759 #define INIT_hipGetDevice_CB_ARGS_DATA(cb_data) { \
1760  cb_data.args.hipGetDevice.deviceId = deviceId; \
1761 };
1762 // hipGetDeviceCount[('int*', 'count')]
1763 #define INIT_hipGetDeviceCount_CB_ARGS_DATA(cb_data) { \
1764  cb_data.args.hipGetDeviceCount.count = count; \
1765 };
1766 #define INIT_CB_ARGS_DATA(cb_id, cb_data) INIT_##cb_id##_CB_ARGS_DATA(cb_data)
1767 
1768 #if 0
1769 // HIP API string method, method name and parameters
1770 const char* hipApiString(hip_api_id_t id, const hip_api_data_t* data) {
1771  std::ostringstream oss;
1772  switch (id) {
1773  case HIP_API_ID_hipStreamCreateWithPriority:
1774  oss << "hipStreamCreateWithPriority("
1775  << " stream=" << data->args.hipStreamCreateWithPriority.stream << ","
1776  << " flags=" << data->args.hipStreamCreateWithPriority.flags << ","
1777  << " priority=" << data->args.hipStreamCreateWithPriority.priority
1778  << ")";
1779  break;
1780  case HIP_API_ID_hipMemcpyToSymbolAsync:
1781  oss << "hipMemcpyToSymbolAsync("
1782  << " symbolName=" << data->args.hipMemcpyToSymbolAsync.symbolName << ","
1783  << " src=" << data->args.hipMemcpyToSymbolAsync.src << ","
1784  << " sizeBytes=" << data->args.hipMemcpyToSymbolAsync.sizeBytes << ","
1785  << " offset=" << data->args.hipMemcpyToSymbolAsync.offset << ","
1786  << " kind=" << data->args.hipMemcpyToSymbolAsync.kind << ","
1787  << " stream=" << data->args.hipMemcpyToSymbolAsync.stream
1788  << ")";
1789  break;
1790  case HIP_API_ID_hipMallocPitch:
1791  oss << "hipMallocPitch("
1792  << " ptr=" << data->args.hipMallocPitch.ptr << ","
1793  << " pitch=" << data->args.hipMallocPitch.pitch << ","
1794  << " width=" << data->args.hipMallocPitch.width << ","
1795  << " height=" << data->args.hipMallocPitch.height
1796  << ")";
1797  break;
1798  case HIP_API_ID_hipMalloc:
1799  oss << "hipMalloc("
1800  << " ptr=" << data->args.hipMalloc.ptr << ","
1801  << " size=" << data->args.hipMalloc.size
1802  << ")";
1803  break;
1804  case HIP_API_ID_hipDeviceGetName:
1805  oss << "hipDeviceGetName("
1806  << " name=" << data->args.hipDeviceGetName.name << ","
1807  << " len=" << data->args.hipDeviceGetName.len << ","
1808  << " device=" << data->args.hipDeviceGetName.device
1809  << ")";
1810  break;
1811  case HIP_API_ID_hipEventRecord:
1812  oss << "hipEventRecord("
1813  << " event=" << data->args.hipEventRecord.event << ","
1814  << " stream=" << data->args.hipEventRecord.stream
1815  << ")";
1816  break;
1817  case HIP_API_ID_hipCtxSynchronize:
1818  oss << "hipCtxSynchronize("
1819  << ")";
1820  break;
1821  case HIP_API_ID_hipSetDevice:
1822  oss << "hipSetDevice("
1823  << " deviceId=" << data->args.hipSetDevice.deviceId
1824  << ")";
1825  break;
1826  case HIP_API_ID_hipCtxGetApiVersion:
1827  oss << "hipCtxGetApiVersion("
1828  << " ctx=" << data->args.hipCtxGetApiVersion.ctx << ","
1829  << " apiVersion=" << data->args.hipCtxGetApiVersion.apiVersion
1830  << ")";
1831  break;
1832  case HIP_API_ID_hipSetupArgument:
1833  oss << "hipSetupArgument("
1834  << " arg=" << data->args.hipSetupArgument.arg << ","
1835  << " size=" << data->args.hipSetupArgument.size << ","
1836  << " offset=" << data->args.hipSetupArgument.offset
1837  << ")";
1838  break;
1839  case HIP_API_ID_hipMemcpyFromSymbolAsync:
1840  oss << "hipMemcpyFromSymbolAsync("
1841  << " dst=" << data->args.hipMemcpyFromSymbolAsync.dst << ","
1842  << " symbolName=" << data->args.hipMemcpyFromSymbolAsync.symbolName << ","
1843  << " sizeBytes=" << data->args.hipMemcpyFromSymbolAsync.sizeBytes << ","
1844  << " offset=" << data->args.hipMemcpyFromSymbolAsync.offset << ","
1845  << " kind=" << data->args.hipMemcpyFromSymbolAsync.kind << ","
1846  << " stream=" << data->args.hipMemcpyFromSymbolAsync.stream
1847  << ")";
1848  break;
1849  case HIP_API_ID_hipExtGetLinkTypeAndHopCount:
1850  oss << "hipExtGetLinkTypeAndHopCount("
1851  << " device1=" << data->args.hipExtGetLinkTypeAndHopCount.device1 << ","
1852  << " device2=" << data->args.hipExtGetLinkTypeAndHopCount.device2 << ","
1853  << " linktype=" << data->args.hipExtGetLinkTypeAndHopCount.linktype << ","
1854  << " hopcount=" << data->args.hipExtGetLinkTypeAndHopCount.hopcount
1855  << ")";
1856  break;
1857  case HIP_API_ID_hipMemcpyDtoD:
1858  oss << "hipMemcpyDtoD("
1859  << " dst=" << data->args.hipMemcpyDtoD.dst << ","
1860  << " src=" << data->args.hipMemcpyDtoD.src << ","
1861  << " sizeBytes=" << data->args.hipMemcpyDtoD.sizeBytes
1862  << ")";
1863  break;
1864  case HIP_API_ID_hipHostFree:
1865  oss << "hipHostFree("
1866  << " ptr=" << data->args.hipHostFree.ptr
1867  << ")";
1868  break;
1869  case HIP_API_ID_hipMemcpy2DToArray:
1870  oss << "hipMemcpy2DToArray("
1871  << " dst=" << data->args.hipMemcpy2DToArray.dst << ","
1872  << " wOffset=" << data->args.hipMemcpy2DToArray.wOffset << ","
1873  << " hOffset=" << data->args.hipMemcpy2DToArray.hOffset << ","
1874  << " src=" << data->args.hipMemcpy2DToArray.src << ","
1875  << " spitch=" << data->args.hipMemcpy2DToArray.spitch << ","
1876  << " width=" << data->args.hipMemcpy2DToArray.width << ","
1877  << " height=" << data->args.hipMemcpy2DToArray.height << ","
1878  << " kind=" << data->args.hipMemcpy2DToArray.kind
1879  << ")";
1880  break;
1881  case HIP_API_ID_hipCtxGetCacheConfig:
1882  oss << "hipCtxGetCacheConfig("
1883  << " cacheConfig=" << data->args.hipCtxGetCacheConfig.cacheConfig
1884  << ")";
1885  break;
1886  case HIP_API_ID_hipStreamWaitEvent:
1887  oss << "hipStreamWaitEvent("
1888  << " stream=" << data->args.hipStreamWaitEvent.stream << ","
1889  << " event=" << data->args.hipStreamWaitEvent.event << ","
1890  << " flags=" << data->args.hipStreamWaitEvent.flags
1891  << ")";
1892  break;
1893  case HIP_API_ID_hipDeviceGetStreamPriorityRange:
1894  oss << "hipDeviceGetStreamPriorityRange("
1895  << " leastPriority=" << data->args.hipDeviceGetStreamPriorityRange.leastPriority << ","
1896  << " greatestPriority=" << data->args.hipDeviceGetStreamPriorityRange.greatestPriority
1897  << ")";
1898  break;
1899  case HIP_API_ID_hipModuleLoad:
1900  oss << "hipModuleLoad("
1901  << " module=" << data->args.hipModuleLoad.module << ","
1902  << " fname=" << data->args.hipModuleLoad.fname
1903  << ")";
1904  break;
1905  case HIP_API_ID_hipDevicePrimaryCtxSetFlags:
1906  oss << "hipDevicePrimaryCtxSetFlags("
1907  << " dev=" << data->args.hipDevicePrimaryCtxSetFlags.dev << ","
1908  << " flags=" << data->args.hipDevicePrimaryCtxSetFlags.flags
1909  << ")";
1910  break;
1911  case HIP_API_ID_hipMemcpyAsync:
1912  oss << "hipMemcpyAsync("
1913  << " dst=" << data->args.hipMemcpyAsync.dst << ","
1914  << " src=" << data->args.hipMemcpyAsync.src << ","
1915  << " sizeBytes=" << data->args.hipMemcpyAsync.sizeBytes << ","
1916  << " kind=" << data->args.hipMemcpyAsync.kind << ","
1917  << " stream=" << data->args.hipMemcpyAsync.stream
1918  << ")";
1919  break;
1920  case HIP_API_ID_hipMalloc3DArray:
1921  oss << "hipMalloc3DArray("
1922  << " array=" << data->args.hipMalloc3DArray.array << ","
1923  << " desc=" << data->args.hipMalloc3DArray.desc << ","
1924  << " extent=" << data->args.hipMalloc3DArray.extent << ","
1925  << " flags=" << data->args.hipMalloc3DArray.flags
1926  << ")";
1927  break;
1928  case HIP_API_ID_hipStreamCreate:
1929  oss << "hipStreamCreate("
1930  << " stream=" << data->args.hipStreamCreate.stream
1931  << ")";
1932  break;
1933  case HIP_API_ID_hipCtxGetCurrent:
1934  oss << "hipCtxGetCurrent("
1935  << " ctx=" << data->args.hipCtxGetCurrent.ctx
1936  << ")";
1937  break;
1938  case HIP_API_ID_hipDevicePrimaryCtxGetState:
1939  oss << "hipDevicePrimaryCtxGetState("
1940  << " dev=" << data->args.hipDevicePrimaryCtxGetState.dev << ","
1941  << " flags=" << data->args.hipDevicePrimaryCtxGetState.flags << ","
1942  << " active=" << data->args.hipDevicePrimaryCtxGetState.active
1943  << ")";
1944  break;
1945  case HIP_API_ID_hipEventQuery:
1946  oss << "hipEventQuery("
1947  << " event=" << data->args.hipEventQuery.event
1948  << ")";
1949  break;
1950  case HIP_API_ID_hipEventCreate:
1951  oss << "hipEventCreate("
1952  << " event=" << data->args.hipEventCreate.event
1953  << ")";
1954  break;
1955  case HIP_API_ID_hipMemGetAddressRange:
1956  oss << "hipMemGetAddressRange("
1957  << " pbase=" << data->args.hipMemGetAddressRange.pbase << ","
1958  << " psize=" << data->args.hipMemGetAddressRange.psize << ","
1959  << " dptr=" << data->args.hipMemGetAddressRange.dptr
1960  << ")";
1961  break;
1962  case HIP_API_ID_hipMemcpyFromSymbol:
1963  oss << "hipMemcpyFromSymbol("
1964  << " dst=" << data->args.hipMemcpyFromSymbol.dst << ","
1965  << " symbolName=" << data->args.hipMemcpyFromSymbol.symbolName << ","
1966  << " sizeBytes=" << data->args.hipMemcpyFromSymbol.sizeBytes << ","
1967  << " offset=" << data->args.hipMemcpyFromSymbol.offset << ","
1968  << " kind=" << data->args.hipMemcpyFromSymbol.kind
1969  << ")";
1970  break;
1971  case HIP_API_ID_hipArrayCreate:
1972  oss << "hipArrayCreate("
1973  << " pHandle=" << data->args.hipArrayCreate.pHandle << ","
1974  << " pAllocateArray=" << data->args.hipArrayCreate.pAllocateArray
1975  << ")";
1976  break;
1977  case HIP_API_ID_hipStreamGetFlags:
1978  oss << "hipStreamGetFlags("
1979  << " stream=" << data->args.hipStreamGetFlags.stream << ","
1980  << " flags=" << data->args.hipStreamGetFlags.flags
1981  << ")";
1982  break;
1983  case HIP_API_ID_hipMallocArray:
1984  oss << "hipMallocArray("
1985  << " array=" << data->args.hipMallocArray.array << ","
1986  << " desc=" << data->args.hipMallocArray.desc << ","
1987  << " width=" << data->args.hipMallocArray.width << ","
1988  << " height=" << data->args.hipMallocArray.height << ","
1989  << " flags=" << data->args.hipMallocArray.flags
1990  << ")";
1991  break;
1992  case HIP_API_ID_hipCtxGetSharedMemConfig:
1993  oss << "hipCtxGetSharedMemConfig("
1994  << " pConfig=" << data->args.hipCtxGetSharedMemConfig.pConfig
1995  << ")";
1996  break;
1997  case HIP_API_ID_hipMemPtrGetInfo:
1998  oss << "hipMemPtrGetInfo("
1999  << " ptr=" << data->args.hipMemPtrGetInfo.ptr << ","
2000  << " size=" << data->args.hipMemPtrGetInfo.size
2001  << ")";
2002  break;
2003  case HIP_API_ID_hipCtxGetFlags:
2004  oss << "hipCtxGetFlags("
2005  << " flags=" << data->args.hipCtxGetFlags.flags
2006  << ")";
2007  break;
2008  case HIP_API_ID_hipStreamDestroy:
2009  oss << "hipStreamDestroy("
2010  << " stream=" << data->args.hipStreamDestroy.stream
2011  << ")";
2012  break;
2013  case HIP_API_ID_hipMemset3DAsync:
2014  oss << "hipMemset3DAsync("
2015  << " pitchedDevPtr=" << data->args.hipMemset3DAsync.pitchedDevPtr << ","
2016  << " value=" << data->args.hipMemset3DAsync.value << ","
2017  << " extent=" << data->args.hipMemset3DAsync.extent << ","
2018  << " stream=" << data->args.hipMemset3DAsync.stream
2019  << ")";
2020  break;
2021  case HIP_API_ID_hipMemcpy3D:
2022  oss << "hipMemcpy3D("
2023  << " p=" << data->args.hipMemcpy3D.p
2024  << ")";
2025  break;
2026  case HIP_API_ID_hipInit:
2027  oss << "hipInit("
2028  << " flags=" << data->args.hipInit.flags
2029  << ")";
2030  break;
2031  case HIP_API_ID_hipMemcpyAtoH:
2032  oss << "hipMemcpyAtoH("
2033  << " dst=" << data->args.hipMemcpyAtoH.dst << ","
2034  << " srcArray=" << data->args.hipMemcpyAtoH.srcArray << ","
2035  << " srcOffset=" << data->args.hipMemcpyAtoH.srcOffset << ","
2036  << " count=" << data->args.hipMemcpyAtoH.count
2037  << ")";
2038  break;
2039  case HIP_API_ID_hipStreamGetPriority:
2040  oss << "hipStreamGetPriority("
2041  << " stream=" << data->args.hipStreamGetPriority.stream << ","
2042  << " priority=" << data->args.hipStreamGetPriority.priority
2043  << ")";
2044  break;
2045  case HIP_API_ID_hipMemset2D:
2046  oss << "hipMemset2D("
2047  << " dst=" << data->args.hipMemset2D.dst << ","
2048  << " pitch=" << data->args.hipMemset2D.pitch << ","
2049  << " value=" << data->args.hipMemset2D.value << ","
2050  << " width=" << data->args.hipMemset2D.width << ","
2051  << " height=" << data->args.hipMemset2D.height
2052  << ")";
2053  break;
2054  case HIP_API_ID_hipMemset2DAsync:
2055  oss << "hipMemset2DAsync("
2056  << " dst=" << data->args.hipMemset2DAsync.dst << ","
2057  << " pitch=" << data->args.hipMemset2DAsync.pitch << ","
2058  << " value=" << data->args.hipMemset2DAsync.value << ","
2059  << " width=" << data->args.hipMemset2DAsync.width << ","
2060  << " height=" << data->args.hipMemset2DAsync.height << ","
2061  << " stream=" << data->args.hipMemset2DAsync.stream
2062  << ")";
2063  break;
2064  case HIP_API_ID_hipDeviceCanAccessPeer:
2065  oss << "hipDeviceCanAccessPeer("
2066  << " canAccessPeer=" << data->args.hipDeviceCanAccessPeer.canAccessPeer << ","
2067  << " deviceId=" << data->args.hipDeviceCanAccessPeer.deviceId << ","
2068  << " peerDeviceId=" << data->args.hipDeviceCanAccessPeer.peerDeviceId
2069  << ")";
2070  break;
2071  case HIP_API_ID_hipDeviceEnablePeerAccess:
2072  oss << "hipDeviceEnablePeerAccess("
2073  << " peerDeviceId=" << data->args.hipDeviceEnablePeerAccess.peerDeviceId << ","
2074  << " flags=" << data->args.hipDeviceEnablePeerAccess.flags
2075  << ")";
2076  break;
2077  case HIP_API_ID_hipModuleUnload:
2078  oss << "hipModuleUnload("
2079  << " module=" << data->args.hipModuleUnload.module
2080  << ")";
2081  break;
2082  case HIP_API_ID_hipHostUnregister:
2083  oss << "hipHostUnregister("
2084  << " hostPtr=" << data->args.hipHostUnregister.hostPtr
2085  << ")";
2086  break;
2087  case HIP_API_ID_hipProfilerStop:
2088  oss << "hipProfilerStop("
2089  << ")";
2090  break;
2091  case HIP_API_ID_hipLaunchByPtr:
2092  oss << "hipLaunchByPtr("
2093  << " func=" << data->args.hipLaunchByPtr.func
2094  << ")";
2095  break;
2096  case HIP_API_ID_hipStreamSynchronize:
2097  oss << "hipStreamSynchronize("
2098  << " stream=" << data->args.hipStreamSynchronize.stream
2099  << ")";
2100  break;
2101  case HIP_API_ID_hipDeviceSetCacheConfig:
2102  oss << "hipDeviceSetCacheConfig("
2103  << " cacheConfig=" << data->args.hipDeviceSetCacheConfig.cacheConfig
2104  << ")";
2105  break;
2106  case HIP_API_ID_hipGetErrorName:
2107  oss << "hipGetErrorName("
2108  << " hip_error=" << data->args.hipGetErrorName.hip_error
2109  << ")";
2110  break;
2111  case HIP_API_ID_hipMemcpyHtoD:
2112  oss << "hipMemcpyHtoD("
2113  << " dst=" << data->args.hipMemcpyHtoD.dst << ","
2114  << " src=" << data->args.hipMemcpyHtoD.src << ","
2115  << " sizeBytes=" << data->args.hipMemcpyHtoD.sizeBytes
2116  << ")";
2117  break;
2118  case HIP_API_ID_hipModuleGetGlobal:
2119  oss << "hipModuleGetGlobal("
2120  << " dptr=" << data->args.hipModuleGetGlobal.dptr << ","
2121  << " bytes=" << data->args.hipModuleGetGlobal.bytes << ","
2122  << " hmod=" << data->args.hipModuleGetGlobal.hmod << ","
2123  << " name=" << data->args.hipModuleGetGlobal.name
2124  << ")";
2125  break;
2126  case HIP_API_ID_hipMemcpyHtoA:
2127  oss << "hipMemcpyHtoA("
2128  << " dstArray=" << data->args.hipMemcpyHtoA.dstArray << ","
2129  << " dstOffset=" << data->args.hipMemcpyHtoA.dstOffset << ","
2130  << " srcHost=" << data->args.hipMemcpyHtoA.srcHost << ","
2131  << " count=" << data->args.hipMemcpyHtoA.count
2132  << ")";
2133  break;
2134  case HIP_API_ID_hipCtxCreate:
2135  oss << "hipCtxCreate("
2136  << " ctx=" << data->args.hipCtxCreate.ctx << ","
2137  << " flags=" << data->args.hipCtxCreate.flags << ","
2138  << " device=" << data->args.hipCtxCreate.device
2139  << ")";
2140  break;
2141  case HIP_API_ID_hipMemcpy2D:
2142  oss << "hipMemcpy2D("
2143  << " dst=" << data->args.hipMemcpy2D.dst << ","
2144  << " dpitch=" << data->args.hipMemcpy2D.dpitch << ","
2145  << " src=" << data->args.hipMemcpy2D.src << ","
2146  << " spitch=" << data->args.hipMemcpy2D.spitch << ","
2147  << " width=" << data->args.hipMemcpy2D.width << ","
2148  << " height=" << data->args.hipMemcpy2D.height << ","
2149  << " kind=" << data->args.hipMemcpy2D.kind
2150  << ")";
2151  break;
2152  case HIP_API_ID_hipIpcCloseMemHandle:
2153  oss << "hipIpcCloseMemHandle("
2154  << " devPtr=" << data->args.hipIpcCloseMemHandle.devPtr
2155  << ")";
2156  break;
2157  case HIP_API_ID_hipChooseDevice:
2158  oss << "hipChooseDevice("
2159  << " device=" << data->args.hipChooseDevice.device << ","
2160  << " prop=" << data->args.hipChooseDevice.prop
2161  << ")";
2162  break;
2163  case HIP_API_ID_hipDeviceSetSharedMemConfig:
2164  oss << "hipDeviceSetSharedMemConfig("
2165  << " config=" << data->args.hipDeviceSetSharedMemConfig.config
2166  << ")";
2167  break;
2168  case HIP_API_ID_hipDeviceComputeCapability:
2169  oss << "hipDeviceComputeCapability("
2170  << " major=" << data->args.hipDeviceComputeCapability.major << ","
2171  << " minor=" << data->args.hipDeviceComputeCapability.minor << ","
2172  << " device=" << data->args.hipDeviceComputeCapability.device
2173  << ")";
2174  break;
2175  case HIP_API_ID_hipDeviceGet:
2176  oss << "hipDeviceGet("
2177  << " device=" << data->args.hipDeviceGet.device << ","
2178  << " ordinal=" << data->args.hipDeviceGet.ordinal
2179  << ")";
2180  break;
2181  case HIP_API_ID_hipProfilerStart:
2182  oss << "hipProfilerStart("
2183  << ")";
2184  break;
2185  case HIP_API_ID_hipCtxSetCacheConfig:
2186  oss << "hipCtxSetCacheConfig("
2187  << " cacheConfig=" << data->args.hipCtxSetCacheConfig.cacheConfig
2188  << ")";
2189  break;
2190  case HIP_API_ID_hipFuncSetCacheConfig:
2191  oss << "hipFuncSetCacheConfig("
2192  << " func=" << data->args.hipFuncSetCacheConfig.func << ","
2193  << " config=" << data->args.hipFuncSetCacheConfig.config
2194  << ")";
2195  break;
2196  case HIP_API_ID_hipMemcpyPeerAsync:
2197  oss << "hipMemcpyPeerAsync("
2198  << " dst=" << data->args.hipMemcpyPeerAsync.dst << ","
2199  << " dstDeviceId=" << data->args.hipMemcpyPeerAsync.dstDeviceId << ","
2200  << " src=" << data->args.hipMemcpyPeerAsync.src << ","
2201  << " srcDevice=" << data->args.hipMemcpyPeerAsync.srcDevice << ","
2202  << " sizeBytes=" << data->args.hipMemcpyPeerAsync.sizeBytes << ","
2203  << " stream=" << data->args.hipMemcpyPeerAsync.stream
2204  << ")";
2205  break;
2206  case HIP_API_ID_hipEventElapsedTime:
2207  oss << "hipEventElapsedTime("
2208  << " ms=" << data->args.hipEventElapsedTime.ms << ","
2209  << " start=" << data->args.hipEventElapsedTime.start << ","
2210  << " stop=" << data->args.hipEventElapsedTime.stop
2211  << ")";
2212  break;
2213  case HIP_API_ID_hipDevicePrimaryCtxReset:
2214  oss << "hipDevicePrimaryCtxReset("
2215  << " dev=" << data->args.hipDevicePrimaryCtxReset.dev
2216  << ")";
2217  break;
2218  case HIP_API_ID_hipEventDestroy:
2219  oss << "hipEventDestroy("
2220  << " event=" << data->args.hipEventDestroy.event
2221  << ")";
2222  break;
2223  case HIP_API_ID_hipCtxPopCurrent:
2224  oss << "hipCtxPopCurrent("
2225  << " ctx=" << data->args.hipCtxPopCurrent.ctx
2226  << ")";
2227  break;
2228  case HIP_API_ID_hipGetSymbolAddress:
2229  oss << "hipGetSymbolAddress("
2230  << " devPtr=" << data->args.hipGetSymbolAddress.devPtr << ","
2231  << " symbolName=" << data->args.hipGetSymbolAddress.symbolName
2232  << ")";
2233  break;
2234  case HIP_API_ID_hipHostGetFlags:
2235  oss << "hipHostGetFlags("
2236  << " flagsPtr=" << data->args.hipHostGetFlags.flagsPtr << ","
2237  << " hostPtr=" << data->args.hipHostGetFlags.hostPtr
2238  << ")";
2239  break;
2240  case HIP_API_ID_hipHostMalloc:
2241  oss << "hipHostMalloc("
2242  << " ptr=" << data->args.hipHostMalloc.ptr << ","
2243  << " size=" << data->args.hipHostMalloc.size << ","
2244  << " flags=" << data->args.hipHostMalloc.flags
2245  << ")";
2246  break;
2247  case HIP_API_ID_hipDriverGetVersion:
2248  oss << "hipDriverGetVersion("
2249  << " driverVersion=" << data->args.hipDriverGetVersion.driverVersion
2250  << ")";
2251  break;
2252  case HIP_API_ID_hipMemGetInfo:
2253  oss << "hipMemGetInfo("
2254  << " free=" << data->args.hipMemGetInfo.free << ","
2255  << " total=" << data->args.hipMemGetInfo.total
2256  << ")";
2257  break;
2258  case HIP_API_ID_hipDeviceReset:
2259  oss << "hipDeviceReset("
2260  << ")";
2261  break;
2262  case HIP_API_ID_hipMemset:
2263  oss << "hipMemset("
2264  << " dst=" << data->args.hipMemset.dst << ","
2265  << " value=" << data->args.hipMemset.value << ","
2266  << " sizeBytes=" << data->args.hipMemset.sizeBytes
2267  << ")";
2268  break;
2269  case HIP_API_ID_hipMemsetD8:
2270  oss << "hipMemsetD8("
2271  << " dest=" << data->args.hipMemsetD8.dest << ","
2272  << " value=" << data->args.hipMemsetD8.value << ","
2273  << " sizeBytes=" << data->args.hipMemsetD8.sizeBytes
2274  << ")";
2275  break;
2276  case HIP_API_ID_hipHostRegister:
2277  oss << "hipHostRegister("
2278  << " hostPtr=" << data->args.hipHostRegister.hostPtr << ","
2279  << " sizeBytes=" << data->args.hipHostRegister.sizeBytes << ","
2280  << " flags=" << data->args.hipHostRegister.flags
2281  << ")";
2282  break;
2283  case HIP_API_ID_hipCtxSetSharedMemConfig:
2284  oss << "hipCtxSetSharedMemConfig("
2285  << " config=" << data->args.hipCtxSetSharedMemConfig.config
2286  << ")";
2287  break;
2288  case HIP_API_ID_hipArray3DCreate:
2289  oss << "hipArray3DCreate("
2290  << " array=" << data->args.hipArray3DCreate.array << ","
2291  << " pAllocateArray=" << data->args.hipArray3DCreate.pAllocateArray
2292  << ")";
2293  break;
2294  case HIP_API_ID_hipIpcOpenMemHandle:
2295  oss << "hipIpcOpenMemHandle("
2296  << " devPtr=" << data->args.hipIpcOpenMemHandle.devPtr << ","
2297  << " handle=" << data->args.hipIpcOpenMemHandle.handle << ","
2298  << " flags=" << data->args.hipIpcOpenMemHandle.flags
2299  << ")";
2300  break;
2301  case HIP_API_ID_hipGetLastError:
2302  oss << "hipGetLastError("
2303  << ")";
2304  break;
2305  case HIP_API_ID_hipCtxDestroy:
2306  oss << "hipCtxDestroy("
2307  << " ctx=" << data->args.hipCtxDestroy.ctx
2308  << ")";
2309  break;
2310  case HIP_API_ID_hipDeviceGetSharedMemConfig:
2311  oss << "hipDeviceGetSharedMemConfig("
2312  << " pConfig=" << data->args.hipDeviceGetSharedMemConfig.pConfig
2313  << ")";
2314  break;
2315  case HIP_API_ID_hipSetDeviceFlags:
2316  oss << "hipSetDeviceFlags("
2317  << " flags=" << data->args.hipSetDeviceFlags.flags
2318  << ")";
2319  break;
2320  case HIP_API_ID_hipHccModuleLaunchKernel:
2321  oss << "hipHccModuleLaunchKernel("
2322  << " f=" << data->args.hipHccModuleLaunchKernel.f << ","
2323  << " globalWorkSizeX=" << data->args.hipHccModuleLaunchKernel.globalWorkSizeX << ","
2324  << " globalWorkSizeY=" << data->args.hipHccModuleLaunchKernel.globalWorkSizeY << ","
2325  << " globalWorkSizeZ=" << data->args.hipHccModuleLaunchKernel.globalWorkSizeZ << ","
2326  << " localWorkSizeX=" << data->args.hipHccModuleLaunchKernel.localWorkSizeX << ","
2327  << " localWorkSizeY=" << data->args.hipHccModuleLaunchKernel.localWorkSizeY << ","
2328  << " localWorkSizeZ=" << data->args.hipHccModuleLaunchKernel.localWorkSizeZ << ","
2329  << " sharedMemBytes=" << data->args.hipHccModuleLaunchKernel.sharedMemBytes << ","
2330  << " hStream=" << data->args.hipHccModuleLaunchKernel.hStream << ","
2331  << " kernelParams=" << data->args.hipHccModuleLaunchKernel.kernelParams << ","
2332  << " extra=" << data->args.hipHccModuleLaunchKernel.extra << ","
2333  << " startEvent=" << data->args.hipHccModuleLaunchKernel.startEvent << ","
2334  << " stopEvent=" << data->args.hipHccModuleLaunchKernel.stopEvent
2335  << ")";
2336  break;
2337  case HIP_API_ID_hipFree:
2338  oss << "hipFree("
2339  << " ptr=" << data->args.hipFree.ptr
2340  << ")";
2341  break;
2342  case HIP_API_ID_hipDeviceGetAttribute:
2343  oss << "hipDeviceGetAttribute("
2344  << " pi=" << data->args.hipDeviceGetAttribute.pi << ","
2345  << " attr=" << data->args.hipDeviceGetAttribute.attr << ","
2346  << " deviceId=" << data->args.hipDeviceGetAttribute.deviceId
2347  << ")";
2348  break;
2349  case HIP_API_ID_hipMemcpyDtoH:
2350  oss << "hipMemcpyDtoH("
2351  << " dst=" << data->args.hipMemcpyDtoH.dst << ","
2352  << " src=" << data->args.hipMemcpyDtoH.src << ","
2353  << " sizeBytes=" << data->args.hipMemcpyDtoH.sizeBytes
2354  << ")";
2355  break;
2356  case HIP_API_ID_hipCtxDisablePeerAccess:
2357  oss << "hipCtxDisablePeerAccess("
2358  << " peerCtx=" << data->args.hipCtxDisablePeerAccess.peerCtx
2359  << ")";
2360  break;
2361  case HIP_API_ID_hipMallocManaged:
2362  oss << "hipMallocManaged("
2363  << " devPtr=" << data->args.hipMallocManaged.devPtr << ","
2364  << " size=" << data->args.hipMallocManaged.size << ","
2365  << " flags=" << data->args.hipMallocManaged.flags
2366  << ")";
2367  break;
2368  case HIP_API_ID_hipDeviceGetByPCIBusId:
2369  oss << "hipDeviceGetByPCIBusId("
2370  << " device=" << data->args.hipDeviceGetByPCIBusId.device << ","
2371  << " pciBusId=" << data->args.hipDeviceGetByPCIBusId.pciBusId
2372  << ")";
2373  break;
2374  case HIP_API_ID_hipIpcGetMemHandle:
2375  oss << "hipIpcGetMemHandle("
2376  << " handle=" << data->args.hipIpcGetMemHandle.handle << ","
2377  << " devPtr=" << data->args.hipIpcGetMemHandle.devPtr
2378  << ")";
2379  break;
2380  case HIP_API_ID_hipMemcpyHtoDAsync:
2381  oss << "hipMemcpyHtoDAsync("
2382  << " dst=" << data->args.hipMemcpyHtoDAsync.dst << ","
2383  << " src=" << data->args.hipMemcpyHtoDAsync.src << ","
2384  << " sizeBytes=" << data->args.hipMemcpyHtoDAsync.sizeBytes << ","
2385  << " stream=" << data->args.hipMemcpyHtoDAsync.stream
2386  << ")";
2387  break;
2388  case HIP_API_ID_hipCtxGetDevice:
2389  oss << "hipCtxGetDevice("
2390  << " device=" << data->args.hipCtxGetDevice.device
2391  << ")";
2392  break;
2393  case HIP_API_ID_hipMemset3D:
2394  oss << "hipMemset3D("
2395  << " pitchedDevPtr=" << data->args.hipMemset3D.pitchedDevPtr << ","
2396  << " value=" << data->args.hipMemset3D.value << ","
2397  << " extent=" << data->args.hipMemset3D.extent
2398  << ")";
2399  break;
2400  case HIP_API_ID_hipModuleLoadData:
2401  oss << "hipModuleLoadData("
2402  << " module=" << data->args.hipModuleLoadData.module << ","
2403  << " image=" << data->args.hipModuleLoadData.image
2404  << ")";
2405  break;
2406  case HIP_API_ID_hipDeviceTotalMem:
2407  oss << "hipDeviceTotalMem("
2408  << " bytes=" << data->args.hipDeviceTotalMem.bytes << ","
2409  << " device=" << data->args.hipDeviceTotalMem.device
2410  << ")";
2411  break;
2412  case HIP_API_ID_hipCtxSetCurrent:
2413  oss << "hipCtxSetCurrent("
2414  << " ctx=" << data->args.hipCtxSetCurrent.ctx
2415  << ")";
2416  break;
2417  case HIP_API_ID_hipGetErrorString:
2418  oss << "hipGetErrorString("
2419  << " hipError=" << data->args.hipGetErrorString.hipError
2420  << ")";
2421  break;
2422  case HIP_API_ID_hipDevicePrimaryCtxRetain:
2423  oss << "hipDevicePrimaryCtxRetain("
2424  << " pctx=" << data->args.hipDevicePrimaryCtxRetain.pctx << ","
2425  << " dev=" << data->args.hipDevicePrimaryCtxRetain.dev
2426  << ")";
2427  break;
2428  case HIP_API_ID_hipDeviceDisablePeerAccess:
2429  oss << "hipDeviceDisablePeerAccess("
2430  << " peerDeviceId=" << data->args.hipDeviceDisablePeerAccess.peerDeviceId
2431  << ")";
2432  break;
2433  case HIP_API_ID_hipStreamCreateWithFlags:
2434  oss << "hipStreamCreateWithFlags("
2435  << " stream=" << data->args.hipStreamCreateWithFlags.stream << ","
2436  << " flags=" << data->args.hipStreamCreateWithFlags.flags
2437  << ")";
2438  break;
2439  case HIP_API_ID_hipMemcpyFromArray:
2440  oss << "hipMemcpyFromArray("
2441  << " dst=" << data->args.hipMemcpyFromArray.dst << ","
2442  << " srcArray=" << data->args.hipMemcpyFromArray.srcArray << ","
2443  << " wOffset=" << data->args.hipMemcpyFromArray.wOffset << ","
2444  << " hOffset=" << data->args.hipMemcpyFromArray.hOffset << ","
2445  << " count=" << data->args.hipMemcpyFromArray.count << ","
2446  << " kind=" << data->args.hipMemcpyFromArray.kind
2447  << ")";
2448  break;
2449  case HIP_API_ID_hipMemcpy2DAsync:
2450  oss << "hipMemcpy2DAsync("
2451  << " dst=" << data->args.hipMemcpy2DAsync.dst << ","
2452  << " dpitch=" << data->args.hipMemcpy2DAsync.dpitch << ","
2453  << " src=" << data->args.hipMemcpy2DAsync.src << ","
2454  << " spitch=" << data->args.hipMemcpy2DAsync.spitch << ","
2455  << " width=" << data->args.hipMemcpy2DAsync.width << ","
2456  << " height=" << data->args.hipMemcpy2DAsync.height << ","
2457  << " kind=" << data->args.hipMemcpy2DAsync.kind << ","
2458  << " stream=" << data->args.hipMemcpy2DAsync.stream
2459  << ")";
2460  break;
2461  case HIP_API_ID_hipGetSymbolSize:
2462  oss << "hipGetSymbolSize("
2463  << " size=" << data->args.hipGetSymbolSize.size << ","
2464  << " symbolName=" << data->args.hipGetSymbolSize.symbolName
2465  << ")";
2466  break;
2467  case HIP_API_ID_hipEventCreateWithFlags:
2468  oss << "hipEventCreateWithFlags("
2469  << " event=" << data->args.hipEventCreateWithFlags.event << ","
2470  << " flags=" << data->args.hipEventCreateWithFlags.flags
2471  << ")";
2472  break;
2473  case HIP_API_ID_hipStreamQuery:
2474  oss << "hipStreamQuery("
2475  << " stream=" << data->args.hipStreamQuery.stream
2476  << ")";
2477  break;
2478  case HIP_API_ID_hipDeviceGetPCIBusId:
2479  oss << "hipDeviceGetPCIBusId("
2480  << " pciBusId=" << data->args.hipDeviceGetPCIBusId.pciBusId << ","
2481  << " len=" << data->args.hipDeviceGetPCIBusId.len << ","
2482  << " device=" << data->args.hipDeviceGetPCIBusId.device
2483  << ")";
2484  break;
2485  case HIP_API_ID_hipMemcpy:
2486  oss << "hipMemcpy("
2487  << " dst=" << data->args.hipMemcpy.dst << ","
2488  << " src=" << data->args.hipMemcpy.src << ","
2489  << " sizeBytes=" << data->args.hipMemcpy.sizeBytes << ","
2490  << " kind=" << data->args.hipMemcpy.kind
2491  << ")";
2492  break;
2493  case HIP_API_ID_hipPeekAtLastError:
2494  oss << "hipPeekAtLastError("
2495  << ")";
2496  break;
2497  case HIP_API_ID_hipStreamAddCallback:
2498  oss << "hipStreamAddCallback("
2499  << " stream=" << data->args.hipStreamAddCallback.stream << ","
2500  << " callback=" << data->args.hipStreamAddCallback.callback << ","
2501  << " userData=" << data->args.hipStreamAddCallback.userData << ","
2502  << " flags=" << data->args.hipStreamAddCallback.flags
2503  << ")";
2504  break;
2505  case HIP_API_ID_hipMemcpyToArray:
2506  oss << "hipMemcpyToArray("
2507  << " dst=" << data->args.hipMemcpyToArray.dst << ","
2508  << " wOffset=" << data->args.hipMemcpyToArray.wOffset << ","
2509  << " hOffset=" << data->args.hipMemcpyToArray.hOffset << ","
2510  << " src=" << data->args.hipMemcpyToArray.src << ","
2511  << " count=" << data->args.hipMemcpyToArray.count << ","
2512  << " kind=" << data->args.hipMemcpyToArray.kind
2513  << ")";
2514  break;
2515  case HIP_API_ID_hipMemsetD32:
2516  oss << "hipMemsetD32("
2517  << " dest=" << data->args.hipMemsetD32.dest << ","
2518  << " value=" << data->args.hipMemsetD32.value << ","
2519  << " count=" << data->args.hipMemsetD32.count
2520  << ")";
2521  break;
2522  case HIP_API_ID_hipDeviceSynchronize:
2523  oss << "hipDeviceSynchronize("
2524  << ")";
2525  break;
2526  case HIP_API_ID_hipDeviceGetCacheConfig:
2527  oss << "hipDeviceGetCacheConfig("
2528  << " cacheConfig=" << data->args.hipDeviceGetCacheConfig.cacheConfig
2529  << ")";
2530  break;
2531  case HIP_API_ID_hipMalloc3D:
2532  oss << "hipMalloc3D("
2533  << " pitchedDevPtr=" << data->args.hipMalloc3D.pitchedDevPtr << ","
2534  << " extent=" << data->args.hipMalloc3D.extent
2535  << ")";
2536  break;
2537  case HIP_API_ID_hipPointerGetAttributes:
2538  oss << "hipPointerGetAttributes("
2539  << " attributes=" << data->args.hipPointerGetAttributes.attributes << ","
2540  << " ptr=" << data->args.hipPointerGetAttributes.ptr
2541  << ")";
2542  break;
2543  case HIP_API_ID_hipMemsetAsync:
2544  oss << "hipMemsetAsync("
2545  << " dst=" << data->args.hipMemsetAsync.dst << ","
2546  << " value=" << data->args.hipMemsetAsync.value << ","
2547  << " sizeBytes=" << data->args.hipMemsetAsync.sizeBytes << ","
2548  << " stream=" << data->args.hipMemsetAsync.stream
2549  << ")";
2550  break;
2551  case HIP_API_ID_hipMemcpyToSymbol:
2552  oss << "hipMemcpyToSymbol("
2553  << " symbolName=" << data->args.hipMemcpyToSymbol.symbolName << ","
2554  << " src=" << data->args.hipMemcpyToSymbol.src << ","
2555  << " sizeBytes=" << data->args.hipMemcpyToSymbol.sizeBytes << ","
2556  << " offset=" << data->args.hipMemcpyToSymbol.offset << ","
2557  << " kind=" << data->args.hipMemcpyToSymbol.kind
2558  << ")";
2559  break;
2560  case HIP_API_ID_hipCtxPushCurrent:
2561  oss << "hipCtxPushCurrent("
2562  << " ctx=" << data->args.hipCtxPushCurrent.ctx
2563  << ")";
2564  break;
2565  case HIP_API_ID_hipMemcpyPeer:
2566  oss << "hipMemcpyPeer("
2567  << " dst=" << data->args.hipMemcpyPeer.dst << ","
2568  << " dstDeviceId=" << data->args.hipMemcpyPeer.dstDeviceId << ","
2569  << " src=" << data->args.hipMemcpyPeer.src << ","
2570  << " srcDeviceId=" << data->args.hipMemcpyPeer.srcDeviceId << ","
2571  << " sizeBytes=" << data->args.hipMemcpyPeer.sizeBytes
2572  << ")";
2573  break;
2574  case HIP_API_ID_hipEventSynchronize:
2575  oss << "hipEventSynchronize("
2576  << " event=" << data->args.hipEventSynchronize.event
2577  << ")";
2578  break;
2579  case HIP_API_ID_hipMemcpyDtoDAsync:
2580  oss << "hipMemcpyDtoDAsync("
2581  << " dst=" << data->args.hipMemcpyDtoDAsync.dst << ","
2582  << " src=" << data->args.hipMemcpyDtoDAsync.src << ","
2583  << " sizeBytes=" << data->args.hipMemcpyDtoDAsync.sizeBytes << ","
2584  << " stream=" << data->args.hipMemcpyDtoDAsync.stream
2585  << ")";
2586  break;
2587  case HIP_API_ID_hipExtMallocWithFlags:
2588  oss << "hipExtMallocWithFlags("
2589  << " ptr=" << data->args.hipExtMallocWithFlags.ptr << ","
2590  << " sizeBytes=" << data->args.hipExtMallocWithFlags.sizeBytes << ","
2591  << " flags=" << data->args.hipExtMallocWithFlags.flags
2592  << ")";
2593  break;
2594  case HIP_API_ID_hipCtxEnablePeerAccess:
2595  oss << "hipCtxEnablePeerAccess("
2596  << " peerCtx=" << data->args.hipCtxEnablePeerAccess.peerCtx << ","
2597  << " flags=" << data->args.hipCtxEnablePeerAccess.flags
2598  << ")";
2599  break;
2600  case HIP_API_ID_hipMemcpyDtoHAsync:
2601  oss << "hipMemcpyDtoHAsync("
2602  << " dst=" << data->args.hipMemcpyDtoHAsync.dst << ","
2603  << " src=" << data->args.hipMemcpyDtoHAsync.src << ","
2604  << " sizeBytes=" << data->args.hipMemcpyDtoHAsync.sizeBytes << ","
2605  << " stream=" << data->args.hipMemcpyDtoHAsync.stream
2606  << ")";
2607  break;
2608  case HIP_API_ID_hipModuleLaunchKernel:
2609  oss << "hipModuleLaunchKernel("
2610  << " f=" << data->args.hipModuleLaunchKernel.f << ","
2611  << " gridDimX=" << data->args.hipModuleLaunchKernel.gridDimX << ","
2612  << " gridDimY=" << data->args.hipModuleLaunchKernel.gridDimY << ","
2613  << " gridDimZ=" << data->args.hipModuleLaunchKernel.gridDimZ << ","
2614  << " blockDimX=" << data->args.hipModuleLaunchKernel.blockDimX << ","
2615  << " blockDimY=" << data->args.hipModuleLaunchKernel.blockDimY << ","
2616  << " blockDimZ=" << data->args.hipModuleLaunchKernel.blockDimZ << ","
2617  << " sharedMemBytes=" << data->args.hipModuleLaunchKernel.sharedMemBytes << ","
2618  << " stream=" << data->args.hipModuleLaunchKernel.stream << ","
2619  << " kernelParams=" << data->args.hipModuleLaunchKernel.kernelParams << ","
2620  << " extra=" << data->args.hipModuleLaunchKernel.extra
2621  << ")";
2622  break;
2623  case HIP_API_ID_hipModuleGetTexRef:
2624  oss << "hipModuleGetTexRef("
2625  << " texRef=" << data->args.hipModuleGetTexRef.texRef << ","
2626  << " hmod=" << data->args.hipModuleGetTexRef.hmod << ","
2627  << " name=" << data->args.hipModuleGetTexRef.name
2628  << ")";
2629  break;
2630  case HIP_API_ID_hipDeviceGetLimit:
2631  oss << "hipDeviceGetLimit("
2632  << " pValue=" << data->args.hipDeviceGetLimit.pValue << ","
2633  << " limit=" << data->args.hipDeviceGetLimit.limit
2634  << ")";
2635  break;
2636  case HIP_API_ID_hipModuleLoadDataEx:
2637  oss << "hipModuleLoadDataEx("
2638  << " module=" << data->args.hipModuleLoadDataEx.module << ","
2639  << " image=" << data->args.hipModuleLoadDataEx.image << ","
2640  << " numOptions=" << data->args.hipModuleLoadDataEx.numOptions << ","
2641  << " options=" << data->args.hipModuleLoadDataEx.options << ","
2642  << " optionValues=" << data->args.hipModuleLoadDataEx.optionValues
2643  << ")";
2644  break;
2645  case HIP_API_ID_hipRuntimeGetVersion:
2646  oss << "hipRuntimeGetVersion("
2647  << " runtimeVersion=" << data->args.hipRuntimeGetVersion.runtimeVersion
2648  << ")";
2649  break;
2650  case HIP_API_ID_hipGetDeviceProperties:
2651  oss << "hipGetDeviceProperties("
2652  << " prop=" << data->args.hipGetDeviceProperties.prop << ","
2653  << " deviceId=" << data->args.hipGetDeviceProperties.deviceId
2654  << ")";
2655  break;
2656  case HIP_API_ID_hipFreeArray:
2657  oss << "hipFreeArray("
2658  << " array=" << data->args.hipFreeArray.array
2659  << ")";
2660  break;
2661  case HIP_API_ID_hipDevicePrimaryCtxRelease:
2662  oss << "hipDevicePrimaryCtxRelease("
2663  << " dev=" << data->args.hipDevicePrimaryCtxRelease.dev
2664  << ")";
2665  break;
2666  case HIP_API_ID_hipHostGetDevicePointer:
2667  oss << "hipHostGetDevicePointer("
2668  << " devPtr=" << data->args.hipHostGetDevicePointer.devPtr << ","
2669  << " hstPtr=" << data->args.hipHostGetDevicePointer.hstPtr << ","
2670  << " flags=" << data->args.hipHostGetDevicePointer.flags
2671  << ")";
2672  break;
2673  case HIP_API_ID_hipMemcpyParam2D:
2674  oss << "hipMemcpyParam2D("
2675  << " pCopy=" << data->args.hipMemcpyParam2D.pCopy
2676  << ")";
2677  break;
2678  case HIP_API_ID_hipModuleGetFunction:
2679  oss << "hipModuleGetFunction("
2680  << " function=" << data->args.hipModuleGetFunction.function << ","
2681  << " module=" << data->args.hipModuleGetFunction.module << ","
2682  << " kname=" << data->args.hipModuleGetFunction.kname
2683  << ")";
2684  break;
2685  case HIP_API_ID_hipMemsetD32Async:
2686  oss << "hipMemsetD32Async("
2687  << " dst=" << data->args.hipMemsetD32Async.dst << ","
2688  << " value=" << data->args.hipMemsetD32Async.value << ","
2689  << " count=" << data->args.hipMemsetD32Async.count << ","
2690  << " stream=" << data->args.hipMemsetD32Async.stream
2691  << ")";
2692  break;
2693  case HIP_API_ID_hipGetDevice:
2694  oss << "hipGetDevice("
2695  << " deviceId=" << data->args.hipGetDevice.deviceId
2696  << ")";
2697  break;
2698  case HIP_API_ID_hipGetDeviceCount:
2699  oss << "hipGetDeviceCount("
2700  << " count=" << data->args.hipGetDeviceCount.count
2701  << ")";
2702  break;
2703  default: oss << "unknown";
2704  };
2705  return strdup(oss.str().c_str());
2706 };
2707 #endif
2708 #endif // _HIP_PROF_STR_H
hipExtent
Definition: driver_types.h:232
hipPointerAttribute_t
Definition: hip_runtime_api.h:137
ihipModuleSymbol_t
Definition: hip_module.cpp:90
ihipCtx_t
Definition: hip_hcc_internal.h:882
textureReference
Definition: texture_types.h:73
hipArray
Definition: driver_types.h:70
hipDeviceAttribute_t
hipDeviceAttribute_t
Definition: hip_runtime_api.h:259
hipStreamCallback_t
void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)
Definition: hip_runtime_api.h:834
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:702
ihipStream_t
Definition: hip_hcc_internal.h:521
hip_Memcpy2D
Definition: driver_types.h:82
hipIpcMemHandle_st
Definition: hip_runtime_api.h:106
ihipModule_t
Definition: hip_hcc_internal.h:369
hip_api_data_t
Definition: hip_prof_str.h:364
Generated on Mon Jun 3 2019 15:19:38 for HIP: Heterogenous-computing Interface for Portability by   doxygen 1.8.11