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