intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 14:55:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: fix ubsan issues in L0

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-11-09 10:14:58 +00:00
committed by Compute-Runtime-Automation
parent 78877424b0
commit 6d67198b4f
21 changed files with 3006 additions and 3007 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
level_zero/core/test/unit_tests/sources/debugger/windows/test_l0_debugger_windows.cpp
View File

@@ -142,7 +142,7 @@ TEST_F(L0DebuggerWindowsTest, givenDebuggerL0NotifyModuleCreateCalledAndCreateDe
auto debugger = static_cast<DebuggerL0 *>(neoDevice->getDebugger());
debugger->notifyModuleCreate((void *)0x12345678, 0x1000, 0x80000000);
EXPECT_EQ(1u, wddm->createDebugDataCalled);
EXPECT_EQ(0xDEADDEADu, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ_VAL(0xDEADDEADu, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ(0u, wddm->moduleCreateNotifyCalled);
}
@@ -151,7 +151,7 @@ TEST_F(L0DebuggerWindowsTest, givenDebuggerL0NotifyModuleCreateCalledAndModuleCr
auto debugger = static_cast<DebuggerL0 *>(neoDevice->getDebugger());
debugger->notifyModuleCreate((void *)0x12345678, 0x1000, 0x80000000);
EXPECT_EQ(1u, wddm->createDebugDataCalled);
EXPECT_EQ(0x12345678u, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ_VAL(0x12345678u, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ(1u, wddm->moduleCreateNotifyCalled);
EXPECT_EQ(0xDEADDEADu, wddm->moduleCreateNotificationPassedParam.param.hElfAddressPtr);
}
@@ -162,12 +162,12 @@ TEST_F(L0DebuggerWindowsTest, givenDebuggerL0NotifyModuleCreateCalledThenCreateD
EXPECT_EQ(1u, wddm->createDebugDataCalled);
EXPECT_EQ(ELF_BINARY, wddm->createDebugDataPassedParam.param.DebugDataType);
EXPECT_EQ(0x1000u, wddm->createDebugDataPassedParam.param.DataSize);
EXPECT_EQ(0x12345678u, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ_VAL(0x12345678u, wddm->createDebugDataPassedParam.param.hElfAddressPtr);
EXPECT_EQ(1u, wddm->moduleCreateNotifyCalled);
EXPECT_TRUE(wddm->moduleCreateNotificationPassedParam.param.IsCreate);
EXPECT_EQ(0x1000u, wddm->moduleCreateNotificationPassedParam.param.Modulesize);
EXPECT_EQ(0x12345678u, wddm->moduleCreateNotificationPassedParam.param.hElfAddressPtr);
EXPECT_EQ_VAL(0x12345678u, wddm->moduleCreateNotificationPassedParam.param.hElfAddressPtr);
EXPECT_EQ(0x80000000, wddm->moduleCreateNotificationPassedParam.param.LoadAddress);
}
@@ -178,7 +178,7 @@ TEST_F(L0DebuggerWindowsTest, givenDebuggerL0NotifyModuleDestroyCalledThenModule
EXPECT_EQ(1u, wddm->moduleCreateNotifyCalled);
EXPECT_FALSE(wddm->moduleCreateNotificationPassedParam.param.IsCreate);
EXPECT_EQ(0u, wddm->moduleCreateNotificationPassedParam.param.Modulesize);
EXPECT_EQ(0ull, wddm->moduleCreateNotificationPassedParam.param.hElfAddressPtr);
EXPECT_EQ_VAL(0ull, wddm->moduleCreateNotificationPassedParam.param.hElfAddressPtr);
EXPECT_EQ(0x80000000u, wddm->moduleCreateNotificationPassedParam.param.LoadAddress);
}

6
level_zero/core/test/unit_tests/sources/tracing/test_barrier_api_tracing.cpp
View File

@@ -14,7 +14,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendBarrierTracingWrapp
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendBarrier =
[](ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_event_handle_t hSignalEvent = nullptr;
uint32_t numWaitEvents = 0;
@@ -32,13 +32,13 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryRangesBarrier
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendMemoryRangesBarrier =
[](ze_command_list_handle_t hCommandList, uint32_t numRanges, const size_t *pRangeSizes, const void **pRanges,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t numRanges = 1;
const size_t pRangeSizes[] = {1};
const void **pRanges = new const void *[1];
driverDdiTable.coreDdiTable.CommandList.pfnAppendMemoryRangesBarrier =
[](ze_command_list_handle_t hCommandList, uint32_t numRanges, const size_t *pRangeSizes, const void **pRanges,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendMemoryRangesBarrierCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendMemoryRangesBarrierCb = genericEpilogCallbackPtr;

16
level_zero/core/test/unit_tests/sources/tracing/test_cmdlist_api_tracing.cpp
View File

@@ -16,7 +16,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListCreateTracingWrapperWithO
[](ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_list_desc_t *desc,
ze_command_list_handle_t *phCommandList) { return ZE_RESULT_SUCCESS; };
ze_command_list_handle_t *phCommandList) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_command_list_desc_t desc = {};
ze_command_list_handle_t commandList = {};
@@ -36,7 +36,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListCreateImmediateTracingWra
[](ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_list_handle_t *phCommandList) { return ZE_RESULT_SUCCESS; };
ze_command_list_handle_t *phCommandList) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_command_queue_desc_t desc = {};
ze_command_list_handle_t commandList = {};
@@ -53,7 +53,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListCreateImmediateTracingWra
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnDestroy =
[](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -67,7 +67,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListDestroyTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnReset =
[](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnResetCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnResetCb = genericEpilogCallbackPtr;
@@ -81,7 +81,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListResetTracingWrapperWithOn
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryPrefetchTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendMemoryPrefetch =
[](ze_command_list_handle_t hCommandList, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList, const void *ptr, size_t size) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendMemoryPrefetchCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendMemoryPrefetchCb = genericEpilogCallbackPtr;
@@ -95,7 +95,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryPrefetchTraci
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListCloseTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnClose =
[](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnCloseCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnCloseCb = genericEpilogCallbackPtr;
@@ -117,7 +117,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendQueryKernelTimestam
const size_t *pOffsets,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendQueryKernelTimestampsCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendQueryKernelTimestampsCb = genericEpilogCallbackPtr;
@@ -136,7 +136,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendWriteGlobalTimestam
uint64_t *dstptr,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendWriteGlobalTimestampCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendWriteGlobalTimestampCb = genericEpilogCallbackPtr;

8
level_zero/core/test/unit_tests/sources/tracing/test_cmdqueue_api_tracing.cpp
View File

@@ -16,7 +16,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueCreateTracingWrapperWith
[](ze_context_handle_t hContext,
ze_device_handle_t hDevice,
const ze_command_queue_desc_t *desc,
ze_command_queue_handle_t *phCommandQueue) { return ZE_RESULT_SUCCESS; };
ze_command_queue_handle_t *phCommandQueue) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_command_queue_desc_t desc = {};
ze_command_queue_handle_t commandQueue = {};
@@ -33,7 +33,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueCreateTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandQueue.pfnDestroy =
[](ze_command_queue_handle_t hCommandQueue) { return ZE_RESULT_SUCCESS; };
[](ze_command_queue_handle_t hCommandQueue) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandQueue.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.CommandQueue.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -53,7 +53,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueExecuteCommandListsTraci
driverDdiTable.coreDdiTable.CommandQueue.pfnExecuteCommandLists =
[](ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists,
ze_fence_handle_t hFence) { return ZE_RESULT_SUCCESS; };
ze_fence_handle_t hFence) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandQueue.pfnExecuteCommandListsCb = genericPrologCallbackPtr;
epilogCbs.CommandQueue.pfnExecuteCommandListsCb = genericEpilogCallbackPtr;
@@ -68,7 +68,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueExecuteCommandListsTraci
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandQueueSynchronizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandQueue.pfnSynchronize =
[](ze_command_queue_handle_t hCommandQueue, uint64_t timeout) { return ZE_RESULT_SUCCESS; };
[](ze_command_queue_handle_t hCommandQueue, uint64_t timeout) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint64_t timeout = 100;
prologCbs.CommandQueue.pfnSynchronizeCb = genericPrologCallbackPtr;

18
level_zero/core/test/unit_tests/sources/tracing/test_copy_api_tracing.cpp
View File

@@ -20,7 +20,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyTracingWr
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitevents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t bufferSize = 4096u;
void *dst = malloc(bufferSize);
@@ -49,7 +49,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryFillTracingWr
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t bufferSize = 4096u;
void *dst = malloc(bufferSize);
@@ -81,7 +81,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyRegionTra
uint32_t srcSlicePitch,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t bufferSize = 4096u;
void *dst = malloc(bufferSize);
@@ -122,7 +122,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendImageCopyTracingWra
ze_image_handle_t hSrcImage,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
@@ -150,7 +150,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendImageCopyRegionTrac
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
@@ -177,7 +177,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendImageCopyToMemoryTr
const ze_image_region_t *pSrcRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
void *dstptr = malloc(1);
@@ -204,7 +204,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendImageCopyFromMemory
const ze_image_region_t *pDstRegion,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
void *srcptr = malloc(1);
@@ -229,7 +229,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemAdviseTracingWra
ze_device_handle_t hDevice,
const void *ptr,
size_t size,
ze_memory_advice_t advice) { return ZE_RESULT_SUCCESS; };
ze_memory_advice_t advice) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t bufferSize = 4096u;
void *ptr = malloc(bufferSize);
@@ -257,7 +257,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyFromConte
size_t size,
ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents,
ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendMemoryCopyFromContextCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendMemoryCopyFromContextCb = genericEpilogCallbackPtr;

30
level_zero/core/test/unit_tests/sources/tracing/test_device_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGet =
[](ze_driver_handle_t hDriver, uint32_t *pCount, ze_device_handle_t *phDevices) { return ZE_RESULT_SUCCESS; };
[](ze_driver_handle_t hDriver, uint32_t *pCount, ze_device_handle_t *phDevices) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetCb = genericEpilogCallbackPtr;
@@ -28,7 +28,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetTracingWrapperWithOneSetOfP
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetProperties =
[](ze_device_handle_t hDevice, ze_device_properties_t *pDeviceProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, ze_device_properties_t *pDeviceProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetPropertiesCb = genericEpilogCallbackPtr;
@@ -43,7 +43,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetPropertiesTracingWrapperWit
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetComputePropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetComputeProperties =
[](ze_device_handle_t hDevice, ze_device_compute_properties_t *pComputeProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, ze_device_compute_properties_t *pComputeProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetComputePropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetComputePropertiesCb = genericEpilogCallbackPtr;
@@ -58,7 +58,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetComputePropertiesTracingWra
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetMemoryPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetMemoryProperties =
[](ze_device_handle_t hDevice, uint32_t *pCount, ze_device_memory_properties_t *pMemProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, uint32_t *pCount, ze_device_memory_properties_t *pMemProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetMemoryPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetMemoryPropertiesCb = genericEpilogCallbackPtr;
@@ -75,7 +75,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetCachePropertiesTracingWrapp
driverDdiTable.coreDdiTable.Device.pfnGetCacheProperties =
[](ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_cache_properties_t *pCacheProperties) { return ZE_RESULT_SUCCESS; };
ze_device_cache_properties_t *pCacheProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetCachePropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetCachePropertiesCb = genericEpilogCallbackPtr;
@@ -91,7 +91,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetImagePropertiesTracingWrapp
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetImageProperties =
[](ze_device_handle_t hDevice,
ze_device_image_properties_t *pImageProperties) { return ZE_RESULT_SUCCESS; };
ze_device_image_properties_t *pImageProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetImagePropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetImagePropertiesCb = genericEpilogCallbackPtr;
@@ -108,7 +108,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetSubDevicesTracingWrapperWit
driverDdiTable.coreDdiTable.Device.pfnGetSubDevices =
[](ze_device_handle_t hDevice,
uint32_t *pCount,
ze_device_handle_t *phSubdevices) { return ZE_RESULT_SUCCESS; };
ze_device_handle_t *phSubdevices) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t pcount = 1;
@@ -127,7 +127,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetP2PPropertiesTracingWrapper
driverDdiTable.coreDdiTable.Device.pfnGetP2PProperties =
[](ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_device_p2p_properties_t *pP2PProperties) { return ZE_RESULT_SUCCESS; };
ze_device_p2p_properties_t *pP2PProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_device_p2p_properties_t pP2PProperties;
@@ -146,7 +146,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceCanAccessPeerTracingWrapperWit
driverDdiTable.coreDdiTable.Device.pfnCanAccessPeer =
[](ze_device_handle_t hDevice,
ze_device_handle_t hPeerDevice,
ze_bool_t *value) { return ZE_RESULT_SUCCESS; };
ze_bool_t *value) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_bool_t value;
@@ -164,7 +164,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetCacheConfigTracingWrapperWi
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSetCacheConfig =
[](ze_kernel_handle_t hKernel,
ze_cache_config_flags_t flags) { return ZE_RESULT_SUCCESS; };
ze_cache_config_flags_t flags) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_cache_config_flags_t flags = {};
@@ -182,7 +182,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetModulePropertiesTracingWrap
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetModuleProperties =
[](ze_device_handle_t hDevice,
ze_device_module_properties_t *pModuleProperties) { return ZE_RESULT_SUCCESS; };
ze_device_module_properties_t *pModuleProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetModulePropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetModulePropertiesCb = genericEpilogCallbackPtr;
@@ -198,7 +198,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetMemoryAccessPropertiesTraci
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetMemoryAccessProperties =
[](ze_device_handle_t hDevice,
ze_device_memory_access_properties_t *pMemAccessProperties) { return ZE_RESULT_SUCCESS; };
ze_device_memory_access_properties_t *pMemAccessProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetMemoryAccessPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetMemoryAccessPropertiesCb = genericEpilogCallbackPtr;
@@ -213,7 +213,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetMemoryAccessPropertiesTraci
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetCommandQueueGroupPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetCommandQueueGroupProperties =
[](ze_device_handle_t hDevice, uint32_t *pCount, ze_command_queue_group_properties_t *pCommandQueueGroupProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, uint32_t *pCount, ze_command_queue_group_properties_t *pCommandQueueGroupProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetCommandQueueGroupPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetCommandQueueGroupPropertiesCb = genericEpilogCallbackPtr;
@@ -228,7 +228,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetCommandQueueGroupProperties
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetExternalMemoryPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetExternalMemoryProperties =
[](ze_device_handle_t hDevice, ze_device_external_memory_properties_t *pExternalMemoryProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, ze_device_external_memory_properties_t *pExternalMemoryProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetExternalMemoryPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetExternalMemoryPropertiesCb = genericEpilogCallbackPtr;
@@ -243,7 +243,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetExternalMemoryPropertiesTra
TEST_F(ZeApiTracingRuntimeTests, WhenCallingDeviceGetStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Device.pfnGetStatus =
[](ze_device_handle_t hDevice) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetStatusCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetStatusCb = genericEpilogCallbackPtr;

10
level_zero/core/test/unit_tests/sources/tracing/test_driver_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Driver.pfnGet =
[](uint32_t *pCount, ze_driver_handle_t *phDrivers) { return ZE_RESULT_SUCCESS; };
[](uint32_t *pCount, ze_driver_handle_t *phDrivers) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Driver.pfnGetCb = genericPrologCallbackPtr;
epilogCbs.Driver.pfnGetCb = genericEpilogCallbackPtr;
@@ -28,7 +28,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetTracingWrapperWithOneSetO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Driver.pfnGetProperties =
[](ze_driver_handle_t hDriver, ze_driver_properties_t *properties) { return ZE_RESULT_SUCCESS; };
[](ze_driver_handle_t hDriver, ze_driver_properties_t *properties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Device.pfnGetSubDevicesCb = genericPrologCallbackPtr;
epilogCbs.Device.pfnGetSubDevicesCb = genericEpilogCallbackPtr;
@@ -42,7 +42,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetPropertiesTracingWrapperW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetApiVersionTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Driver.pfnGetApiVersion =
[](ze_driver_handle_t hDrivers, ze_api_version_t *version) { return ZE_RESULT_SUCCESS; };
[](ze_driver_handle_t hDrivers, ze_api_version_t *version) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Driver.pfnGetApiVersionCb = genericPrologCallbackPtr;
epilogCbs.Driver.pfnGetApiVersionCb = genericEpilogCallbackPtr;
@@ -58,7 +58,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetIpcPropertiesTracingWrapp
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Driver.pfnGetIpcProperties =
[](ze_driver_handle_t hDrivers,
ze_driver_ipc_properties_t *pIpcProperties) { return ZE_RESULT_SUCCESS; };
ze_driver_ipc_properties_t *pIpcProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Driver.pfnGetIpcPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Driver.pfnGetIpcPropertiesCb = genericEpilogCallbackPtr;
@@ -75,7 +75,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingzeDriverGetExtensionPropertiesTracin
driverDdiTable.coreDdiTable.Driver.pfnGetExtensionProperties =
[](ze_driver_handle_t hDrivers,
uint32_t *pCount,
ze_driver_extension_properties_t *pExtensionProperties) { return ZE_RESULT_SUCCESS; };
ze_driver_extension_properties_t *pExtensionProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Driver.pfnGetExtensionPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Driver.pfnGetExtensionPropertiesCb = genericEpilogCallbackPtr;

2334
level_zero/core/test/unit_tests/sources/tracing/test_event_api_multi_tracing.cpp
View File

File diff suppressed because it is too large Load Diff

30
level_zero/core/test/unit_tests/sources/tracing/test_event_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnCreate =
[](ze_event_pool_handle_t hEventPool, const ze_event_desc_t *desc, ze_event_handle_t *phEvent) { return ZE_RESULT_SUCCESS; };
[](ze_event_pool_handle_t hEventPool, const ze_event_desc_t *desc, ze_event_handle_t *phEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_event_handle_t event = {};
ze_event_desc_t desc = {};
@@ -30,7 +30,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventCreateTracingWrapperWithOneSetO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnDestroy =
[](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -45,7 +45,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventDestroyTracingWrapperWithOneSet
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventHostSignalTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnHostSignal =
[](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnHostSignalCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnHostSignalCb = genericEpilogCallbackPtr;
@@ -59,7 +59,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventHostSignalTracingWrapperWithOne
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventHostSynchronizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnHostSynchronize =
[](ze_event_handle_t hEvent, uint64_t timeout) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent, uint64_t timeout) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnHostSynchronizeCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnHostSynchronizeCb = genericEpilogCallbackPtr;
@@ -73,7 +73,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventHostSynchronizeTracingWrapperWi
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventQueryStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnQueryStatus =
[](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnQueryStatusCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnQueryStatusCb = genericEpilogCallbackPtr;
@@ -87,7 +87,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventQueryStatusTracingWrapperWithOn
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventHostResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnHostReset =
[](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnHostResetCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnHostResetCb = genericEpilogCallbackPtr;
@@ -105,7 +105,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolCreateTracingWrapperWithOne
const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool) { return ZE_RESULT_SUCCESS; };
ze_event_pool_handle_t *phEventPool) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.EventPool.pfnCreateCb = genericPrologCallbackPtr;
epilogCbs.EventPool.pfnCreateCb = genericEpilogCallbackPtr;
@@ -119,7 +119,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolCreateTracingWrapperWithOne
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.EventPool.pfnDestroy =
[](ze_event_pool_handle_t hEventPool) { return ZE_RESULT_SUCCESS; };
[](ze_event_pool_handle_t hEventPool) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.EventPool.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.EventPool.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -133,7 +133,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolDestroyTracingWrapperWithOn
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolGetIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.EventPool.pfnGetIpcHandle =
[](ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t *phIpc) { return ZE_RESULT_SUCCESS; };
[](ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t *phIpc) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_ipc_event_pool_handle_t phIpc;
prologCbs.EventPool.pfnGetIpcHandleCb = genericPrologCallbackPtr;
@@ -151,7 +151,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolOpenIpcHandleTracingWrapper
driverDdiTable.coreDdiTable.EventPool.pfnOpenIpcHandle =
[](ze_context_handle_t hDriver,
ze_ipc_event_pool_handle_t hIpc,
ze_event_pool_handle_t *phEventPool) { return ZE_RESULT_SUCCESS; };
ze_event_pool_handle_t *phEventPool) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_ipc_event_pool_handle_t hIpc = {};
ze_event_pool_handle_t phEventPool;
@@ -168,7 +168,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolOpenIpcHandleTracingWrapper
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolCloseIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.EventPool.pfnCloseIpcHandle =
[](ze_event_pool_handle_t hEventPool) { return ZE_RESULT_SUCCESS; };
[](ze_event_pool_handle_t hEventPool) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.EventPool.pfnCloseIpcHandleCb = genericPrologCallbackPtr;
epilogCbs.EventPool.pfnCloseIpcHandleCb = genericEpilogCallbackPtr;
@@ -184,7 +184,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventPoolCloseIpcHandleTracingWrappe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendSignalEventTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendSignalEvent =
[](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendSignalEventCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendSignalEventCb = genericEpilogCallbackPtr;
@@ -198,7 +198,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendSignalEventTracingW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendWaitOnEventsTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendWaitOnEvents =
[](ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t *phEvents) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t *phEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_event_handle_t phEvents = {};
@@ -215,7 +215,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendWaitOnEventsTracing
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendEventResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendEventReset =
[](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendEventResetCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendEventResetCb = genericEpilogCallbackPtr;
@@ -230,7 +230,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendEventResetTracingWr
TEST_F(ZeApiTracingRuntimeTests, WhenCallingEventQueryKernelTimestampTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Event.pfnQueryKernelTimestamp =
[](ze_event_handle_t hEvent, ze_kernel_timestamp_result_t *dstptr) { return ZE_RESULT_SUCCESS; };
[](ze_event_handle_t hEvent, ze_kernel_timestamp_result_t *dstptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Event.pfnQueryKernelTimestampCb = genericPrologCallbackPtr;
epilogCbs.Event.pfnQueryKernelTimestampCb = genericEpilogCallbackPtr;

826
level_zero/core/test/unit_tests/sources/tracing/test_fence_api_tracing.cpp
View File

File diff suppressed because it is too large Load Diff

2
level_zero/core/test/unit_tests/sources/tracing/test_global_api_tracing.cpp
View File

@@ -12,7 +12,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingInitTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Global.pfnInit = [](ze_init_flags_t flags) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Global.pfnInit = [](ze_init_flags_t flags) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Global.pfnInitCb = genericPrologCallbackPtr;
epilogCbs.Global.pfnInitCb = genericEpilogCallbackPtr;

616
level_zero/core/test/unit_tests/sources/tracing/test_image_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingImageGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Image.pfnGetProperties =
[](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) { return ZE_RESULT_SUCCESS; };
[](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const ze_image_desc_t desc = {};
ze_image_properties_t pImageProperties = {};
@@ -30,7 +30,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingImageGetPropertiesTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingImageCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Image.pfnCreate =
[](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; };
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const ze_image_desc_t desc = {};
ze_image_handle_t phImage = {};
@@ -47,7 +47,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingImageCreateTracingWrapperWithOneSetO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingImageDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Image.pfnDestroy =
[](ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
[](ze_image_handle_t hImage) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Image.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Image.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -85,122 +85,122 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
ImageGetProperties_args.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Image.pfnGetProperties =
[](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) {
EXPECT_EQ(ImageGetProperties_args.hDevice1, hDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, desc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, pImageProperties);
return ZE_RESULT_SUCCESS;
};
[](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) -> ze_result_t {
EXPECT_EQ(ImageGetProperties_args.hDevice1, hDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, desc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, pImageProperties);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Create instance data, pass it to corresponding epilog.
//
prologCbs0.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageGetProperties_args.hDevice0, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc0, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties0, *params->ppImageProperties);
*params->phDevice = ImageGetProperties_args.hDevice1;
*params->pdesc = &ImageGetProperties_args.desc1;
*params->ppImageProperties = &ImageGetProperties_args.imageProperties1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageGetProperties_args.hDevice0, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc0, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties0, *params->ppImageProperties);
*params->phDevice = ImageGetProperties_args.hDevice1;
*params->pdesc = &ImageGetProperties_args.desc1;
*params->ppImageProperties = &ImageGetProperties_args.imageProperties1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData0);
delete instanceData;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
prologCbs3.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd epilog expects to see the API argument replacements
// Expect to see instance data from corresponding prolog
//
epilogCbs3.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData3);
delete instanceData;
};
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
EXPECT_EQ(&ImageGetProperties_args.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -241,227 +241,227 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ImageCreate_args.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Image.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) {
EXPECT_EQ(ImageCreate_args.hContext1, hContext);
EXPECT_EQ(ImageCreate_args.hDevice1, hDevice);
EXPECT_EQ(&ImageCreate_args.desc1, desc);
EXPECT_EQ(&ImageCreate_args.hImage1, phImage);
EXPECT_EQ(ImageCreate_args.hImage1, *phImage);
ImageCreate_args.hImageAPI = generateRandomHandle<ze_image_handle_t>();
*phImage = ImageCreate_args.hImageAPI;
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) -> ze_result_t {
EXPECT_EQ(ImageCreate_args.hContext1, hContext);
EXPECT_EQ(ImageCreate_args.hDevice1, hDevice);
EXPECT_EQ(&ImageCreate_args.desc1, desc);
EXPECT_EQ(&ImageCreate_args.hImage1, phImage);
EXPECT_EQ(ImageCreate_args.hImage1, *phImage);
ImageCreate_args.hImageAPI = generateRandomHandle<ze_image_handle_t>();
*phImage = ImageCreate_args.hImageAPI;
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Create instance data, pass it to corresponding epilog.
//
prologCbs0.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
ASSERT_NE(nullptr, params);
ASSERT_NE(nullptr, params->phContext);
ASSERT_NE(nullptr, params->phDevice);
ASSERT_NE(nullptr, *params->phContext);
ASSERT_NE(nullptr, *params->phDevice);
EXPECT_EQ(ImageCreate_args.hContext0, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice0, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc0, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
ASSERT_NE(nullptr, params);
ASSERT_NE(nullptr, params->phContext);
ASSERT_NE(nullptr, params->phDevice);
ASSERT_NE(nullptr, *params->phContext);
ASSERT_NE(nullptr, *params->phDevice);
EXPECT_EQ(ImageCreate_args.hContext0, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice0, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc0, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage0, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage0, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage0, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage0, handle);
*params->phContext = ImageCreate_args.hContext1;
*params->phDevice = ImageCreate_args.hDevice1;
*params->pdesc = &ImageCreate_args.desc1;
*params->pphImage = &ImageCreate_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
*params->phContext = ImageCreate_args.hContext1;
*params->phDevice = ImageCreate_args.hDevice1;
*params->pdesc = &ImageCreate_args.desc1;
*params->pphImage = &ImageCreate_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, params);
ASSERT_NE(nullptr, params->phContext);
ASSERT_NE(nullptr, params->phDevice);
ASSERT_NE(nullptr, *params->phContext);
ASSERT_NE(nullptr, *params->phDevice);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, params);
ASSERT_NE(nullptr, params->phContext);
ASSERT_NE(nullptr, params->phDevice);
ASSERT_NE(nullptr, *params->phContext);
ASSERT_NE(nullptr, *params->phDevice);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData0);
delete instanceData;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
prologCbs3.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd epilog expects to see the API argument replacements
// Expect to see instance data from corresponding prolog
//
epilogCbs3.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphImage;
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData3);
delete instanceData;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -491,106 +491,106 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
ImageDestroy_args.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Image.pfnDestroy =
[](ze_image_handle_t hImage) {
EXPECT_EQ(ImageDestroy_args.hImage1, hImage);
return ZE_RESULT_SUCCESS;
};
[](ze_image_handle_t hImage) -> ze_result_t {
EXPECT_EQ(ImageDestroy_args.hImage1, hImage);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Create instance data, pass it to corresponding epilog.
//
prologCbs0.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageDestroy_args.hImage0, *params->phImage);
*params->phImage = ImageDestroy_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageDestroy_args.hImage0, *params->phImage);
*params->phImage = ImageDestroy_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData0);
delete instanceData;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
prologCbs3.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd epilog expects to see the API argument replacements
// Expect to see instance data from corresponding prolog
//
epilogCbs3.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData3);
delete instanceData;
};
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();

36
level_zero/core/test/unit_tests/sources/tracing/test_memory_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocSharedTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Mem.pfnAllocShared =
[](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_device_mem_alloc_desc_t deviceDesc = {};
ze_host_mem_alloc_desc_t hostDesc;
@@ -34,7 +34,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocSharedTracingWrapperWithOneS
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocDeviceTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Mem.pfnAllocDevice =
[](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t size = 1024;
size_t alignment = 4096;
@@ -53,7 +53,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocDeviceTracingWrapperWithOneS
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocHostTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnAllocHost =
[](ze_context_handle_t hContext, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, void **pptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, void **pptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
size_t size = 1024;
size_t alignment = 4096;
@@ -72,7 +72,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemAllocHostTracingWrapperWithOneSet
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemFreeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnFree =
[](ze_context_handle_t hContext, void *ptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, void *ptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.Mem.pfnFreeCb = genericPrologCallbackPtr;
@@ -87,7 +87,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemFreeTracingWrapperWithOneSetOfPro
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetAllocPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnGetAllocProperties =
[](ze_context_handle_t hContext, const void *ptr, ze_memory_allocation_properties_t *pMemAllocProperties, ze_device_handle_t *phDevice) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, ze_memory_allocation_properties_t *pMemAllocProperties, ze_device_handle_t *phDevice) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.Mem.pfnGetAllocPropertiesCb = genericPrologCallbackPtr;
@@ -102,7 +102,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetAllocPropertiesTracingWrapperW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetAddressRangeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnGetAddressRange =
[](ze_context_handle_t hContext, const void *ptr, void **pBase, size_t *pSize) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, void **pBase, size_t *pSize) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.Mem.pfnGetAddressRangeCb = genericPrologCallbackPtr;
@@ -117,7 +117,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetAddressRangeTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnGetIpcHandle =
[](ze_context_handle_t hContext, const void *ptr, ze_ipc_mem_handle_t *pIpcHandle) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, ze_ipc_mem_handle_t *pIpcHandle) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.Mem.pfnGetIpcHandleCb = genericPrologCallbackPtr;
@@ -132,7 +132,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemGetIpcHandleTracingWrapperWithOne
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemOpenIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnOpenIpcHandle =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle, ze_ipc_memory_flags_t flags, void **pptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle, ze_ipc_memory_flags_t flags, void **pptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
ze_ipc_mem_handle_t ipchandle = {};
@@ -149,7 +149,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemOpenIpcHandleTracingWrapperWithOn
TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemCloseIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.Mem.pfnCloseIpcHandle =
[](ze_context_handle_t hContext, const void *ptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.Mem.pfnCloseIpcHandleCb = genericPrologCallbackPtr;
@@ -164,7 +164,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingMemCloseIpcHandleTracingWrapperWithO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingPhysicalMemCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.PhysicalMem.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_physical_mem_desc_t *desc, ze_physical_mem_handle_t *phPhysicalMemory) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_physical_mem_desc_t *desc, ze_physical_mem_handle_t *phPhysicalMemory) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.PhysicalMem.pfnCreateCb = genericPrologCallbackPtr;
@@ -180,7 +180,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingPhysicalMemCreateTracingWrapperWithO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingPhysicalMemDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.PhysicalMem.pfnDestroy =
[](ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMemory) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMemory) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.PhysicalMem.pfnDestroyCb = genericPrologCallbackPtr;
@@ -196,7 +196,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingPhysicalMemDestroyTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemFreeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnFree =
[](ze_context_handle_t hContext, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, size_t size) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnFreeCb = genericPrologCallbackPtr;
@@ -212,7 +212,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemFreeTracingWrapperWithOneS
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemGetAccessAttributeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnGetAccessAttribute =
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t *access, size_t *outSize) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t *access, size_t *outSize) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnGetAccessAttributeCb = genericPrologCallbackPtr;
@@ -228,7 +228,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemGetAccessAttributeTracingW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemMapTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnMap =
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_physical_mem_handle_t hPhysicalMemory, size_t offset, ze_memory_access_attribute_t access) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_physical_mem_handle_t hPhysicalMemory, size_t offset, ze_memory_access_attribute_t access) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnMapCb = genericPrologCallbackPtr;
@@ -244,7 +244,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemMapTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemQueryPageSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnQueryPageSize =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t size, size_t *pagesize) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t size, size_t *pagesize) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnQueryPageSizeCb = genericPrologCallbackPtr;
@@ -260,7 +260,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemQueryPageSizeTracingWrappe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemReserveTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnReserve =
[](ze_context_handle_t hContext, const void *pStart, size_t size, void **pptr) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *pStart, size_t size, void **pptr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnReserveCb = genericPrologCallbackPtr;
@@ -276,7 +276,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemReserveTracingWrapperWithO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemSetAccessAttributeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnSetAccessAttribute =
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t access) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t access) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnSetAccessAttributeCb = genericPrologCallbackPtr;
@@ -292,7 +292,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemSetAccessAttributeTracingW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingVirtualMemUnmapTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
driverDdiTable.coreDdiTable.VirtualMem.pfnUnmap =
[](ze_context_handle_t hContext, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, const void *ptr, size_t size) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_result_t result = ZE_RESULT_SUCCESS;
prologCbs.VirtualMem.pfnUnmapCb = genericPrologCallbackPtr;

