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

refactor: correct variable naming

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-12-01 12:07:00 +00:00
committed by Compute-Runtime-Automation
parent 039c993219
commit 7a17df93a6
9 changed files with 958 additions and 958 deletions
Download Patch File Download Diff File Expand all files Collapse all files

796
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

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

@@ -94,31 +94,31 @@ struct {
ze_fence_handle_t hFenceAPI;
void *instanceData0;
void *instanceData3;
} fence_create_args;
} fenceCreateArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
fence_create_args.hCommandQueue0 = generateRandomHandle<ze_command_queue_handle_t>();
fence_create_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fenceCreateArgs.hCommandQueue0 = generateRandomHandle<ze_command_queue_handle_t>();
fenceCreateArgs.hFence0 = generateRandomHandle<ze_fence_handle_t>();
// initialize replacement argument set
fence_create_args.hCommandQueue1 = generateRandomHandle<ze_command_queue_handle_t>();
fence_create_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fenceCreateArgs.hCommandQueue1 = generateRandomHandle<ze_command_queue_handle_t>();
fenceCreateArgs.hFence1 = generateRandomHandle<ze_fence_handle_t>();
// initialize user instance data
fence_create_args.instanceData0 = generateRandomHandle<void *>();
fence_create_args.instanceData3 = generateRandomHandle<void *>();
fenceCreateArgs.instanceData0 = generateRandomHandle<void *>();
fenceCreateArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Fence.pfnCreate =
[](ze_command_queue_handle_t hCommandQueue, const ze_fence_desc_t *desc, ze_fence_handle_t *phFence) -> ze_result_t {
EXPECT_EQ(fence_create_args.hCommandQueue1, hCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, desc);
EXPECT_EQ(&fence_create_args.hFence1, phFence);
EXPECT_EQ(fence_create_args.hFence1, *phFence);
fence_create_args.hFenceAPI = generateRandomHandle<ze_fence_handle_t>();
*phFence = fence_create_args.hFenceAPI;
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, hCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, desc);
EXPECT_EQ(&fenceCreateArgs.hFence1, phFence);
EXPECT_EQ(fenceCreateArgs.hFence1, *phFence);
fenceCreateArgs.hFenceAPI = generateRandomHandle<ze_fence_handle_t>();
*phFence = fenceCreateArgs.hFenceAPI;
return ZE_RESULT_SUCCESS;
};
@@ -128,9 +128,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
//
prologCbs0.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_create_args.hCommandQueue0, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc0, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence0, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue0, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc0, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence0, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -144,16 +144,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(fence_create_args.hFence0, handle);
*params->phCommandQueue = fence_create_args.hCommandQueue1;
*params->pdesc = &fence_create_args.desc1;
*params->pphFence = &fence_create_args.hFence1;
EXPECT_EQ(fenceCreateArgs.hFence0, handle);
*params->phCommandQueue = fenceCreateArgs.hCommandQueue1;
*params->pdesc = &fenceCreateArgs.desc1;
*params->pphFence = &fenceCreateArgs.hFence1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_create_args.instanceData0;
instanceData->instanceDataValue = fenceCreateArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -165,9 +165,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence1, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -181,13 +181,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(fence_create_args.hFence1, handle);
EXPECT_EQ(fenceCreateArgs.hFence1, 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, fence_create_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, fenceCreateArgs.instanceData0);
delete instanceData;
};
@@ -197,9 +197,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
//
prologCbs1.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence1, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -213,7 +213,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(fence_create_args.hFence1, handle);
EXPECT_EQ(fenceCreateArgs.hFence1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -227,9 +227,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
epilogCbs2.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence1, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -243,7 +243,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(fence_create_args.hFence1, handle);
EXPECT_EQ(fenceCreateArgs.hFence1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -256,9 +256,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
//
prologCbs3.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence1, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -272,13 +272,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(fence_create_args.hFence1, handle);
EXPECT_EQ(fenceCreateArgs.hFence1, 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 = fence_create_args.instanceData3;
instanceData->instanceDataValue = fenceCreateArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -290,9 +290,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
EXPECT_EQ(fenceCreateArgs.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fenceCreateArgs.desc1, *params->pdesc);
EXPECT_EQ(&fenceCreateArgs.hFence1, *params->pphFence);
ze_fence_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -307,21 +307,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
handle = *pHandle;
ASSERT_NE(nullptr, handle);
EXPECT_EQ(fence_create_args.hFence1, handle);
EXPECT_EQ(fenceCreateArgs.hFence1, 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, fence_create_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, fenceCreateArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeFenceCreateTracing(fence_create_args.hCommandQueue0, &fence_create_args.desc0, &fence_create_args.hFence0);
result = zeFenceCreateTracing(fenceCreateArgs.hCommandQueue0, &fenceCreateArgs.desc0, &fenceCreateArgs.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(fence_create_args.hFence1, fence_create_args.hFenceAPI);
EXPECT_EQ(fenceCreateArgs.hFence1, fenceCreateArgs.hFenceAPI);
validateDefaultUserDataFinal();
}
@@ -330,24 +330,24 @@ struct {
ze_fence_handle_t hFence1;
void *instanceData0;
void *instanceData3;
} fence_destroy_args;
} fenceDestroyArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
fence_destroy_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fenceDestroyArgs.hFence0 = generateRandomHandle<ze_fence_handle_t>();
// initialize replacement argument set
fence_destroy_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fenceDestroyArgs.hFence1 = generateRandomHandle<ze_fence_handle_t>();
// initialize user instance data
fence_destroy_args.instanceData0 = generateRandomHandle<void *>();
fence_destroy_args.instanceData3 = generateRandomHandle<void *>();
fenceDestroyArgs.instanceData0 = generateRandomHandle<void *>();
fenceDestroyArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Fence.pfnDestroy =
[](ze_fence_handle_t hFence) -> ze_result_t {
EXPECT_EQ(fence_destroy_args.hFence1, hFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, hFence);
return ZE_RESULT_SUCCESS;
};
@@ -357,14 +357,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
//
prologCbs0.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_destroy_args.hFence0, *params->phFence);
*params->phFence = fence_destroy_args.hFence1;
EXPECT_EQ(fenceDestroyArgs.hFence0, *params->phFence);
*params->phFence = fenceDestroyArgs.hFence1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_destroy_args.instanceData0;
instanceData->instanceDataValue = fenceDestroyArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -376,13 +376,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_destroy_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, fenceDestroyArgs.instanceData0);
delete instanceData;
};
@@ -392,7 +392,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
//
prologCbs1.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -406,7 +406,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
epilogCbs2.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -419,13 +419,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
//
prologCbs3.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_destroy_args.instanceData3;
instanceData->instanceDataValue = fenceDestroyArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -437,19 +437,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
EXPECT_EQ(fenceDestroyArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_destroy_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, fenceDestroyArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeFenceDestroyTracing(fence_destroy_args.hFence0);
result = zeFenceDestroyTracing(fenceDestroyArgs.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -461,27 +461,27 @@ struct {
uint64_t timeout1;
void *instanceData0;
void *instanceData3;
} fence_host_synchronize_args;
} fenceHostSynchronizeArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchronizeTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
fence_host_synchronize_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fence_host_synchronize_args.timeout0 = generateRandomSize<uint64_t>();
fenceHostSynchronizeArgs.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fenceHostSynchronizeArgs.timeout0 = generateRandomSize<uint64_t>();
// initialize replacement argument set
fence_host_synchronize_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fence_host_synchronize_args.timeout1 = generateRandomSize<uint64_t>();
fenceHostSynchronizeArgs.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fenceHostSynchronizeArgs.timeout1 = generateRandomSize<uint64_t>();
// initialize user instance data
fence_host_synchronize_args.instanceData0 = generateRandomHandle<void *>();
fence_host_synchronize_args.instanceData3 = generateRandomHandle<void *>();
fenceHostSynchronizeArgs.instanceData0 = generateRandomHandle<void *>();
fenceHostSynchronizeArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Fence.pfnHostSynchronize =
[](ze_fence_handle_t hFence, uint64_t timeout) -> ze_result_t {
EXPECT_EQ(fence_host_synchronize_args.hFence1, hFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, timeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, hFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, timeout);
return ZE_RESULT_SUCCESS;
};
@@ -491,16 +491,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
//
prologCbs0.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_host_synchronize_args.hFence0, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout0, *params->ptimeout);
*params->phFence = fence_host_synchronize_args.hFence1;
*params->ptimeout = fence_host_synchronize_args.timeout1;
EXPECT_EQ(fenceHostSynchronizeArgs.hFence0, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout0, *params->ptimeout);
*params->phFence = fenceHostSynchronizeArgs.hFence1;
*params->ptimeout = fenceHostSynchronizeArgs.timeout1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_host_synchronize_args.instanceData0;
instanceData->instanceDataValue = fenceHostSynchronizeArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -512,14 +512,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, *params->ptimeout);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_host_synchronize_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, fenceHostSynchronizeArgs.instanceData0);
delete instanceData;
};
@@ -529,8 +529,8 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
//
prologCbs1.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, *params->ptimeout);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -544,8 +544,8 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
epilogCbs2.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, *params->ptimeout);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -558,14 +558,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
//
prologCbs3.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, *params->ptimeout);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_host_synchronize_args.instanceData3;
instanceData->instanceDataValue = fenceHostSynchronizeArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -577,20 +577,20 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
EXPECT_EQ(fenceHostSynchronizeArgs.hFence1, *params->phFence);
EXPECT_EQ(fenceHostSynchronizeArgs.timeout1, *params->ptimeout);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_host_synchronize_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, fenceHostSynchronizeArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeFenceHostSynchronizeTracing(fence_host_synchronize_args.hFence0, fence_host_synchronize_args.timeout0);
result = zeFenceHostSynchronizeTracing(fenceHostSynchronizeArgs.hFence0, fenceHostSynchronizeArgs.timeout0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -600,24 +600,24 @@ struct {
ze_fence_handle_t hFence1;
void *instanceData0;
void *instanceData3;
} fence_query_status_args;
} fenceQueryStatusArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
fence_query_status_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fenceQueryStatusArgs.hFence0 = generateRandomHandle<ze_fence_handle_t>();
// initialize replacement argument set
fence_query_status_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fenceQueryStatusArgs.hFence1 = generateRandomHandle<ze_fence_handle_t>();
// initialize user instance data
fence_query_status_args.instanceData0 = generateRandomHandle<void *>();
fence_query_status_args.instanceData3 = generateRandomHandle<void *>();
fenceQueryStatusArgs.instanceData0 = generateRandomHandle<void *>();
fenceQueryStatusArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Fence.pfnQueryStatus =
[](ze_fence_handle_t hFence) -> ze_result_t {
EXPECT_EQ(fence_query_status_args.hFence1, hFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, hFence);
return ZE_RESULT_SUCCESS;
};
@@ -627,14 +627,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
//
prologCbs0.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_query_status_args.hFence0, *params->phFence);
*params->phFence = fence_query_status_args.hFence1;
EXPECT_EQ(fenceQueryStatusArgs.hFence0, *params->phFence);
*params->phFence = fenceQueryStatusArgs.hFence1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_query_status_args.instanceData0;
instanceData->instanceDataValue = fenceQueryStatusArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -646,13 +646,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_query_status_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, fenceQueryStatusArgs.instanceData0);
delete instanceData;
};
@@ -662,7 +662,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
//
prologCbs1.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -676,7 +676,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
epilogCbs2.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -689,13 +689,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
//
prologCbs3.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_query_status_args.instanceData3;
instanceData->instanceDataValue = fenceQueryStatusArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -707,19 +707,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
EXPECT_EQ(fenceQueryStatusArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_query_status_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, fenceQueryStatusArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeFenceQueryStatusTracing(fence_query_status_args.hFence0);
result = zeFenceQueryStatusTracing(fenceQueryStatusArgs.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -729,24 +729,24 @@ struct {
ze_fence_handle_t hFence1;
void *instanceData0;
void *instanceData3;
} fence_reset_args;
} fenceResetArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
fence_reset_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
fenceResetArgs.hFence0 = generateRandomHandle<ze_fence_handle_t>();
// initialize replacement argument set
fence_reset_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
fenceResetArgs.hFence1 = generateRandomHandle<ze_fence_handle_t>();
// initialize user instance data
fence_reset_args.instanceData0 = generateRandomHandle<void *>();
fence_reset_args.instanceData3 = generateRandomHandle<void *>();
fenceResetArgs.instanceData0 = generateRandomHandle<void *>();
fenceResetArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Fence.pfnReset =
[](ze_fence_handle_t hFence) -> ze_result_t {
EXPECT_EQ(fence_reset_args.hFence1, hFence);
EXPECT_EQ(fenceResetArgs.hFence1, hFence);
return ZE_RESULT_SUCCESS;
};
@@ -756,14 +756,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
//
prologCbs0.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_reset_args.hFence0, *params->phFence);
*params->phFence = fence_reset_args.hFence1;
EXPECT_EQ(fenceResetArgs.hFence0, *params->phFence);
*params->phFence = fenceResetArgs.hFence1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_reset_args.instanceData0;
instanceData->instanceDataValue = fenceResetArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -775,13 +775,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
EXPECT_EQ(fenceResetArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_reset_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, fenceResetArgs.instanceData0);
delete instanceData;
};
@@ -791,7 +791,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
//
prologCbs1.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
EXPECT_EQ(fenceResetArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -805,7 +805,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
epilogCbs2.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
EXPECT_EQ(fenceResetArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -818,13 +818,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
//
prologCbs3.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
EXPECT_EQ(fenceResetArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_reset_args.instanceData3;
instanceData->instanceDataValue = fenceResetArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -836,19 +836,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
EXPECT_EQ(fenceResetArgs.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_reset_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, fenceResetArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeFenceResetTracing(fence_reset_args.hFence0);
result = zeFenceResetTracing(fenceResetArgs.hFence0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

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

@@ -69,26 +69,26 @@ struct {
ze_image_properties_t imageProperties1;
void *instanceData0;
void *instanceData3;
} ImageGetProperties_args;
} imageGetPropertiesArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
ImageGetProperties_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
imageGetPropertiesArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
// initialize replacement argument set
ImageGetProperties_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
imageGetPropertiesArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
// initialize user instance data
ImageGetProperties_args.instanceData0 = generateRandomHandle<void *>();
ImageGetProperties_args.instanceData3 = generateRandomHandle<void *>();
imageGetPropertiesArgs.instanceData0 = generateRandomHandle<void *>();
imageGetPropertiesArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Image.pfnGetProperties =
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, hDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, desc);
EXPECT_EQ(&imageGetPropertiesArgs.imageProperties1, pImageProperties);
return ZE_RESULT_SUCCESS;
};
@@ -98,18 +98,18 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
//
prologCbs0.Image.pfnGetPropertiesCb =
[](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;
EXPECT_EQ(imageGetPropertiesArgs.hDevice0, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc0, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.imageProperties0, *params->ppImageProperties);
*params->phDevice = imageGetPropertiesArgs.hDevice1;
*params->pdesc = &imageGetPropertiesArgs.desc1;
*params->ppImageProperties = &imageGetPropertiesArgs.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;
instanceData->instanceDataValue = imageGetPropertiesArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -121,15 +121,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageGetPropertiesArgs.instanceData0);
delete instanceData;
};
@@ -139,9 +139,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
//
prologCbs1.Image.pfnGetPropertiesCb =
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -155,9 +155,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
epilogCbs2.Image.pfnGetPropertiesCb =
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.imageProperties1, *params->ppImageProperties);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -170,15 +170,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
//
prologCbs3.Image.pfnGetPropertiesCb =
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.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;
instanceData->instanceDataValue = imageGetPropertiesArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -190,21 +190,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
[](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);
EXPECT_EQ(imageGetPropertiesArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageGetPropertiesArgs.desc1, *params->pdesc);
EXPECT_EQ(&imageGetPropertiesArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageGetPropertiesArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeImageGetPropertiesTracing(ImageGetProperties_args.hDevice0, &ImageGetProperties_args.desc0, &ImageGetProperties_args.imageProperties0);
result = zeImageGetPropertiesTracing(imageGetPropertiesArgs.hDevice0, &imageGetPropertiesArgs.desc0, &imageGetPropertiesArgs.imageProperties0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -221,34 +221,34 @@ struct {
ze_image_handle_t hImageAPI;
void *instanceData0;
void *instanceData3;
} ImageCreate_args;
} imageCreateArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
ImageCreate_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
ImageCreate_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
ImageCreate_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
imageCreateArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
imageCreateArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
imageCreateArgs.hImage0 = generateRandomHandle<ze_image_handle_t>();
// initialize replacement argument set
ImageCreate_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
ImageCreate_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
ImageCreate_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
imageCreateArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
imageCreateArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
imageCreateArgs.hImage1 = generateRandomHandle<ze_image_handle_t>();
// initialize user instance data
ImageCreate_args.instanceData0 = generateRandomHandle<void *>();
ImageCreate_args.instanceData3 = generateRandomHandle<void *>();
imageCreateArgs.instanceData0 = generateRandomHandle<void *>();
imageCreateArgs.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) -> 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;
EXPECT_EQ(imageCreateArgs.hContext1, hContext);
EXPECT_EQ(imageCreateArgs.hDevice1, hDevice);
EXPECT_EQ(&imageCreateArgs.desc1, desc);
EXPECT_EQ(&imageCreateArgs.hImage1, phImage);
EXPECT_EQ(imageCreateArgs.hImage1, *phImage);
imageCreateArgs.hImageAPI = generateRandomHandle<ze_image_handle_t>();
*phImage = imageCreateArgs.hImageAPI;
return ZE_RESULT_SUCCESS;
};
@@ -263,9 +263,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
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);
EXPECT_EQ(imageCreateArgs.hContext0, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice0, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc0, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -274,23 +274,23 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage0, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage0, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage0, handle);
EXPECT_EQ(imageCreateArgs.hImage0, handle);
*params->phContext = ImageCreate_args.hContext1;
*params->phDevice = ImageCreate_args.hDevice1;
*params->pdesc = &ImageCreate_args.desc1;
*params->pphImage = &ImageCreate_args.hImage1;
*params->phContext = imageCreateArgs.hContext1;
*params->phDevice = imageCreateArgs.hDevice1;
*params->pdesc = &imageCreateArgs.desc1;
*params->pphImage = &imageCreateArgs.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;
instanceData->instanceDataValue = imageCreateArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -307,9 +307,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
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);
EXPECT_EQ(imageCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -318,19 +318,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
EXPECT_EQ(imageCreateArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageCreateArgs.instanceData0);
delete instanceData;
};
@@ -340,9 +340,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
//
prologCbs1.Image.pfnCreateCb =
[](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);
EXPECT_EQ(imageCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -351,12 +351,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
EXPECT_EQ(imageCreateArgs.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -371,9 +371,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
epilogCbs2.Image.pfnCreateCb =
[](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);
EXPECT_EQ(imageCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -382,12 +382,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
EXPECT_EQ(imageCreateArgs.hImage1, handle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -401,9 +401,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
//
prologCbs3.Image.pfnCreateCb =
[](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);
EXPECT_EQ(imageCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -412,19 +412,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
EXPECT_EQ(imageCreateArgs.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;
instanceData->instanceDataValue = imageCreateArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -436,9 +436,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
[](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);
EXPECT_EQ(imageCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(imageCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&imageCreateArgs.desc1, *params->pdesc);
ze_image_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -447,25 +447,25 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
ze_image_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
EXPECT_EQ(&imageCreateArgs.hImage1, pHandle);
ze_image_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(ImageCreate_args.hImage1, handle);
EXPECT_EQ(imageCreateArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageCreateArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeImageCreateTracing(ImageCreate_args.hContext0, ImageCreate_args.hDevice0, &ImageCreate_args.desc0, &ImageCreate_args.hImage0);
result = zeImageCreateTracing(imageCreateArgs.hContext0, imageCreateArgs.hDevice0, &imageCreateArgs.desc0, &imageCreateArgs.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -475,24 +475,24 @@ struct {
ze_image_handle_t hImage1;
void *instanceData0;
void *instanceData3;
} ImageDestroy_args;
} imageDestroyArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
ImageDestroy_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
imageDestroyArgs.hImage0 = generateRandomHandle<ze_image_handle_t>();
// initialize replacement argument set
ImageDestroy_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
imageDestroyArgs.hImage1 = generateRandomHandle<ze_image_handle_t>();
// initialize user instance data
ImageDestroy_args.instanceData0 = generateRandomHandle<void *>();
ImageDestroy_args.instanceData3 = generateRandomHandle<void *>();
imageDestroyArgs.instanceData0 = generateRandomHandle<void *>();
imageDestroyArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Image.pfnDestroy =
[](ze_image_handle_t hImage) -> ze_result_t {
EXPECT_EQ(ImageDestroy_args.hImage1, hImage);
EXPECT_EQ(imageDestroyArgs.hImage1, hImage);
return ZE_RESULT_SUCCESS;
};
@@ -502,14 +502,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
//
prologCbs0.Image.pfnDestroyCb =
[](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;
EXPECT_EQ(imageDestroyArgs.hImage0, *params->phImage);
*params->phImage = imageDestroyArgs.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;
instanceData->instanceDataValue = imageDestroyArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -521,13 +521,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
[](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);
EXPECT_EQ(imageDestroyArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageDestroyArgs.instanceData0);
delete instanceData;
};
@@ -537,7 +537,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
//
prologCbs1.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
EXPECT_EQ(imageDestroyArgs.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -551,7 +551,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
epilogCbs2.Image.pfnDestroyCb =
[](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);
EXPECT_EQ(imageDestroyArgs.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -564,13 +564,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
//
prologCbs3.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
EXPECT_EQ(imageDestroyArgs.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;
instanceData->instanceDataValue = imageDestroyArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -582,19 +582,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
[](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);
EXPECT_EQ(imageDestroyArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, imageDestroyArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeImageDestroyTracing(ImageDestroy_args.hImage0);
result = zeImageDestroyTracing(imageDestroyArgs.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

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

@@ -27,7 +27,7 @@ struct {
ze_module_build_log_handle_t hBuildLogAPI;
void *instanceData0;
void *instanceData3;
} module_create_args;
} moduleCreateArgs;
static void moduleCreateDescInitRandom(ze_module_desc_t *desc) {
uint8_t *ptr = (uint8_t *)desc;
@@ -50,37 +50,37 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
module_create_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
module_create_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
moduleCreateDescInitRandom(&module_create_args.desc0);
module_create_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
module_create_args.hBuildLog0 = generateRandomHandle<ze_module_build_log_handle_t>();
moduleCreateArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
moduleCreateArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
moduleCreateDescInitRandom(&moduleCreateArgs.desc0);
moduleCreateArgs.hModule0 = generateRandomHandle<ze_module_handle_t>();
moduleCreateArgs.hBuildLog0 = generateRandomHandle<ze_module_build_log_handle_t>();
// initialize replacement argument set
module_create_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
module_create_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
moduleCreateDescInitRandom(&module_create_args.desc1);
module_create_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
module_create_args.hBuildLog1 = generateRandomHandle<ze_module_build_log_handle_t>();
moduleCreateArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
moduleCreateArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
moduleCreateDescInitRandom(&moduleCreateArgs.desc1);
moduleCreateArgs.hModule1 = generateRandomHandle<ze_module_handle_t>();
moduleCreateArgs.hBuildLog1 = generateRandomHandle<ze_module_build_log_handle_t>();
// initialize user instance data
module_create_args.instanceData0 = generateRandomHandle<void *>();
module_create_args.instanceData3 = generateRandomHandle<void *>();
moduleCreateArgs.instanceData0 = generateRandomHandle<void *>();
moduleCreateArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Module.pfnCreate =
[](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t *desc, ze_module_handle_t *phModule, ze_module_build_log_handle_t *phBuildLog) -> ze_result_t {
EXPECT_EQ(module_create_args.hContext1, hContext);
EXPECT_EQ(module_create_args.hDevice1, hDevice);
EXPECT_EQ(&module_create_args.desc1, desc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, desc));
EXPECT_EQ(&module_create_args.hModule1, phModule);
EXPECT_EQ(module_create_args.hModule1, *phModule);
EXPECT_EQ(&module_create_args.hBuildLog1, phBuildLog);
EXPECT_EQ(module_create_args.hBuildLog1, *phBuildLog);
module_create_args.hModuleAPI = generateRandomHandle<ze_module_handle_t>();
module_create_args.hBuildLogAPI = generateRandomHandle<ze_module_build_log_handle_t>();
*phModule = module_create_args.hModuleAPI;
*phBuildLog = module_create_args.hBuildLogAPI;
EXPECT_EQ(moduleCreateArgs.hContext1, hContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, hDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, desc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, desc));
EXPECT_EQ(&moduleCreateArgs.hModule1, phModule);
EXPECT_EQ(moduleCreateArgs.hModule1, *phModule);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, phBuildLog);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, *phBuildLog);
moduleCreateArgs.hModuleAPI = generateRandomHandle<ze_module_handle_t>();
moduleCreateArgs.hBuildLogAPI = generateRandomHandle<ze_module_build_log_handle_t>();
*phModule = moduleCreateArgs.hModuleAPI;
*phBuildLog = moduleCreateArgs.hBuildLogAPI;
return ZE_RESULT_SUCCESS;
};
@@ -90,10 +90,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
//
prologCbs0.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_create_args.hContext0, *params->phContext);
EXPECT_EQ(module_create_args.hDevice0, *params->phDevice);
EXPECT_EQ(&module_create_args.desc0, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc0, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext0, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice0, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc0, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc0, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -102,12 +102,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule0, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule0, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule0, handle);
EXPECT_EQ(moduleCreateArgs.hModule0, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -115,25 +115,25 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog0, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog0, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog0, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog0, logHandle);
*params->phContext = module_create_args.hContext1;
*params->phDevice = module_create_args.hDevice1;
*params->pdesc = &module_create_args.desc1;
*params->pphModule = &module_create_args.hModule1;
*params->pphBuildLog = &module_create_args.hBuildLog1;
*params->phContext = moduleCreateArgs.hContext1;
*params->phDevice = moduleCreateArgs.hDevice1;
*params->pdesc = &moduleCreateArgs.desc1;
*params->pphModule = &moduleCreateArgs.hModule1;
*params->pphBuildLog = &moduleCreateArgs.hBuildLog1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_create_args.instanceData0;
instanceData->instanceDataValue = moduleCreateArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -145,10 +145,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&module_create_args.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -157,12 +157,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule1, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule1, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule1, handle);
EXPECT_EQ(moduleCreateArgs.hModule1, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -170,19 +170,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, logHandle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_create_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, moduleCreateArgs.instanceData0);
delete instanceData;
};
@@ -192,10 +192,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
//
prologCbs1.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&module_create_args.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -204,12 +204,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule1, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule1, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule1, handle);
EXPECT_EQ(moduleCreateArgs.hModule1, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -217,12 +217,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, logHandle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -237,10 +237,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
epilogCbs2.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&module_create_args.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -249,12 +249,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule1, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule1, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule1, handle);
EXPECT_EQ(moduleCreateArgs.hModule1, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -262,12 +262,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, logHandle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -281,10 +281,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
//
prologCbs3.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&module_create_args.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -293,12 +293,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule1, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule1, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule1, handle);
EXPECT_EQ(moduleCreateArgs.hModule1, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -306,19 +306,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, logHandle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_create_args.instanceData3;
instanceData->instanceDataValue = moduleCreateArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -330,10 +330,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
EXPECT_EQ(&module_create_args.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&module_create_args.desc1, *params->pdesc));
EXPECT_EQ(moduleCreateArgs.hContext1, *params->phContext);
EXPECT_EQ(moduleCreateArgs.hDevice1, *params->phDevice);
EXPECT_EQ(&moduleCreateArgs.desc1, *params->pdesc);
EXPECT_TRUE(moduleCreateDescCompare(&moduleCreateArgs.desc1, *params->pdesc));
ze_module_handle_t **ppHandle;
ASSERT_NE(nullptr, params);
@@ -342,12 +342,12 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_handle_t *pHandle;
ASSERT_NE(nullptr, ppHandle);
pHandle = *ppHandle;
EXPECT_EQ(&module_create_args.hModule1, pHandle);
EXPECT_EQ(&moduleCreateArgs.hModule1, pHandle);
ze_module_handle_t handle;
ASSERT_NE(nullptr, pHandle);
handle = *pHandle;
EXPECT_EQ(module_create_args.hModule1, handle);
EXPECT_EQ(moduleCreateArgs.hModule1, handle);
ze_module_build_log_handle_t **ppLogHandle;
ppLogHandle = params->pphBuildLog;
@@ -355,25 +355,25 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
ze_module_build_log_handle_t *pLogHandle;
ASSERT_NE(nullptr, ppLogHandle);
pLogHandle = *ppLogHandle;
EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
EXPECT_EQ(&moduleCreateArgs.hBuildLog1, pLogHandle);
ze_module_build_log_handle_t logHandle;
logHandle = *pLogHandle;
ASSERT_NE(nullptr, logHandle);
EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
EXPECT_EQ(moduleCreateArgs.hBuildLog1, logHandle);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_create_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, moduleCreateArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeModuleCreateTracing(module_create_args.hContext0, module_create_args.hDevice0, &module_create_args.desc0, &module_create_args.hModule0, &module_create_args.hBuildLog0);
result = zeModuleCreateTracing(moduleCreateArgs.hContext0, moduleCreateArgs.hDevice0, &moduleCreateArgs.desc0, &moduleCreateArgs.hModule0, &moduleCreateArgs.hBuildLog0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -383,24 +383,24 @@ struct {
ze_module_handle_t hModule1;
void *instanceData0;
void *instanceData3;
} module_destroy_args;
} moduleDestroyArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
module_destroy_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
moduleDestroyArgs.hModule0 = generateRandomHandle<ze_module_handle_t>();
// initialize replacement argument set
module_destroy_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
moduleDestroyArgs.hModule1 = generateRandomHandle<ze_module_handle_t>();
// initialize user instance data
module_destroy_args.instanceData0 = generateRandomHandle<void *>();
module_destroy_args.instanceData3 = generateRandomHandle<void *>();
moduleDestroyArgs.instanceData0 = generateRandomHandle<void *>();
moduleDestroyArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Module.pfnDestroy =
[](ze_module_handle_t hModule) -> ze_result_t {
EXPECT_EQ(module_destroy_args.hModule1, hModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, hModule);
return ZE_RESULT_SUCCESS;
};
@@ -410,14 +410,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
//
prologCbs0.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_destroy_args.hModule0, *params->phModule);
*params->phModule = module_destroy_args.hModule1;
EXPECT_EQ(moduleDestroyArgs.hModule0, *params->phModule);
*params->phModule = moduleDestroyArgs.hModule1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_destroy_args.instanceData0;
instanceData->instanceDataValue = moduleDestroyArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -429,13 +429,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_destroy_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, moduleDestroyArgs.instanceData0);
delete instanceData;
};
@@ -445,7 +445,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
//
prologCbs1.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -459,7 +459,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
epilogCbs2.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -472,13 +472,13 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
//
prologCbs3.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_destroy_args.instanceData3;
instanceData->instanceDataValue = moduleDestroyArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -490,19 +490,19 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
EXPECT_EQ(moduleDestroyArgs.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_destroy_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, moduleDestroyArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeModuleDestroyTracing(module_destroy_args.hModule0);
result = zeModuleDestroyTracing(moduleDestroyArgs.hModule0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -519,7 +519,7 @@ struct {
uint8_t moduleNativeBinary1[moduleGetNativeBinarySize1];
void *instanceData0;
void *instanceData3;
} module_get_native_binary_args;
} moduleGetNativeBinaryArgs;
static void moduleGetNativeBinaryNativeBinaryInitRandom(uint8_t *binary, size_t size) {
uint8_t *ptr = binary;
@@ -542,24 +542,24 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
module_get_native_binary_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
moduleGetNativeBinaryNativeBinaryInitRandom(module_get_native_binary_args.moduleNativeBinary0, moduleGetNativeBinarySize0);
moduleGetNativeBinaryArgs.hModule0 = generateRandomHandle<ze_module_handle_t>();
moduleGetNativeBinaryNativeBinaryInitRandom(moduleGetNativeBinaryArgs.moduleNativeBinary0, moduleGetNativeBinarySize0);
// initialize replacement argument set
module_get_native_binary_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
moduleGetNativeBinaryNativeBinaryInitRandom(module_get_native_binary_args.moduleNativeBinary1, moduleGetNativeBinarySize1);
moduleGetNativeBinaryArgs.hModule1 = generateRandomHandle<ze_module_handle_t>();
moduleGetNativeBinaryNativeBinaryInitRandom(moduleGetNativeBinaryArgs.moduleNativeBinary1, moduleGetNativeBinarySize1);
// initialize user instance data
module_get_native_binary_args.instanceData0 = generateRandomHandle<void *>();
module_get_native_binary_args.instanceData3 = generateRandomHandle<void *>();
moduleGetNativeBinaryArgs.instanceData0 = generateRandomHandle<void *>();
moduleGetNativeBinaryArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Module.pfnGetNativeBinary =
[](ze_module_handle_t hModule, size_t *pSize, uint8_t *pModuleNativeBinary) -> ze_result_t {
EXPECT_EQ(module_get_native_binary_args.hModule1, hModule);
EXPECT_EQ(&module_get_native_binary_args.size1, pSize);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, hModule);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, pSize);
EXPECT_EQ(*pSize, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, pModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, pModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
pModuleNativeBinary, moduleGetNativeBinarySize0));
return ZE_RESULT_SUCCESS;
};
@@ -570,7 +570,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
//
prologCbs0.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_get_native_binary_args.hModule0, *params->phModule);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule0, *params->phModule);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -579,26 +579,26 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size0, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size0, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize0);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary0, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary0,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary0, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary0,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize0));
*params->phModule = module_get_native_binary_args.hModule1;
*params->ppSize = &module_get_native_binary_args.size1;
*params->ppModuleNativeBinary = module_get_native_binary_args.moduleNativeBinary1;
*params->phModule = moduleGetNativeBinaryArgs.hModule1;
*params->ppSize = &moduleGetNativeBinaryArgs.size1;
*params->ppModuleNativeBinary = moduleGetNativeBinaryArgs.moduleNativeBinary1;
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_get_native_binary_args.instanceData0;
instanceData->instanceDataValue = moduleGetNativeBinaryArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -610,7 +610,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, *params->phModule);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -619,22 +619,22 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_get_native_binary_args.instanceData0);
EXPECT_EQ(instanceData->instanceDataValue, moduleGetNativeBinaryArgs.instanceData0);
delete instanceData;
};
@@ -644,7 +644,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
//
prologCbs1.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, *params->phModule);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -653,15 +653,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -676,7 +676,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
epilogCbs2.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, *params->phModule);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -685,15 +685,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
@@ -707,8 +707,8 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
//
prologCbs3.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, *params->phModule);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -717,22 +717,22 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_get_native_binary_args.instanceData3;
instanceData->instanceDataValue = moduleGetNativeBinaryArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -744,7 +744,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) -> void {
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
EXPECT_EQ(moduleGetNativeBinaryArgs.hModule1, *params->phModule);
size_t **ppSize;
ASSERT_NE(nullptr, params);
@@ -753,28 +753,28 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
size_t *pSize;
ASSERT_NE(nullptr, ppSize);
pSize = *ppSize;
EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
EXPECT_EQ(&moduleGetNativeBinaryArgs.size1, *params->ppSize);
size_t size;
ASSERT_NE(nullptr, pSize);
size = *pSize;
EXPECT_EQ(size, moduleGetNativeBinarySize1);
EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(module_get_native_binary_args.moduleNativeBinary1,
EXPECT_EQ(moduleGetNativeBinaryArgs.moduleNativeBinary1, *params->ppModuleNativeBinary);
EXPECT_TRUE(moduleGetNativeBinaryNativeBinaryCompare(moduleGetNativeBinaryArgs.moduleNativeBinary1,
*params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_get_native_binary_args.instanceData3);
EXPECT_EQ(instanceData->instanceDataValue, moduleGetNativeBinaryArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeModuleGetNativeBinaryTracing(module_get_native_binary_args.hModule0, &module_get_native_binary_args.size0, module_get_native_binary_args.moduleNativeBinary0);
result = zeModuleGetNativeBinaryTracing(moduleGetNativeBinaryArgs.hModule0, &moduleGetNativeBinaryArgs.size0, moduleGetNativeBinaryArgs.moduleNativeBinary0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}

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

@@ -133,35 +133,35 @@ struct {
size_t size1;
void *instanceData0;
void *instanceData3;
} MakeMemoryResident_args;
} makeMemoryResidentArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
WhenCallingContextMakeMemoryResidentTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
MakeMemoryResident_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
MakeMemoryResident_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
MakeMemoryResident_args.ptr0 = generateRandomHandle<void *>();
MakeMemoryResident_args.size0 = generateRandomSize<size_t>();
makeMemoryResidentArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
makeMemoryResidentArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
makeMemoryResidentArgs.ptr0 = generateRandomHandle<void *>();
makeMemoryResidentArgs.size0 = generateRandomSize<size_t>();
// initialize replacement argument set
MakeMemoryResident_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
MakeMemoryResident_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
MakeMemoryResident_args.ptr1 = generateRandomHandle<void *>();
MakeMemoryResident_args.size1 = generateRandomSize<size_t>();
makeMemoryResidentArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
makeMemoryResidentArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
makeMemoryResidentArgs.ptr1 = generateRandomHandle<void *>();
makeMemoryResidentArgs.size1 = generateRandomSize<size_t>();
// initialize user instance data
MakeMemoryResident_args.instanceData0 = generateRandomHandle<void *>();
MakeMemoryResident_args.instanceData3 = generateRandomHandle<void *>();
makeMemoryResidentArgs.instanceData0 = generateRandomHandle<void *>();
makeMemoryResidentArgs.instanceData3 = generateRandomHandle<void *>();
// 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) -> 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);
EXPECT_EQ(hContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(hDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(ptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(size, makeMemoryResidentArgs.size1);
return ZE_RESULT_SUCCESS;
};
@@ -171,20 +171,20 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs0.Context.pfnMakeMemoryResidentCb =
[](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;
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext0);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice0);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr0);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.size0);
*params->phContext = makeMemoryResidentArgs.hContext1;
*params->phDevice = makeMemoryResidentArgs.hDevice1;
*params->pptr = makeMemoryResidentArgs.ptr1;
*params->psize = makeMemoryResidentArgs.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;
instanceData->instanceDataValue = makeMemoryResidentArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -196,16 +196,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, makeMemoryResidentArgs.instanceData0);
delete instanceData;
};
@@ -215,10 +215,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs1.Context.pfnMakeMemoryResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -232,10 +232,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
epilogCbs2.Context.pfnMakeMemoryResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -248,16 +248,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs3.Context.pfnMakeMemoryResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.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;
instanceData->instanceDataValue = makeMemoryResidentArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -269,22 +269,22 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phContext, makeMemoryResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeMemoryResidentArgs.hDevice1);
EXPECT_EQ(*params->pptr, makeMemoryResidentArgs.ptr1);
EXPECT_EQ(*params->psize, makeMemoryResidentArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, makeMemoryResidentArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeContextMakeMemoryResidentTracing(MakeMemoryResident_args.hContext0, MakeMemoryResident_args.hDevice0, MakeMemoryResident_args.ptr0, MakeMemoryResident_args.size0);
result = zeContextMakeMemoryResidentTracing(makeMemoryResidentArgs.hContext0, makeMemoryResidentArgs.hDevice0, makeMemoryResidentArgs.ptr0, makeMemoryResidentArgs.size0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -300,33 +300,33 @@ struct {
size_t size1;
void *instanceData0;
void *instanceData3;
} EvictMemory_args;
} evictMemoryArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
EvictMemory_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
EvictMemory_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
EvictMemory_args.ptr0 = generateRandomHandle<void *>();
EvictMemory_args.size0 = generateRandomSize<size_t>();
evictMemoryArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
evictMemoryArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
evictMemoryArgs.ptr0 = generateRandomHandle<void *>();
evictMemoryArgs.size0 = generateRandomSize<size_t>();
// initialize replacement argument set
EvictMemory_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
EvictMemory_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
EvictMemory_args.ptr1 = generateRandomHandle<void *>();
EvictMemory_args.size1 = generateRandomSize<size_t>();
evictMemoryArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
evictMemoryArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
evictMemoryArgs.ptr1 = generateRandomHandle<void *>();
evictMemoryArgs.size1 = generateRandomSize<size_t>();
// initialize user instance data
EvictMemory_args.instanceData0 = generateRandomHandle<void *>();
EvictMemory_args.instanceData3 = generateRandomHandle<void *>();
evictMemoryArgs.instanceData0 = generateRandomHandle<void *>();
evictMemoryArgs.instanceData3 = generateRandomHandle<void *>();
driverDdiTable.coreDdiTable.Context.pfnEvictMemory =
[](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);
EXPECT_EQ(hContext, evictMemoryArgs.hContext1);
EXPECT_EQ(hDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(ptr, evictMemoryArgs.ptr1);
EXPECT_EQ(size, evictMemoryArgs.size1);
return ZE_RESULT_SUCCESS;
};
@@ -336,22 +336,22 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
//
prologCbs0.Context.pfnEvictMemoryCb =
[](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);
EXPECT_EQ(evictMemoryArgs.hContext0, *params->phContext);
EXPECT_EQ(evictMemoryArgs.hDevice0, *params->phDevice);
EXPECT_EQ(evictMemoryArgs.ptr0, *params->pptr);
EXPECT_EQ(evictMemoryArgs.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 = evictMemoryArgs.hContext1;
*params->phDevice = evictMemoryArgs.hDevice1;
*params->pptr = evictMemoryArgs.ptr1;
*params->psize = evictMemoryArgs.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;
instanceData->instanceDataValue = evictMemoryArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -363,16 +363,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
[](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);
EXPECT_EQ(*params->phContext, evictMemoryArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(*params->pptr, evictMemoryArgs.ptr1);
EXPECT_EQ(*params->psize, evictMemoryArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, evictMemoryArgs.instanceData0);
delete instanceData;
};
@@ -382,10 +382,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
//
prologCbs1.Context.pfnEvictMemoryCb =
[](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);
EXPECT_EQ(*params->phContext, evictMemoryArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(*params->pptr, evictMemoryArgs.ptr1);
EXPECT_EQ(*params->psize, evictMemoryArgs.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -399,10 +399,10 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
epilogCbs2.Context.pfnEvictMemoryCb =
[](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);
EXPECT_EQ(*params->phContext, evictMemoryArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(*params->pptr, evictMemoryArgs.ptr1);
EXPECT_EQ(*params->psize, evictMemoryArgs.size1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -415,16 +415,16 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
//
prologCbs3.Context.pfnEvictMemoryCb =
[](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);
EXPECT_EQ(*params->phContext, evictMemoryArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(*params->pptr, evictMemoryArgs.ptr1);
EXPECT_EQ(*params->psize, evictMemoryArgs.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;
instanceData->instanceDataValue = evictMemoryArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -432,22 +432,22 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
[](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);
EXPECT_EQ(*params->phContext, evictMemoryArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictMemoryArgs.hDevice1);
EXPECT_EQ(*params->pptr, evictMemoryArgs.ptr1);
EXPECT_EQ(*params->psize, evictMemoryArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, evictMemoryArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeContextEvictMemoryTracing(EvictMemory_args.hContext0, EvictMemory_args.hDevice0, EvictMemory_args.ptr0, EvictMemory_args.size0);
result = zeContextEvictMemoryTracing(evictMemoryArgs.hContext0, evictMemoryArgs.hDevice0, evictMemoryArgs.ptr0, evictMemoryArgs.size0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -461,32 +461,32 @@ struct {
ze_image_handle_t hImage1;
void *instanceData0;
void *instanceData3;
} MakeImageResident_args;
} makeImageResidentArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
WhenCallingContextMakeImageResidentTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
MakeImageResident_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
MakeImageResident_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
MakeImageResident_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
makeImageResidentArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
makeImageResidentArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
makeImageResidentArgs.hImage0 = generateRandomHandle<ze_image_handle_t>();
// initialize replacement argument set
MakeImageResident_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
MakeImageResident_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
MakeImageResident_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
makeImageResidentArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
makeImageResidentArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
makeImageResidentArgs.hImage1 = generateRandomHandle<ze_image_handle_t>();
// initialize user instance data
MakeImageResident_args.instanceData0 = generateRandomHandle<void *>();
MakeImageResident_args.instanceData3 = generateRandomHandle<void *>();
makeImageResidentArgs.instanceData0 = generateRandomHandle<void *>();
makeImageResidentArgs.instanceData3 = generateRandomHandle<void *>();
// 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) -> ze_result_t {
EXPECT_EQ(hContext, MakeImageResident_args.hContext1);
EXPECT_EQ(hDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(hImage, MakeImageResident_args.hImage1);
EXPECT_EQ(hContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(hDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(hImage, makeImageResidentArgs.hImage1);
return ZE_RESULT_SUCCESS;
};
@@ -496,18 +496,18 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs0.Context.pfnMakeImageResidentCb =
[](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;
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext0);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice0);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.hImage0);
*params->phContext = makeImageResidentArgs.hContext1;
*params->phDevice = makeImageResidentArgs.hDevice1;
*params->phImage = makeImageResidentArgs.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;
instanceData->instanceDataValue = makeImageResidentArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -519,15 +519,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, makeImageResidentArgs.instanceData0);
delete instanceData;
};
@@ -537,9 +537,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs1.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -553,9 +553,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
epilogCbs2.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -568,15 +568,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs3.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.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;
instanceData->instanceDataValue = makeImageResidentArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -588,21 +588,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phDevice, makeImageResidentArgs.hDevice1);
EXPECT_EQ(*params->phContext, makeImageResidentArgs.hContext1);
EXPECT_EQ(*params->phImage, makeImageResidentArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, makeImageResidentArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeContextMakeImageResidentTracing(MakeImageResident_args.hContext0, MakeImageResident_args.hDevice0, MakeImageResident_args.hImage0);
result = zeContextMakeImageResidentTracing(makeImageResidentArgs.hContext0, makeImageResidentArgs.hDevice0, makeImageResidentArgs.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}
@@ -616,32 +616,32 @@ struct {
ze_image_handle_t hImage1;
void *instanceData0;
void *instanceData3;
} EvictImage_args;
} evictImageArgs;
TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
WhenCallingContextMakeImageResidentTracingWrapperWithMultiplefPrologEpilogsThenReturnSuccess) {
ze_result_t result = ZE_RESULT_SUCCESS;
// initialize initial argument set
EvictImage_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
EvictImage_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
EvictImage_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
evictImageArgs.hContext0 = generateRandomHandle<ze_context_handle_t>();
evictImageArgs.hDevice0 = generateRandomHandle<ze_device_handle_t>();
evictImageArgs.hImage0 = generateRandomHandle<ze_image_handle_t>();
// initialize replacement argument set
EvictImage_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
EvictImage_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
EvictImage_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
evictImageArgs.hContext1 = generateRandomHandle<ze_context_handle_t>();
evictImageArgs.hDevice1 = generateRandomHandle<ze_device_handle_t>();
evictImageArgs.hImage1 = generateRandomHandle<ze_image_handle_t>();
// initialize user instance data
EvictImage_args.instanceData0 = generateRandomHandle<void *>();
EvictImage_args.instanceData3 = generateRandomHandle<void *>();
evictImageArgs.instanceData0 = generateRandomHandle<void *>();
evictImageArgs.instanceData3 = generateRandomHandle<void *>();
// 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) -> ze_result_t {
EXPECT_EQ(hContext, EvictImage_args.hContext1);
EXPECT_EQ(hDevice, EvictImage_args.hDevice1);
EXPECT_EQ(hImage, EvictImage_args.hImage1);
EXPECT_EQ(hContext, evictImageArgs.hContext1);
EXPECT_EQ(hDevice, evictImageArgs.hDevice1);
EXPECT_EQ(hImage, evictImageArgs.hImage1);
return ZE_RESULT_SUCCESS;
};
@@ -651,18 +651,18 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs0.Context.pfnMakeImageResidentCb =
[](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;
EXPECT_EQ(*params->phContext, evictImageArgs.hContext0);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice0);
EXPECT_EQ(*params->phImage, evictImageArgs.hImage0);
*params->phContext = evictImageArgs.hContext1;
*params->phDevice = evictImageArgs.hDevice1;
*params->phImage = evictImageArgs.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;
instanceData->instanceDataValue = evictImageArgs.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -674,15 +674,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phContext, evictImageArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice1);
EXPECT_EQ(*params->phImage, evictImageArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, evictImageArgs.instanceData0);
delete instanceData;
};
@@ -692,9 +692,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs1.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, evictImageArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice1);
EXPECT_EQ(*params->phImage, evictImageArgs.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 11);
@@ -708,9 +708,9 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
epilogCbs2.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, evictImageArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice1);
EXPECT_EQ(*params->phImage, evictImageArgs.hImage1);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 21);
@@ -723,15 +723,15 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
prologCbs3.Context.pfnMakeImageResidentCb =
[](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);
EXPECT_EQ(*params->phContext, evictImageArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice1);
EXPECT_EQ(*params->phImage, evictImageArgs.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;
instanceData->instanceDataValue = evictImageArgs.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -743,21 +743,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
[](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);
EXPECT_EQ(*params->phContext, evictImageArgs.hContext1);
EXPECT_EQ(*params->phDevice, evictImageArgs.hDevice1);
EXPECT_EQ(*params->phImage, evictImageArgs.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);
EXPECT_EQ(instanceData->instanceDataValue, evictImageArgs.instanceData3);
delete instanceData;
};
setTracerCallbacksAndEnableTracer();
result = zeContextMakeImageResidentTracing(EvictImage_args.hContext0, EvictImage_args.hDevice0, EvictImage_args.hImage0);
result = zeContextMakeImageResidentTracing(evictImageArgs.hContext0, evictImageArgs.hDevice0, evictImageArgs.hImage0);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
validateDefaultUserDataFinal();
}