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