886
level_zero/core/test/unit_tests/sources/tracing/test_module_api_multi_tracing.cpp
View File

File diff suppressed because it is too large Load Diff

50
level_zero/core/test/unit_tests/sources/tracing/test_module_api_tracing.cpp
View File

@@ -13,7 +13,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t *pDesc, ze_module_handle_t *phModule, ze_module_build_log_handle_t *phBuildLog) { return ZE_RESULT_SUCCESS; };
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t *pDesc, ze_module_handle_t *phModule, ze_module_build_log_handle_t *phBuildLog) -> ze_result_t { return ZE_RESULT_SUCCESS; };
ze_module_desc_t desc = {};
ze_module_handle_t phModule = {};
ze_module_build_log_handle_t phBuildLog = {};
@@ -31,7 +31,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleCreateTracingWrapperWithOneSet
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnDestroy =
[](ze_module_handle_t hModule) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Module.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Module.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -46,7 +46,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleDestroyTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleBuildLogDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.ModuleBuildLog.pfnDestroy =
[](ze_module_build_log_handle_t hModuleBuildLog) { return ZE_RESULT_SUCCESS; };
[](ze_module_build_log_handle_t hModuleBuildLog) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.ModuleBuildLog.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.ModuleBuildLog.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -61,7 +61,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleBuildLogDestroyTracingWrapperW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleBuildLogGetStringTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.ModuleBuildLog.pfnGetString =
[](ze_module_build_log_handle_t hModuleBuildLog, size_t *pSize, char *pBuildLog) { return ZE_RESULT_SUCCESS; };
[](ze_module_build_log_handle_t hModuleBuildLog, size_t *pSize, char *pBuildLog) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t pSize = {};
char pBuildLog = {};
@@ -79,7 +79,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleBuildLogGetStringTracingWrappe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetNativeBinaryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnGetNativeBinary =
[](ze_module_handle_t hModule, size_t *pSize, uint8_t *pModuleNativeBinary) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule, size_t *pSize, uint8_t *pModuleNativeBinary) -> ze_result_t { return ZE_RESULT_SUCCESS; };
size_t pSize = {};
uint8_t pModuleNativeBinary = {};
@@ -96,7 +96,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetNativeBinaryTracingWrapperW
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetGlobalPointerTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnGetGlobalPointer =
[](ze_module_handle_t hModule, const char *pGlobalName, size_t *pSize, void **pPtr) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule, const char *pGlobalName, size_t *pSize, void **pPtr) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const char pGlobalName = {};
size_t size;
void *pptr = nullptr;
@@ -114,7 +114,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetGlobalPointerTracingWrapper
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnCreate =
[](ze_module_handle_t hModule, const ze_kernel_desc_t *pDesc, ze_kernel_handle_t *phKernel) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule, const ze_kernel_desc_t *pDesc, ze_kernel_handle_t *phKernel) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const ze_kernel_desc_t desc = {};
ze_kernel_handle_t phKernel = {};
@@ -131,7 +131,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelCreateTracingWrapperWithOneSet
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnDestroy =
[](ze_kernel_handle_t hKernel) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -146,7 +146,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelDestroyTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetFunctionPointerTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnGetFunctionPointer =
[](ze_module_handle_t hModule, const char *pKernelName, void **pfnFunction) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule, const char *pKernelName, void **pfnFunction) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const char pKernelName = {};
void *pfnFunction = nullptr;
@@ -163,7 +163,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetFunctionPointerTracingWrapp
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetGroupSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSetGroupSize =
[](ze_kernel_handle_t hKernel, uint32_t groupSizeX, uint32_t groupSizeY, uint32_t groupSizeZ) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, uint32_t groupSizeX, uint32_t groupSizeY, uint32_t groupSizeZ) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t groupSizeX = {};
uint32_t groupSizeY = {};
uint32_t groupSizeZ = {};
@@ -181,7 +181,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetGroupSizeTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSuggestGroupSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSuggestGroupSize =
[](ze_kernel_handle_t hKernel, uint32_t globalSizeX, uint32_t globalSizeY, uint32_t globalSizeZ, uint32_t *groupSizeX, uint32_t *groupSizeY, uint32_t *groupSizeZ) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, uint32_t globalSizeX, uint32_t globalSizeY, uint32_t globalSizeZ, uint32_t *groupSizeX, uint32_t *groupSizeY, uint32_t *groupSizeZ) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t globalSizeX = {};
uint32_t globalSizeY = {};
uint32_t globalSizeZ = {};
@@ -202,7 +202,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSuggestGroupSizeTracingWrapper
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetArgumentValueTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSetArgumentValue =
[](ze_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize, const void *pArgValue) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize, const void *pArgValue) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t argIndex = {};
size_t argSize = {};
const void *pArgValue = nullptr;
@@ -220,7 +220,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetArgumentValueTracingWrapper
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnGetProperties =
[](ze_kernel_handle_t hKernel, ze_kernel_properties_t *pKernelProperties) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, ze_kernel_properties_t *pKernelProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnGetPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnGetPropertiesCb = genericEpilogCallbackPtr;
@@ -236,7 +236,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelTracing
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendLaunchKernel =
[](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchFuncArgs,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const ze_group_count_t pLaunchFuncArgs = {};
ze_event_handle_t hSignalEvent = {};
uint32_t numWaitEvents = {};
@@ -256,7 +256,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelIndirec
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendLaunchKernelIndirect =
[](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchArgumentsBuffer,
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
const ze_group_count_t pLaunchArgumentsBuffer = {};
ze_event_handle_t hSignalEvent = {};
uint32_t numWaitEvents = {};
@@ -277,7 +277,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchMultipleKerne
driverDdiTable.coreDdiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect =
[](ze_command_list_handle_t hCommandList, uint32_t numKernels, ze_kernel_handle_t *phKernels,
const uint32_t *pNumLaunchArguments, const ze_group_count_t *pLaunchArgumentsBuffer, ze_event_handle_t hSignalEvent,
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
uint32_t numKernels = {};
ze_kernel_handle_t phKernels = {};
const uint32_t pNumLaunchArguments = {};
@@ -299,7 +299,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchMultipleKerne
TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchCooperativeKernelTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.CommandList.pfnAppendLaunchCooperativeKernel =
[](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchFuncArgs, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
[](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchFuncArgs, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.CommandList.pfnAppendLaunchCooperativeKernelCb = genericPrologCallbackPtr;
epilogCbs.CommandList.pfnAppendLaunchCooperativeKernelCb = genericEpilogCallbackPtr;
@@ -314,7 +314,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingCommandListAppendLaunchCooperativeKe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetKernelNamesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnGetKernelNames =
[](ze_module_handle_t hDevice, uint32_t *pCount, const char **pNames) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hDevice, uint32_t *pCount, const char **pNames) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Module.pfnGetKernelNamesCb = genericPrologCallbackPtr;
epilogCbs.Module.pfnGetKernelNamesCb = genericEpilogCallbackPtr;
@@ -329,7 +329,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetKernelNamesTracingWrapperWi
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSuggestMaxCooperativeGroupCountTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSuggestMaxCooperativeGroupCount =
[](ze_kernel_handle_t hKernel, uint32_t *totalGroupCount) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, uint32_t *totalGroupCount) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnSuggestMaxCooperativeGroupCountCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnSuggestMaxCooperativeGroupCountCb = genericEpilogCallbackPtr;
@@ -344,7 +344,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSuggestMaxCooperativeGroupCoun
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetIndirectAccessTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnGetIndirectAccess =
[](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t *pFlags) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t *pFlags) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnGetIndirectAccessCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnGetIndirectAccessCb = genericEpilogCallbackPtr;
@@ -359,7 +359,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetIndirectAccessTracingWrappe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetNameTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnGetName =
[](ze_kernel_handle_t hKernel, size_t *pSize, char *pName) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, size_t *pSize, char *pName) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnGetNameCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnGetNameCb = genericEpilogCallbackPtr;
@@ -374,7 +374,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetNameTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetSourceAttributesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnGetSourceAttributes =
[](ze_kernel_handle_t hKernel, uint32_t *pSize, char **pString) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, uint32_t *pSize, char **pString) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnGetSourceAttributesCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnGetSourceAttributesCb = genericEpilogCallbackPtr;
@@ -389,7 +389,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelGetSourceAttributesTracingWrap
TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetIndirectAccessTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Kernel.pfnSetIndirectAccess =
[](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t flags) { return ZE_RESULT_SUCCESS; };
[](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t flags) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Kernel.pfnSetIndirectAccessCb = genericPrologCallbackPtr;
epilogCbs.Kernel.pfnSetIndirectAccessCb = genericEpilogCallbackPtr;
@@ -404,7 +404,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingKernelSetIndirectAccessTracingWrappe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleDynamicLinkTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnDynamicLink =
[](uint32_t numModules, ze_module_handle_t *phModules, ze_module_build_log_handle_t *phLinkLog) { return ZE_RESULT_SUCCESS; };
[](uint32_t numModules, ze_module_handle_t *phModules, ze_module_build_log_handle_t *phLinkLog) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Module.pfnDynamicLinkCb = genericPrologCallbackPtr;
epilogCbs.Module.pfnDynamicLinkCb = genericEpilogCallbackPtr;
@@ -419,7 +419,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleDynamicLinkTracingWrapperWithO
TEST_F(ZeApiTracingRuntimeTests, WhenCallingModuleGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Module.pfnGetProperties =
[](ze_module_handle_t hModule, ze_module_properties_t *pModuleProperties) { return ZE_RESULT_SUCCESS; };
[](ze_module_handle_t hModule, ze_module_properties_t *pModuleProperties) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Module.pfnGetPropertiesCb = genericPrologCallbackPtr;
epilogCbs.Module.pfnGetPropertiesCb = genericEpilogCallbackPtr;

688
level_zero/core/test/unit_tests/sources/tracing/test_residency_api_tracing.cpp
View File

@@ -12,7 +12,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnCreate = [](ze_driver_handle_t hContext, const ze_context_desc_t *desc, ze_context_handle_t *phContext) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnCreate = [](ze_driver_handle_t hContext, const ze_context_desc_t *desc, ze_context_handle_t *phContext) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnCreateCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnCreateCb = genericEpilogCallbackPtr;
@@ -26,7 +26,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextCreateTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnDestroy = [](ze_context_handle_t hContext) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnDestroy = [](ze_context_handle_t hContext) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -40,7 +40,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextDestroyTracingWrapperWithOneS
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextGetStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnGetStatus = [](ze_context_handle_t hContext) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnGetStatus = [](ze_context_handle_t hContext) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnGetStatusCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnGetStatusCb = genericEpilogCallbackPtr;
@@ -54,7 +54,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextGetStatusTracingWrapperWithOn
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextSystemBarrierTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnSystemBarrier = [](ze_context_handle_t hContext, ze_device_handle_t hDevice) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnSystemBarrier = [](ze_context_handle_t hContext, ze_device_handle_t hDevice) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnSystemBarrierCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnSystemBarrierCb = genericEpilogCallbackPtr;
@@ -68,7 +68,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextSystemBarrierTracingWrapperWi
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextMakeMemoryResidentTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnMakeMemoryResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnMakeMemoryResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnMakeMemoryResidentCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnMakeMemoryResidentCb = genericEpilogCallbackPtr;
@@ -82,7 +82,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextMakeMemoryResidentTracingWrap
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextEvictMemoryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnEvictMemory = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnEvictMemory = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnEvictMemoryCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnEvictMemoryCb = genericEpilogCallbackPtr;
@@ -96,7 +96,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextEvictMemoryTracingWrapperWith
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextMakeImageResidentTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnMakeImageResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnMakeImageResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnMakeImageResidentCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnMakeImageResidentCb = genericEpilogCallbackPtr;
@@ -110,7 +110,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextMakeImageResidentTracingWrapp
TEST_F(ZeApiTracingRuntimeTests, WhenCallingContextEvictImageTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Context.pfnEvictImage = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Context.pfnEvictImage = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Context.pfnEvictImageCb = genericPrologCallbackPtr;
epilogCbs.Context.pfnEvictImageCb = genericEpilogCallbackPtr;
@@ -157,130 +157,130 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
// arguments are expeted to be passed in from first prolog callback
driverDdiTable.coreDdiTable.Context.pfnMakeMemoryResident =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) {
EXPECT_EQ(hContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(hDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(ptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(size, MakeMemoryResident_args.size1);
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) -> ze_result_t {
EXPECT_EQ(hContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(hDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(ptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(size, MakeMemoryResident_args.size1);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Allocate instance data, pass it to corresponding epilog.
//
prologCbs0.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext0);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice0);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr0);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size0);
*params->phContext = MakeMemoryResident_args.hContext1;
*params->phDevice = MakeMemoryResident_args.hDevice1;
*params->pptr = MakeMemoryResident_args.ptr1;
*params->psize = MakeMemoryResident_args.size1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext0);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice0);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr0);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size0);
*params->phContext = MakeMemoryResident_args.hContext1;
*params->phDevice = MakeMemoryResident_args.hDevice1;
*params->pptr = MakeMemoryResident_args.ptr1;
*params->psize = MakeMemoryResident_args.size1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData0);
delete instanceData;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Allocate instance data and pass to corresponding epilog
//
prologCbs3.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
epilogCbs3.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData3);
delete instanceData;
};
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -322,128 +322,128 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
EvictMemory_args.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Context.pfnEvictMemory =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) {
EXPECT_EQ(hContext, EvictMemory_args.hContext1);
EXPECT_EQ(hDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(ptr, EvictMemory_args.ptr1);
EXPECT_EQ(size, EvictMemory_args.size1);
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) -> ze_result_t {
EXPECT_EQ(hContext, EvictMemory_args.hContext1);
EXPECT_EQ(hDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(ptr, EvictMemory_args.ptr1);
EXPECT_EQ(size, EvictMemory_args.size1);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Create instance data, pass it to corresponding epilog.
//
prologCbs0.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(EvictMemory_args.hContext0, *params->phContext);
EXPECT_EQ(EvictMemory_args.hDevice0, *params->phDevice);
EXPECT_EQ(EvictMemory_args.ptr0, *params->pptr);
EXPECT_EQ(EvictMemory_args.size0, *params->psize);
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(EvictMemory_args.hContext0, *params->phContext);
EXPECT_EQ(EvictMemory_args.hDevice0, *params->phDevice);
EXPECT_EQ(EvictMemory_args.ptr0, *params->pptr);
EXPECT_EQ(EvictMemory_args.size0, *params->psize);
*params->phContext = EvictMemory_args.hContext1;
*params->phDevice = EvictMemory_args.hDevice1;
*params->pptr = EvictMemory_args.ptr1;
*params->psize = EvictMemory_args.size1;
*params->phContext = EvictMemory_args.hContext1;
*params->phDevice = EvictMemory_args.hDevice1;
*params->pptr = EvictMemory_args.ptr1;
*params->psize = EvictMemory_args.size1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData0);
delete instanceData;
};
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Allocate instance data and pass to corresponding epilog
//
prologCbs3.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
epilogCbs3.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData3);
delete instanceData;
};
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
EXPECT_EQ(*params->psize, EvictMemory_args.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -483,122 +483,122 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
// arguments are expeted to be passed in from first prolog callback
driverDdiTable.coreDdiTable.Context.pfnMakeImageResident =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) {
EXPECT_EQ(hContext, MakeImageResident_args.hContext1);
EXPECT_EQ(hDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(hImage, MakeImageResident_args.hImage1);
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) -> ze_result_t {
EXPECT_EQ(hContext, MakeImageResident_args.hContext1);
EXPECT_EQ(hDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(hImage, MakeImageResident_args.hImage1);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Allocate instance data, pass it to corresponding epilog.
//
prologCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext0);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice0);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage0);
*params->phContext = MakeImageResident_args.hContext1;
*params->phDevice = MakeImageResident_args.hDevice1;
*params->phImage = MakeImageResident_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext0);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice0);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage0);
*params->phContext = MakeImageResident_args.hContext1;
*params->phDevice = MakeImageResident_args.hDevice1;
*params->phImage = MakeImageResident_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData0);
delete instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Allocate instance data and pass to corresponding epilog
//
prologCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
epilogCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData3);
delete instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -638,122 +638,122 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
// arguments are expeted to be passed in from first prolog callback
driverDdiTable.coreDdiTable.Context.pfnMakeImageResident =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) {
EXPECT_EQ(hContext, EvictImage_args.hContext1);
EXPECT_EQ(hDevice, EvictImage_args.hDevice1);
EXPECT_EQ(hImage, EvictImage_args.hImage1);
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) -> ze_result_t {
EXPECT_EQ(hContext, EvictImage_args.hContext1);
EXPECT_EQ(hDevice, EvictImage_args.hDevice1);
EXPECT_EQ(hImage, EvictImage_args.hImage1);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Allocate instance data, pass it to corresponding epilog.
//
prologCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext0);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice0);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage0);
*params->phContext = EvictImage_args.hContext1;
*params->phDevice = EvictImage_args.hDevice1;
*params->phImage = EvictImage_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext0);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice0);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage0);
*params->phContext = EvictImage_args.hContext1;
*params->phDevice = EvictImage_args.hDevice1;
*params->phImage = EvictImage_args.hImage1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData0);
delete instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Allocate instance data and pass to corresponding epilog
//
prologCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
epilogCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData3);
delete instanceData;
};
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();

