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