1 /*
2  * Copyright (C) 2020 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #include "test_api_tracing_common.h"
9 
10 using ::testing::Return;
11 
12 namespace L0 {
13 namespace ult {
14 
TEST_F(zeAPITracingRuntimeTests,WhenCallingImageGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess)15 TEST_F(zeAPITracingRuntimeTests, WhenCallingImageGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
16     ze_result_t result;
17     driver_ddiTable.core_ddiTable.Image.pfnGetProperties =
18         [](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) { return ZE_RESULT_SUCCESS; };
19     const ze_image_desc_t desc = {};
20     ze_image_properties_t pImageProperties = {};
21 
22     prologCbs.Image.pfnGetPropertiesCb = genericPrologCallbackPtr;
23     epilogCbs.Image.pfnGetPropertiesCb = genericEpilogCallbackPtr;
24 
25     setTracerCallbacksAndEnableTracer();
26 
27     result = zeImageGetProperties_Tracing(nullptr, &desc, &pImageProperties);
28     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
29     EXPECT_EQ(defaultUserData, 1);
30 }
31 
TEST_F(zeAPITracingRuntimeTests,WhenCallingImageCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess)32 TEST_F(zeAPITracingRuntimeTests, WhenCallingImageCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
33     ze_result_t result;
34     driver_ddiTable.core_ddiTable.Image.pfnCreate =
35         [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) { return ZE_RESULT_SUCCESS; };
36     const ze_image_desc_t desc = {};
37     ze_image_handle_t phImage = {};
38 
39     prologCbs.Image.pfnCreateCb = genericPrologCallbackPtr;
40     epilogCbs.Image.pfnCreateCb = genericEpilogCallbackPtr;
41 
42     setTracerCallbacksAndEnableTracer();
43 
44     result = zeImageCreate_Tracing(nullptr, nullptr, &desc, &phImage);
45     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
46     EXPECT_EQ(defaultUserData, 1);
47 }
48 
TEST_F(zeAPITracingRuntimeTests,WhenCallingImageDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess)49 TEST_F(zeAPITracingRuntimeTests, WhenCallingImageDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
50     ze_result_t result;
51     driver_ddiTable.core_ddiTable.Image.pfnDestroy =
52         [](ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
53     prologCbs.Image.pfnDestroyCb = genericPrologCallbackPtr;
54     epilogCbs.Image.pfnDestroyCb = genericEpilogCallbackPtr;
55 
56     setTracerCallbacksAndEnableTracer();
57 
58     result = zeImageDestroy_Tracing(nullptr);
59     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
60     EXPECT_EQ(defaultUserData, 1);
61 }
62 
63 // More complex tracing test.
64 
65 struct {
66     ze_device_handle_t hDevice0;
67     ze_image_desc_t desc0;
68     ze_image_properties_t ImageProperties0;
69     ze_device_handle_t hDevice1;
70     ze_image_desc_t desc1;
71     ze_image_properties_t ImageProperties1;
72     void *instanceData0;
73     void *instanceData3;
74 } ImageGetProperties_args;
75 
TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,WhenCallingImageGetPropertiesTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess)76 TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
77     ze_result_t result;
78 
79     // initialize initial argument set
80     ImageGetProperties_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
81 
82     // initialize replacement argument set
83     ImageGetProperties_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
84 
85     // initialize user instance data
86     ImageGetProperties_args.instanceData0 = generateRandomHandle<void *>();
87     ImageGetProperties_args.instanceData3 = generateRandomHandle<void *>();
88 
89     driver_ddiTable.core_ddiTable.Image.pfnGetProperties =
90         [](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) {
91             EXPECT_EQ(ImageGetProperties_args.hDevice1, hDevice);
92             EXPECT_EQ(&ImageGetProperties_args.desc1, desc);
93             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, pImageProperties);
94             return ZE_RESULT_SUCCESS;
95         };
96 
97     //
98     // The 0th prolog replaces the orignal API arguments with a new set
99     // Create instance data, pass it to corresponding epilog.
100     //
101     prologCbs0.Image.pfnGetPropertiesCb =
102         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
103             EXPECT_EQ(ImageGetProperties_args.hDevice0, *params->phDevice);
104             EXPECT_EQ(&ImageGetProperties_args.desc0, *params->pdesc);
105             EXPECT_EQ(&ImageGetProperties_args.ImageProperties0, *params->ppImageProperties);
106             *params->phDevice = ImageGetProperties_args.hDevice1;
107             *params->pdesc = &ImageGetProperties_args.desc1;
108             *params->ppImageProperties = &ImageGetProperties_args.ImageProperties1;
109             ASSERT_NE(nullptr, pTracerUserData);
110             int *val = static_cast<int *>(pTracerUserData);
111             EXPECT_EQ(*val, 1);
112             *val += 1;
113             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
114             instanceData->instanceDataValue = ImageGetProperties_args.instanceData0;
115             *ppTracerInstanceUserData = instanceData;
116         };
117 
118     //
119     // The 0th epilog expects to see the API argument replacements
120     // Expect to receive instance data from corresponding prolog
121     //
122     epilogCbs0.Image.pfnGetPropertiesCb =
123         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
124             struct instanceDataStruct *instanceData;
125             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
126             EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
127             EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
128             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
129             ASSERT_NE(nullptr, pTracerUserData);
130             int *val = static_cast<int *>(pTracerUserData);
131             EXPECT_EQ(*val, 2);
132             *val += 1;
133             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
134             EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData0);
135             delete instanceData;
136         };
137 
138     //
139     // The 1st prolog sees the arguments as replaced by the 0th prolog.
140     // There is no epilog for this prolog, so don't allocate instance data
141     //
142     prologCbs1.Image.pfnGetPropertiesCb =
143         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
144             EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
145             EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
146             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
147             ASSERT_NE(nullptr, pTracerUserData);
148             int *val = static_cast<int *>(pTracerUserData);
149             EXPECT_EQ(*val, 11);
150             *val += 11;
151         };
152 
153     //
154     // The 2nd epilog expects to see the API argument replacements
155     // There is no corresponding prolog, so there is no instance data
156     //
157     epilogCbs2.Image.pfnGetPropertiesCb =
158         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
159             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
160             EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
161             EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
162             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
163             ASSERT_NE(nullptr, pTracerUserData);
164             int *val = static_cast<int *>(pTracerUserData);
165             EXPECT_EQ(*val, 21);
166             *val += 21;
167         };
168 
169     //
170     // The 3rd prolog expects to see the API argument replacements and doesn't modify them
171     // Create instance data and pass to corresponding epilog
172     //
173     prologCbs3.Image.pfnGetPropertiesCb =
174         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
175             EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
176             EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
177             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
178             ASSERT_NE(nullptr, pTracerUserData);
179             int *val = static_cast<int *>(pTracerUserData);
180             EXPECT_EQ(*val, 31);
181             *val += 31;
182             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
183             instanceData->instanceDataValue = ImageGetProperties_args.instanceData3;
184             *ppTracerInstanceUserData = instanceData;
185         };
186 
187     //
188     // The 3rd epilog expects to see the API argument replacements
189     // Expect to see instance data from corresponding prolog
190     //
191     epilogCbs3.Image.pfnGetPropertiesCb =
192         [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
193             struct instanceDataStruct *instanceData;
194             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
195             EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
196             EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
197             EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
198             ASSERT_NE(nullptr, pTracerUserData);
199             int *val = static_cast<int *>(pTracerUserData);
200             EXPECT_EQ(*val, 62);
201             *val += 31;
202             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
203             EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData3);
204             delete instanceData;
205         };
206 
207     setTracerCallbacksAndEnableTracer();
208 
209     result = zeImageGetProperties_Tracing(ImageGetProperties_args.hDevice0, &ImageGetProperties_args.desc0, &ImageGetProperties_args.ImageProperties0);
210     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
211     validateDefaultUserDataFinal();
212 }
213 
214 struct {
215     ze_context_handle_t hContext0;
216     ze_device_handle_t hDevice0;
217     ze_image_desc_t desc0;
218     ze_image_handle_t hImage0;
219     ze_context_handle_t hContext1;
220     ze_device_handle_t hDevice1;
221     ze_image_desc_t desc1;
222     ze_image_handle_t hImage1;
223     ze_image_handle_t hImageAPI;
224     void *instanceData0;
225     void *instanceData3;
226 } ImageCreate_args;
227 
TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,WhenCallingImageCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess)228 TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
229     ze_result_t result;
230 
231     // initialize initial argument set
232     ImageCreate_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
233     ImageCreate_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
234     ImageCreate_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
235 
236     // initialize replacement argument set
237     ImageCreate_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
238     ImageCreate_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
239     ImageCreate_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
240 
241     // initialize user instance data
242     ImageCreate_args.instanceData0 = generateRandomHandle<void *>();
243     ImageCreate_args.instanceData3 = generateRandomHandle<void *>();
244 
245     driver_ddiTable.core_ddiTable.Image.pfnCreate =
246         [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) {
247             EXPECT_EQ(ImageCreate_args.hContext1, hContext);
248             EXPECT_EQ(ImageCreate_args.hDevice1, hDevice);
249             EXPECT_EQ(&ImageCreate_args.desc1, desc);
250             EXPECT_EQ(&ImageCreate_args.hImage1, phImage);
251             EXPECT_EQ(ImageCreate_args.hImage1, *phImage);
252             ImageCreate_args.hImageAPI = generateRandomHandle<ze_image_handle_t>();
253             *phImage = ImageCreate_args.hImageAPI;
254             return ZE_RESULT_SUCCESS;
255         };
256 
257     //
258     // The 0th prolog replaces the orignal API arguments with a new set
259     // Create instance data, pass it to corresponding epilog.
260     //
261     prologCbs0.Image.pfnCreateCb =
262         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
263             ASSERT_NE(nullptr, params);
264             ASSERT_NE(nullptr, params->phContext);
265             ASSERT_NE(nullptr, params->phDevice);
266             ASSERT_NE(nullptr, *params->phContext);
267             ASSERT_NE(nullptr, *params->phDevice);
268             EXPECT_EQ(ImageCreate_args.hContext0, *params->phContext);
269             EXPECT_EQ(ImageCreate_args.hDevice0, *params->phDevice);
270             EXPECT_EQ(&ImageCreate_args.desc0, *params->pdesc);
271 
272             ze_image_handle_t **ppHandle;
273             ASSERT_NE(nullptr, params);
274             ppHandle = params->pphImage;
275 
276             ze_image_handle_t *pHandle;
277             ASSERT_NE(nullptr, ppHandle);
278             pHandle = *ppHandle;
279             EXPECT_EQ(&ImageCreate_args.hImage0, pHandle);
280 
281             ze_image_handle_t handle;
282             ASSERT_NE(nullptr, pHandle);
283             handle = *pHandle;
284             EXPECT_EQ(ImageCreate_args.hImage0, handle);
285 
286             *params->phContext = ImageCreate_args.hContext1;
287             *params->phDevice = ImageCreate_args.hDevice1;
288             *params->pdesc = &ImageCreate_args.desc1;
289             *params->pphImage = &ImageCreate_args.hImage1;
290             ASSERT_NE(nullptr, pTracerUserData);
291             int *val = static_cast<int *>(pTracerUserData);
292             EXPECT_EQ(*val, 1);
293             *val += 1;
294             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
295             instanceData->instanceDataValue = ImageCreate_args.instanceData0;
296             *ppTracerInstanceUserData = instanceData;
297         };
298 
299     //
300     // The 0th epilog expects to see the API argument replacements
301     // Expect to receive instance data from corresponding prolog
302     //
303     epilogCbs0.Image.pfnCreateCb =
304         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
305             struct instanceDataStruct *instanceData;
306             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
307             ASSERT_NE(nullptr, params);
308             ASSERT_NE(nullptr, params->phContext);
309             ASSERT_NE(nullptr, params->phDevice);
310             ASSERT_NE(nullptr, *params->phContext);
311             ASSERT_NE(nullptr, *params->phDevice);
312             EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
313             EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
314             EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
315 
316             ze_image_handle_t **ppHandle;
317             ASSERT_NE(nullptr, params);
318             ppHandle = params->pphImage;
319 
320             ze_image_handle_t *pHandle;
321             ASSERT_NE(nullptr, ppHandle);
322             pHandle = *ppHandle;
323             EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
324 
325             ze_image_handle_t handle;
326             ASSERT_NE(nullptr, pHandle);
327             handle = *pHandle;
328             EXPECT_EQ(ImageCreate_args.hImage1, handle);
329 
330             ASSERT_NE(nullptr, pTracerUserData);
331             int *val = static_cast<int *>(pTracerUserData);
332             EXPECT_EQ(*val, 2);
333             *val += 1;
334             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
335             EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData0);
336             delete instanceData;
337         };
338 
339     //
340     // The 1st prolog sees the arguments as replaced by the 0th prolog.
341     // There is no epilog for this prolog, so don't allocate instance data
342     //
343     prologCbs1.Image.pfnCreateCb =
344         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
345             EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
346             EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
347             EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
348 
349             ze_image_handle_t **ppHandle;
350             ASSERT_NE(nullptr, params);
351             ppHandle = params->pphImage;
352 
353             ze_image_handle_t *pHandle;
354             ASSERT_NE(nullptr, ppHandle);
355             pHandle = *ppHandle;
356             EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
357 
358             ze_image_handle_t handle;
359             ASSERT_NE(nullptr, pHandle);
360             handle = *pHandle;
361             EXPECT_EQ(ImageCreate_args.hImage1, handle);
362 
363             ASSERT_NE(nullptr, pTracerUserData);
364             int *val = static_cast<int *>(pTracerUserData);
365             EXPECT_EQ(*val, 11);
366             *val += 11;
367         };
368 
369     //
370     // The 2nd epilog expects to see the API argument replacements
371     // There is no corresponding prolog, so there is no instance data
372     //
373     epilogCbs2.Image.pfnCreateCb =
374         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
375             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
376             EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
377             EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
378             EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
379 
380             ze_image_handle_t **ppHandle;
381             ASSERT_NE(nullptr, params);
382             ppHandle = params->pphImage;
383 
384             ze_image_handle_t *pHandle;
385             ASSERT_NE(nullptr, ppHandle);
386             pHandle = *ppHandle;
387             EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
388 
389             ze_image_handle_t handle;
390             ASSERT_NE(nullptr, pHandle);
391             handle = *pHandle;
392             EXPECT_EQ(ImageCreate_args.hImage1, handle);
393 
394             ASSERT_NE(nullptr, pTracerUserData);
395             int *val = static_cast<int *>(pTracerUserData);
396             EXPECT_EQ(*val, 21);
397             *val += 21;
398         };
399 
400     //
401     // The 3rd prolog expects to see the API argument replacements and doesn't modify them
402     // Create instance data and pass to corresponding epilog
403     //
404     prologCbs3.Image.pfnCreateCb =
405         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
406             EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
407             EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
408             EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
409 
410             ze_image_handle_t **ppHandle;
411             ASSERT_NE(nullptr, params);
412             ppHandle = params->pphImage;
413 
414             ze_image_handle_t *pHandle;
415             ASSERT_NE(nullptr, ppHandle);
416             pHandle = *ppHandle;
417             EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
418 
419             ze_image_handle_t handle;
420             ASSERT_NE(nullptr, pHandle);
421             handle = *pHandle;
422             EXPECT_EQ(ImageCreate_args.hImage1, handle);
423 
424             ASSERT_NE(nullptr, pTracerUserData);
425             int *val = static_cast<int *>(pTracerUserData);
426             EXPECT_EQ(*val, 31);
427             *val += 31;
428             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
429             instanceData->instanceDataValue = ImageCreate_args.instanceData3;
430             *ppTracerInstanceUserData = instanceData;
431         };
432 
433     //
434     // The 3rd epilog expects to see the API argument replacements
435     // Expect to see instance data from corresponding prolog
436     //
437     epilogCbs3.Image.pfnCreateCb =
438         [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
439             struct instanceDataStruct *instanceData;
440             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
441             EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
442             EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
443             EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
444 
445             ze_image_handle_t **ppHandle;
446             ASSERT_NE(nullptr, params);
447             ppHandle = params->pphImage;
448 
449             ze_image_handle_t *pHandle;
450             ASSERT_NE(nullptr, ppHandle);
451             pHandle = *ppHandle;
452             EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
453 
454             ze_image_handle_t handle;
455             ASSERT_NE(nullptr, pHandle);
456             handle = *pHandle;
457             EXPECT_EQ(ImageCreate_args.hImage1, handle);
458 
459             ASSERT_NE(nullptr, pTracerUserData);
460             int *val = static_cast<int *>(pTracerUserData);
461             EXPECT_EQ(*val, 62);
462             *val += 31;
463             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
464             EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData3);
465             delete instanceData;
466         };
467 
468     setTracerCallbacksAndEnableTracer();
469 
470     result = zeImageCreate_Tracing(ImageCreate_args.hContext0, ImageCreate_args.hDevice0, &ImageCreate_args.desc0, &ImageCreate_args.hImage0);
471     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
472     validateDefaultUserDataFinal();
473 }
474 
475 struct {
476     ze_image_handle_t hImage0;
477     ze_image_handle_t hImage1;
478     void *instanceData0;
479     void *instanceData3;
480 } ImageDestroy_args;
481 
TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,WhenCallingImageDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess)482 TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
483     ze_result_t result;
484 
485     // initialize initial argument set
486     ImageDestroy_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
487 
488     // initialize replacement argument set
489     ImageDestroy_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
490 
491     // initialize user instance data
492     ImageDestroy_args.instanceData0 = generateRandomHandle<void *>();
493     ImageDestroy_args.instanceData3 = generateRandomHandle<void *>();
494 
495     driver_ddiTable.core_ddiTable.Image.pfnDestroy =
496         [](ze_image_handle_t hImage) {
497             EXPECT_EQ(ImageDestroy_args.hImage1, hImage);
498             return ZE_RESULT_SUCCESS;
499         };
500 
501     //
502     // The 0th prolog replaces the orignal API arguments with a new set
503     // Create instance data, pass it to corresponding epilog.
504     //
505     prologCbs0.Image.pfnDestroyCb =
506         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
507             EXPECT_EQ(ImageDestroy_args.hImage0, *params->phImage);
508             *params->phImage = ImageDestroy_args.hImage1;
509             ASSERT_NE(nullptr, pTracerUserData);
510             int *val = static_cast<int *>(pTracerUserData);
511             EXPECT_EQ(*val, 1);
512             *val += 1;
513             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
514             instanceData->instanceDataValue = ImageDestroy_args.instanceData0;
515             *ppTracerInstanceUserData = instanceData;
516         };
517 
518     //
519     // The 0th epilog expects to see the API argument replacements
520     // Expect to receive instance data from corresponding prolog
521     //
522     epilogCbs0.Image.pfnDestroyCb =
523         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
524             struct instanceDataStruct *instanceData;
525             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
526             EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
527             ASSERT_NE(nullptr, pTracerUserData);
528             int *val = static_cast<int *>(pTracerUserData);
529             EXPECT_EQ(*val, 2);
530             *val += 1;
531             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
532             EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData0);
533             delete instanceData;
534         };
535 
536     //
537     // The 1st prolog sees the arguments as replaced by the 0th prolog.
538     // There is no epilog for this prolog, so don't allocate instance data
539     //
540     prologCbs1.Image.pfnDestroyCb =
541         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
542             EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
543             ASSERT_NE(nullptr, pTracerUserData);
544             int *val = static_cast<int *>(pTracerUserData);
545             EXPECT_EQ(*val, 11);
546             *val += 11;
547         };
548 
549     //
550     // The 2nd epilog expects to see the API argument replacements
551     // There is no corresponding prolog, so there is no instance data
552     //
553     epilogCbs2.Image.pfnDestroyCb =
554         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
555             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
556             EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
557             ASSERT_NE(nullptr, pTracerUserData);
558             int *val = static_cast<int *>(pTracerUserData);
559             EXPECT_EQ(*val, 21);
560             *val += 21;
561         };
562 
563     //
564     // The 3rd prolog expects to see the API argument replacements and doesn't modify them
565     // Create instance data and pass to corresponding epilog
566     //
567     prologCbs3.Image.pfnDestroyCb =
568         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
569             EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
570             ASSERT_NE(nullptr, pTracerUserData);
571             int *val = static_cast<int *>(pTracerUserData);
572             EXPECT_EQ(*val, 31);
573             *val += 31;
574             struct instanceDataStruct *instanceData = new struct instanceDataStruct;
575             instanceData->instanceDataValue = ImageDestroy_args.instanceData3;
576             *ppTracerInstanceUserData = instanceData;
577         };
578 
579     //
580     // The 3rd epilog expects to see the API argument replacements
581     // Expect to see instance data from corresponding prolog
582     //
583     epilogCbs3.Image.pfnDestroyCb =
584         [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
585             struct instanceDataStruct *instanceData;
586             EXPECT_EQ(result, ZE_RESULT_SUCCESS);
587             EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
588             ASSERT_NE(nullptr, pTracerUserData);
589             int *val = static_cast<int *>(pTracerUserData);
590             EXPECT_EQ(*val, 62);
591             *val += 31;
592             instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
593             EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData3);
594             delete instanceData;
595         };
596 
597     setTracerCallbacksAndEnableTracer();
598 
599     result = zeImageDestroy_Tracing(ImageDestroy_args.hImage0);
600     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
601     validateDefaultUserDataFinal();
602 }
603 
604 } // namespace ult
605 } // namespace L0
606