Debian Codegraph @

level_zero/experimental/source/tracing/tracing_memory_imp.cpp

raw
1 /*
2 * Copyright (C) 2020-2023 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "level_zero/experimental/source/tracing/tracing_imp.h"
9
10 ZE_APIEXPORT ze_result_t ZE_APICALL
11 zeMemAllocSharedTracing(ze_context_handle_t hContext,
12 const ze_device_mem_alloc_desc_t *deviceDesc,
13 const ze_host_mem_alloc_desc_t *hostDesc,
14 size_t size,
15 size_t alignment,
16 ze_device_handle_t hDevice,
17 void **pptr) {
18
19 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnAllocShared,
20 hContext,
21 deviceDesc,
22 hostDesc,
23 size,
24 alignment,
25 hDevice,
26 pptr);
27
28 ze_mem_alloc_shared_params_t tracerParams;
29 tracerParams.phContext = &hContext;
30 tracerParams.pdevice_desc = &deviceDesc;
31 tracerParams.phost_desc = &hostDesc;
32 tracerParams.psize = &size;
33 tracerParams.palignment = &alignment;
34 tracerParams.phDevice = &hDevice;
35 tracerParams.ppptr = &pptr;
36
37 L0::APITracerCallbackDataImp<ze_pfnMemAllocSharedCb_t> apiCallbackData;
38
39 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocSharedCb_t, Mem, pfnAllocSharedCb);
40
41 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnAllocShared,
42 &tracerParams,
43 apiCallbackData.apiOrdinal,
44 apiCallbackData.prologCallbacks,
45 apiCallbackData.epilogCallbacks,
46 *tracerParams.phContext,
47 *tracerParams.pdevice_desc,
48 *tracerParams.phost_desc,
49 *tracerParams.psize,
50 *tracerParams.palignment,
51 *tracerParams.phDevice,
52 *tracerParams.ppptr);
53 }
54
55 ZE_APIEXPORT ze_result_t ZE_APICALL
56 zeMemAllocDeviceTracing(ze_context_handle_t hContext,
57 const ze_device_mem_alloc_desc_t *deviceDesc,
58 size_t size,
59 size_t alignment,
60 ze_device_handle_t hDevice,
61 void **pptr) {
62
63 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnAllocDevice,
64 hContext,
65 deviceDesc,
66 size,
67 alignment,
68 hDevice,
69 pptr);
70
71 ze_mem_alloc_device_params_t tracerParams;
72 tracerParams.phContext = &hContext;
73 tracerParams.pdevice_desc = &deviceDesc;
74 tracerParams.psize = &size;
75 tracerParams.palignment = &alignment;
76 tracerParams.phDevice = &hDevice;
77 tracerParams.ppptr = &pptr;
78
79 L0::APITracerCallbackDataImp<ze_pfnMemAllocDeviceCb_t> apiCallbackData;
80
81 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocDeviceCb_t, Mem, pfnAllocDeviceCb);
82
83 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnAllocDevice,
84 &tracerParams,
85 apiCallbackData.apiOrdinal,
86 apiCallbackData.prologCallbacks,
87 apiCallbackData.epilogCallbacks,
88 *tracerParams.phContext,
89 *tracerParams.pdevice_desc,
90 *tracerParams.psize,
91 *tracerParams.palignment,
92 *tracerParams.phDevice,
93 *tracerParams.ppptr);
94 }
95
96 ZE_APIEXPORT ze_result_t ZE_APICALL
97 zeMemAllocHostTracing(ze_context_handle_t hContext,
98 const ze_host_mem_alloc_desc_t *hostDesc,
99 size_t size,
100 size_t alignment,
101 void **pptr) {
102
103 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnAllocHost,
104 hContext,
105 hostDesc,
106 size,
107 alignment,
108 pptr);
109
110 ze_mem_alloc_host_params_t tracerParams;
111 tracerParams.phContext = &hContext;
112 tracerParams.phost_desc = &hostDesc;
113 tracerParams.psize = &size;
114 tracerParams.palignment = &alignment;
115 tracerParams.ppptr = &pptr;
116
117 L0::APITracerCallbackDataImp<ze_pfnMemAllocHostCb_t> apiCallbackData;
118
119 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemAllocHostCb_t, Mem, pfnAllocHostCb);
120
121 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnAllocHost,
122 &tracerParams,
123 apiCallbackData.apiOrdinal,
124 apiCallbackData.prologCallbacks,
125 apiCallbackData.epilogCallbacks,
126 *tracerParams.phContext,
127 *tracerParams.phost_desc,
128 *tracerParams.psize,
129 *tracerParams.palignment,
130 *tracerParams.ppptr);
131 }
132
133 ZE_APIEXPORT ze_result_t ZE_APICALL
134 zeMemFreeTracing(ze_context_handle_t hContext,
135 void *ptr) {
136
137 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnFree,
138 hContext,
139 ptr);
140
141 ze_mem_free_params_t tracerParams;
142 tracerParams.phContext = &hContext;
143 tracerParams.pptr = &ptr;
144
145 L0::APITracerCallbackDataImp<ze_pfnMemFreeCb_t> apiCallbackData;
146
147 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemFreeCb_t, Mem, pfnFreeCb);
148
149 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnFree,
150 &tracerParams,
151 apiCallbackData.apiOrdinal,
152 apiCallbackData.prologCallbacks,
153 apiCallbackData.epilogCallbacks,
154 *tracerParams.phContext,
155 *tracerParams.pptr);
156 }
157
158 ZE_APIEXPORT ze_result_t ZE_APICALL
159 zeMemGetAllocPropertiesTracing(ze_context_handle_t hContext,
160 const void *ptr,
161 ze_memory_allocation_properties_t *pMemAllocProperties,
162 ze_device_handle_t *phDevice) {
163
164 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnGetAllocProperties,
165 hContext,
166 ptr,
167 pMemAllocProperties,
168 phDevice);
169
170 ze_mem_get_alloc_properties_params_t tracerParams;
171 tracerParams.phContext = &hContext;
172 tracerParams.pptr = &ptr;
173 tracerParams.ppMemAllocProperties = &pMemAllocProperties;
174 tracerParams.pphDevice = &phDevice;
175
176 L0::APITracerCallbackDataImp<ze_pfnMemGetAllocPropertiesCb_t> apiCallbackData;
177
178 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetAllocPropertiesCb_t, Mem, pfnGetAllocPropertiesCb);
179
180 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnGetAllocProperties,
181 &tracerParams,
182 apiCallbackData.apiOrdinal,
183 apiCallbackData.prologCallbacks,
184 apiCallbackData.epilogCallbacks,
185 *tracerParams.phContext,
186 *tracerParams.pptr,
187 *tracerParams.ppMemAllocProperties,
188 *tracerParams.pphDevice);
189 }
190
191 ZE_APIEXPORT ze_result_t ZE_APICALL
192 zeMemGetAddressRangeTracing(ze_context_handle_t hContext,
193 const void *ptr,
194 void **pBase,
195 size_t *pSize) {
196
197 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnGetAddressRange,
198 hContext,
199 ptr,
200 pBase,
201 pSize);
202
203 ze_mem_get_address_range_params_t tracerParams;
204 tracerParams.phContext = &hContext;
205 tracerParams.pptr = &ptr;
206 tracerParams.ppBase = &pBase;
207 tracerParams.ppSize = &pSize;
208
209 L0::APITracerCallbackDataImp<ze_pfnMemGetAddressRangeCb_t> apiCallbackData;
210
211 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetAddressRangeCb_t, Mem, pfnGetAddressRangeCb);
212
213 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnGetAddressRange,
214 &tracerParams,
215 apiCallbackData.apiOrdinal,
216 apiCallbackData.prologCallbacks,
217 apiCallbackData.epilogCallbacks,
218 *tracerParams.phContext,
219 *tracerParams.pptr,
220 *tracerParams.ppBase,
221 *tracerParams.ppSize);
222 }
223
224 ZE_APIEXPORT ze_result_t ZE_APICALL
225 zeMemGetIpcHandleTracing(ze_context_handle_t hContext,
226 const void *ptr,
227 ze_ipc_mem_handle_t *pIpcHandle) {
228
229 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnGetIpcHandle,
230 hContext,
231 ptr,
232 pIpcHandle);
233
234 ze_mem_get_ipc_handle_params_t tracerParams;
235 tracerParams.phContext = &hContext;
236 tracerParams.pptr = &ptr;
237 tracerParams.ppIpcHandle = &pIpcHandle;
238
239 L0::APITracerCallbackDataImp<ze_pfnMemGetIpcHandleCb_t> apiCallbackData;
240
241 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemGetIpcHandleCb_t, Mem, pfnGetIpcHandleCb);
242
243 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnGetIpcHandle,
244 &tracerParams,
245 apiCallbackData.apiOrdinal,
246 apiCallbackData.prologCallbacks,
247 apiCallbackData.epilogCallbacks,
248 *tracerParams.phContext,
249 *tracerParams.pptr,
250 *tracerParams.ppIpcHandle);
251 }
252
253 ZE_APIEXPORT ze_result_t ZE_APICALL
254 zeMemOpenIpcHandleTracing(ze_context_handle_t hContext,
255 ze_device_handle_t hDevice,
256 ze_ipc_mem_handle_t handle,
257 ze_ipc_memory_flags_t flags,
258 void **pptr) {
259
260 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnOpenIpcHandle,
261 hContext,
262 hDevice,
263 handle,
264 flags,
265 pptr);
266
267 ze_mem_open_ipc_handle_params_t tracerParams;
268 tracerParams.phContext = &hContext;
269 tracerParams.phDevice = &hDevice;
270 tracerParams.phandle = &handle;
271 tracerParams.pflags = &flags;
272 tracerParams.ppptr = &pptr;
273
274 L0::APITracerCallbackDataImp<ze_pfnMemOpenIpcHandleCb_t> apiCallbackData;
275
276 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemOpenIpcHandleCb_t, Mem, pfnOpenIpcHandleCb);
277
278 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnOpenIpcHandle,
279 &tracerParams,
280 apiCallbackData.apiOrdinal,
281 apiCallbackData.prologCallbacks,
282 apiCallbackData.epilogCallbacks,
283 *tracerParams.phContext,
284 *tracerParams.phDevice,
285 *tracerParams.phandle,
286 *tracerParams.pflags,
287 *tracerParams.ppptr);
288 }
289
290 ZE_APIEXPORT ze_result_t ZE_APICALL
291 zeMemCloseIpcHandleTracing(ze_context_handle_t hContext,
292 const void *ptr) {
293
294 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.Mem.pfnCloseIpcHandle,
295 hContext,
296 ptr);
297
298 ze_mem_close_ipc_handle_params_t tracerParams;
299 tracerParams.phContext = &hContext;
300 tracerParams.pptr = &ptr;
301
302 L0::APITracerCallbackDataImp<ze_pfnMemCloseIpcHandleCb_t> apiCallbackData;
303
304 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnMemCloseIpcHandleCb_t, Mem, pfnCloseIpcHandleCb);
305
306 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.Mem.pfnCloseIpcHandle,
307 &tracerParams,
308 apiCallbackData.apiOrdinal,
309 apiCallbackData.prologCallbacks,
310 apiCallbackData.epilogCallbacks,
311 *tracerParams.phContext,
312 *tracerParams.pptr);
313 }
314
315 ZE_APIEXPORT ze_result_t ZE_APICALL
316 zeVirtualMemReserveTracing(ze_context_handle_t hContext,
317 const void *pStart,
318 size_t size,
319 void **pptr) {
320
321 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnReserve,
322 hContext,
323 pStart,
324 size,
325 pptr);
326
327 ze_virtual_mem_reserve_params_t tracerParams;
328 tracerParams.phContext = &hContext;
329 tracerParams.ppStart = &pStart;
330 tracerParams.psize = &size;
331 tracerParams.ppptr = &pptr;
332
333 L0::APITracerCallbackDataImp<ze_pfnVirtualMemReserveCb_t> apiCallbackData;
334
335 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemReserveCb_t, VirtualMem, pfnReserveCb);
336
337 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnReserve,
338 &tracerParams,
339 apiCallbackData.apiOrdinal,
340 apiCallbackData.prologCallbacks,
341 apiCallbackData.epilogCallbacks,
342 *tracerParams.phContext,
343 *tracerParams.ppStart,
344 *tracerParams.psize,
345 *tracerParams.ppptr);
346 }
347
348 ZE_APIEXPORT ze_result_t ZE_APICALL
349 zeVirtualMemFreeTracing(ze_context_handle_t hContext,
350 const void *ptr,
351 size_t size) {
352
353 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnFree,
354 hContext,
355 ptr,
356 size);
357
358 ze_virtual_mem_free_params_t tracerParams;
359 tracerParams.phContext = &hContext;
360 tracerParams.pptr = &ptr;
361 tracerParams.psize = &size;
362
363 L0::APITracerCallbackDataImp<ze_pfnVirtualMemFreeCb_t> apiCallbackData;
364
365 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemFreeCb_t, VirtualMem, pfnFreeCb);
366
367 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnFree,
368 &tracerParams,
369 apiCallbackData.apiOrdinal,
370 apiCallbackData.prologCallbacks,
371 apiCallbackData.epilogCallbacks,
372 *tracerParams.phContext,
373 *tracerParams.pptr,
374 *tracerParams.psize);
375 }
376
377 ZE_APIEXPORT ze_result_t ZE_APICALL
378 zeVirtualMemQueryPageSizeTracing(ze_context_handle_t hContext,
379 ze_device_handle_t hDevice,
380 size_t size,
381 size_t *pagesize) {
382
383 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnQueryPageSize,
384 hContext,
385 hDevice,
386 size,
387 pagesize);
388
389 ze_virtual_mem_query_page_size_params_t tracerParams;
390 tracerParams.phContext = &hContext;
391 tracerParams.phDevice = &hDevice;
392 tracerParams.psize = &size;
393 tracerParams.ppagesize = &pagesize;
394
395 L0::APITracerCallbackDataImp<ze_pfnVirtualMemQueryPageSizeCb_t> apiCallbackData;
396
397 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemQueryPageSizeCb_t, VirtualMem, pfnQueryPageSizeCb);
398
399 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnQueryPageSize,
400 &tracerParams,
401 apiCallbackData.apiOrdinal,
402 apiCallbackData.prologCallbacks,
403 apiCallbackData.epilogCallbacks,
404 *tracerParams.phContext,
405 *tracerParams.phDevice,
406 *tracerParams.psize,
407 *tracerParams.ppagesize);
408 }
409
410 ZE_APIEXPORT ze_result_t ZE_APICALL
411 zeVirtualMemMapTracing(ze_context_handle_t hContext,
412 const void *ptr,
413 size_t size,
414 ze_physical_mem_handle_t hPhysicalMemory,
415 size_t offset,
416 ze_memory_access_attribute_t access) {
417
418 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnMap,
419 hContext,
420 ptr,
421 size,
422 hPhysicalMemory,
423 offset,
424 access);
425
426 ze_virtual_mem_map_params_t tracerParams;
427 tracerParams.phContext = &hContext;
428 tracerParams.pptr = &ptr;
429 tracerParams.psize = &size;
430 tracerParams.phPhysicalMemory = &hPhysicalMemory;
431 tracerParams.poffset = &offset;
432 tracerParams.paccess = &access;
433
434 L0::APITracerCallbackDataImp<ze_pfnVirtualMemMapCb_t> apiCallbackData;
435
436 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemMapCb_t, VirtualMem, pfnMapCb);
437
438 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnMap,
439 &tracerParams,
440 apiCallbackData.apiOrdinal,
441 apiCallbackData.prologCallbacks,
442 apiCallbackData.epilogCallbacks,
443 *tracerParams.phContext,
444 *tracerParams.pptr,
445 *tracerParams.psize,
446 *tracerParams.phPhysicalMemory,
447 *tracerParams.poffset,
448 *tracerParams.paccess);
449 }
450
451 ZE_APIEXPORT ze_result_t ZE_APICALL
452 zeVirtualMemUnmapTracing(ze_context_handle_t hContext,
453 const void *ptr,
454 size_t size) {
455
456 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnUnmap,
457 hContext,
458 ptr,
459 size);
460
461 ze_virtual_mem_unmap_params_t tracerParams;
462 tracerParams.phContext = &hContext;
463 tracerParams.pptr = &ptr;
464 tracerParams.psize = &size;
465
466 L0::APITracerCallbackDataImp<ze_pfnVirtualMemUnmapCb_t> apiCallbackData;
467
468 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemUnmapCb_t, VirtualMem, pfnUnmapCb);
469
470 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnUnmap,
471 &tracerParams,
472 apiCallbackData.apiOrdinal,
473 apiCallbackData.prologCallbacks,
474 apiCallbackData.epilogCallbacks,
475 *tracerParams.phContext,
476 *tracerParams.pptr,
477 *tracerParams.psize);
478 }
479
480 ZE_APIEXPORT ze_result_t ZE_APICALL
481 zeVirtualMemSetAccessAttributeTracing(ze_context_handle_t hContext,
482 const void *ptr,
483 size_t size,
484 ze_memory_access_attribute_t access) {
485
486 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnSetAccessAttribute,
487 hContext,
488 ptr,
489 size,
490 access);
491
492 ze_virtual_mem_set_access_attribute_params_t tracerParams;
493 tracerParams.phContext = &hContext;
494 tracerParams.pptr = &ptr;
495 tracerParams.psize = &size;
496 tracerParams.paccess = &access;
497
498 L0::APITracerCallbackDataImp<ze_pfnVirtualMemSetAccessAttributeCb_t> apiCallbackData;
499
500 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemSetAccessAttributeCb_t, VirtualMem, pfnSetAccessAttributeCb);
501
502 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnSetAccessAttribute,
503 &tracerParams,
504 apiCallbackData.apiOrdinal,
505 apiCallbackData.prologCallbacks,
506 apiCallbackData.epilogCallbacks,
507 *tracerParams.phContext,
508 *tracerParams.pptr,
509 *tracerParams.psize,
510 *tracerParams.paccess);
511 }
512
513 ZE_APIEXPORT ze_result_t ZE_APICALL
514 zeVirtualMemGetAccessAttributeTracing(ze_context_handle_t hContext,
515 const void *ptr,
516 size_t size,
517 ze_memory_access_attribute_t *access,
518 size_t *outSize) {
519
520 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.VirtualMem.pfnGetAccessAttribute,
521 hContext,
522 ptr,
523 size,
524 access,
525 outSize);
526
527 ze_virtual_mem_get_access_attribute_params_t tracerParams;
528 tracerParams.phContext = &hContext;
529 tracerParams.pptr = &ptr;
530 tracerParams.psize = &size;
531 tracerParams.paccess = &access;
532 tracerParams.poutSize = &outSize;
533
534 L0::APITracerCallbackDataImp<ze_pfnVirtualMemGetAccessAttributeCb_t> apiCallbackData;
535
536 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnVirtualMemGetAccessAttributeCb_t, VirtualMem, pfnGetAccessAttributeCb);
537
538 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.VirtualMem.pfnGetAccessAttribute,
539 &tracerParams,
540 apiCallbackData.apiOrdinal,
541 apiCallbackData.prologCallbacks,
542 apiCallbackData.epilogCallbacks,
543 *tracerParams.phContext,
544 *tracerParams.pptr,
545 *tracerParams.psize,
546 *tracerParams.paccess,
547 *tracerParams.poutSize);
548 }
549
550 ZE_APIEXPORT ze_result_t ZE_APICALL
551 zePhysicalMemCreateTracing(ze_context_handle_t hContext,
552 ze_device_handle_t hDevice,
553 ze_physical_mem_desc_t *desc,
554 ze_physical_mem_handle_t *phPhysicalMemory) {
555
556 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.PhysicalMem.pfnCreate,
557 hContext,
558 hDevice,
559 desc,
560 phPhysicalMemory);
561
562 ze_physical_mem_create_params_t tracerParams;
563 tracerParams.phContext = &hContext;
564 tracerParams.phDevice = &hDevice;
565 tracerParams.pdesc = &desc;
566 tracerParams.pphPhysicalMemory = &phPhysicalMemory;
567
568 L0::APITracerCallbackDataImp<ze_pfnPhysicalMemCreateCb_t> apiCallbackData;
569
570 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnPhysicalMemCreateCb_t, PhysicalMem, pfnCreateCb);
571
572 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.PhysicalMem.pfnCreate,
573 &tracerParams,
574 apiCallbackData.apiOrdinal,
575 apiCallbackData.prologCallbacks,
576 apiCallbackData.epilogCallbacks,
577 *tracerParams.phContext,
578 *tracerParams.phDevice,
579 *tracerParams.pdesc,
580 *tracerParams.pphPhysicalMemory);
581 }
582
583 ZE_APIEXPORT ze_result_t ZE_APICALL
584 zePhysicalMemDestroyTracing(ze_context_handle_t hContext,
585 ze_physical_mem_handle_t hPhysicalMemory) {
586
587 ZE_HANDLE_TRACER_RECURSION(driverDdiTable.coreDdiTable.PhysicalMem.pfnDestroy,
588 hContext,
589 hPhysicalMemory);
590
591 ze_physical_mem_destroy_params_t tracerParams;
592 tracerParams.phContext = &hContext;
593 tracerParams.phPhysicalMemory = &hPhysicalMemory;
594
595 L0::APITracerCallbackDataImp<ze_pfnPhysicalMemDestroyCb_t> apiCallbackData;
596
597 ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnPhysicalMemDestroyCb_t, PhysicalMem, pfnDestroyCb);
598
599 return L0::apiTracerWrapperImp(driverDdiTable.coreDdiTable.PhysicalMem.pfnDestroy,
600 &tracerParams,
601 apiCallbackData.apiOrdinal,
602 apiCallbackData.prologCallbacks,
603 apiCallbackData.epilogCallbacks,
604 *tracerParams.phContext,
605 *tracerParams.phPhysicalMemory);
606 }