434
level_zero/core/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp
View File

@@ -12,7 +12,7 @@ namespace ult {
TEST_F(ZeApiTracingRuntimeTests, WhenCallingSamplerCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Sampler.pfnCreate = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Sampler.pfnCreate = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Sampler.pfnCreateCb = genericPrologCallbackPtr;
epilogCbs.Sampler.pfnCreateCb = genericEpilogCallbackPtr;
@@ -26,7 +26,7 @@ TEST_F(ZeApiTracingRuntimeTests, WhenCallingSamplerCreateTracingWrapperWithOneSe
TEST_F(ZeApiTracingRuntimeTests, WhenCallingSamplerDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
driverDdiTable.coreDdiTable.Sampler.pfnDestroy = [](ze_sampler_handle_t hSampler) { return ZE_RESULT_SUCCESS; };
driverDdiTable.coreDdiTable.Sampler.pfnDestroy = [](ze_sampler_handle_t hSampler) -> ze_result_t { return ZE_RESULT_SUCCESS; };
prologCbs.Sampler.pfnDestroyCb = genericPrologCallbackPtr;
epilogCbs.Sampler.pfnDestroyCb = genericEpilogCallbackPtr;
@@ -72,217 +72,217 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
// Arguments are expected to be passed in by the first prolog callback
driverDdiTable.coreDdiTable.Sampler.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) {
EXPECT_EQ(sampler_create_args.hContext1, hContext);
EXPECT_EQ(sampler_create_args.hDevice1, hDevice);
EXPECT_EQ(&sampler_create_args.desc1, pDesc);
EXPECT_EQ(&sampler_create_args.hSampler1, phSampler);
EXPECT_EQ(sampler_create_args.hSampler1, *phSampler);
sampler_create_args.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
*phSampler = sampler_create_args.hSamplerAPI;
return ZE_RESULT_SUCCESS;
};
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) -> ze_result_t {
EXPECT_EQ(sampler_create_args.hContext1, hContext);
EXPECT_EQ(sampler_create_args.hDevice1, hDevice);
EXPECT_EQ(&sampler_create_args.desc1, pDesc);
EXPECT_EQ(&sampler_create_args.hSampler1, phSampler);
EXPECT_EQ(sampler_create_args.hSampler1, *phSampler);
sampler_create_args.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
*phSampler = sampler_create_args.hSamplerAPI;
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Create instance data, pass it to corresponding epilog.
//
prologCbs0.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_create_args.hContext0, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice0, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc0, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler0, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext0, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice0, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc0, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler0, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler0, handle);
*params->phContext = sampler_create_args.hContext1;
*params->phDevice = sampler_create_args.hDevice1;
*params->pdesc = &sampler_create_args.desc1;
*params->pphSampler = &sampler_create_args.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
EXPECT_EQ(sampler_create_args.hSampler0, handle);
*params->phContext = sampler_create_args.hContext1;
*params->phDevice = sampler_create_args.hDevice1;
*params->pdesc = &sampler_create_args.desc1;
*params->pphSampler = &sampler_create_args.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData0);
delete instanceData;
};
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Create instance data and pass to corresponding epilog
//
prologCbs3.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd epilog expects to see the API argument replacements
// Expect to see instance data from corresponding prolog
//
epilogCbs3.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&sampler_create_args.desc1, *params->pdesc);
EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
ppHandle = params->pphSampler;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
ze_sampler_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData3);
delete instanceData;
};
EXPECT_EQ(sampler_create_args.hSampler1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
@@ -315,106 +315,106 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
// Arguments are expected to be passed in by the first prolog callback
driverDdiTable.coreDdiTable.Sampler.pfnDestroy =
[](ze_sampler_handle_t hSampler) {
EXPECT_EQ(sampler_destroy_args.hSampler1, hSampler);
return ZE_RESULT_SUCCESS;
};
[](ze_sampler_handle_t hSampler) -> ze_result_t {
EXPECT_EQ(sampler_destroy_args.hSampler1, hSampler);
return ZE_RESULT_SUCCESS;
};
//
// The 0th prolog replaces the orignal API arguments with a new set
// Allocate instance data, pass it to corresponding epilog.
//
prologCbs0.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_destroy_args.hSampler0, *params->phSampler);
*params->phSampler = sampler_destroy_args.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler0, *params->phSampler);
*params->phSampler = sampler_destroy_args.hSampler1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
//
// The 0th epilog expects to see the API argument replacements
// Expect to receive instance data from corresponding prolog
//
epilogCbs0.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData0);
delete instanceData;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData0);
delete instanceData;
};
//
// The 1st prolog sees the arguments as replaced by the 0th prolog.
// There is no epilog for this prolog, so don't allocate instance data
//
prologCbs1.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
*val += 11;
};
//
// The 2nd epilog expects to see the API argument replacements
// There is no corresponding prolog, so there is no instance data
//
epilogCbs2.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
*val += 21;
};
//
// The 3rd prolog expects to see the API argument replacements and doesn't modify them
// Allocate instance data and pass to corresponding epilog
//
prologCbs3.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
//
// The 3rd epilog expects to see the API argument replacements
// Expect to see instance data from corresponding prolog
//
epilogCbs3.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData3);
delete instanceData;
};
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();