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