Tracing wrapper ULTs added to master branch

Change-Id: Ib502bcf4c21408b75703e87b7377f09b4dae3677
Signed-off-by: davidoli <david.olien@intel.com>

cmake/run_ult_target.cmake

@@ -49,6 +49,8 @@ if(NOT SKIP_L0_UNIT_TESTS AND BUILD_WITH_L0)
                      COMMAND $<TARGET_FILE:ze_intel_gpu_core_tests> --product ${product} --slices ${slices} --subslices ${subslices} --eu_per_ss ${eu_per_ss} ${GTEST_EXCEPTION_OPTIONS} --gtest_repeat=${GTEST_REPEAT} ${GTEST_SHUFFLE} ${IGDRCL_TESTS_LISTENER_OPTION} ${GTEST_FILTER_OPTION}
                      COMMAND echo Running ze_intel_gpu_tools_tests ${target} ${slices}x${subslices}x${eu_per_ss} in ${TargetDir}/${product}
                      COMMAND $<TARGET_FILE:ze_intel_gpu_tools_tests> --product ${product} --slices ${slices} --subslices ${subslices} --eu_per_ss ${eu_per_ss} ${GTEST_EXCEPTION_OPTIONS} --gtest_repeat=${GTEST_REPEAT} ${GTEST_SHUFFLE} ${IGDRCL_TESTS_LISTENER_OPTION} ${GTEST_FILTER_OPTION}
+                     COMMAND echo Running ze_intel_gpu_exp_tests ${target} ${slices}x${subslices}x${eu_per_ss} in ${TargetDir}/${product}
+                     COMMAND $<TARGET_FILE:ze_intel_gpu_exp_tests> --product ${product} --slices ${slices} --subslices ${subslices} --eu_per_ss ${eu_per_ss} ${GTEST_EXCEPTION_OPTIONS} --gtest_repeat=${GTEST_REPEAT} ${GTEST_SHUFFLE} ${IGDRCL_TESTS_LISTENER_OPTION} ${GTEST_FILTER_OPTION}
   )
 endif()
 

level_zero/CMakeLists.txt

@@ -474,9 +474,11 @@ if(BUILD_WITH_L0)
   if(NOT SKIP_L0_UNIT_TESTS)
     add_subdirectory_unique(core/test)
     add_subdirectory_unique(tools/test)
+    add_subdirectory_unique(experimental/test)
   else()
     hide_subdir(core/test)
     hide_subdir(tools/test)
+    hide_subdir(experimental/test)
   endif()
   add_subdirectories()
 

level_zero/experimental/source/tracing/tracing_imp.cpp

@@ -13,8 +13,8 @@ namespace L0 {
 
 thread_local ze_bool_t tracingInProgress = 0;
 
-struct APITracerContextImp GLOBAL_APITracerContextImp;
-struct APITracerContextImp *PGLOBAL_APITracerContextImp = &GLOBAL_APITracerContextImp;
+struct APITracerContextImp globalAPITracerContextImp;
+struct APITracerContextImp *pGlobalAPITracerContextImp = &globalAPITracerContextImp;
 
 APITracer *APITracer::create() {
     APITracerImp *tracer = new APITracerImp;
@@ -26,7 +26,7 @@ APITracer *APITracer::create() {
 
 ze_result_t createAPITracer(zet_context_handle_t hContext, const zet_tracer_exp_desc_t *desc, zet_tracer_exp_handle_t *phTracer) {
 
-    if (!PGLOBAL_APITracerContextImp->isTracingEnabled()) {
+    if (!pGlobalAPITracerContextImp->isTracingEnabled()) {
         return ZE_RESULT_ERROR_UNINITIALIZED;
     }
 
@@ -42,7 +42,7 @@ ze_result_t APITracerImp::destroyTracer(zet_tracer_exp_handle_t phTracer) {
 
     APITracerImp *tracer = static_cast<APITracerImp *>(phTracer);
 
-    ze_result_t result = PGLOBAL_APITracerContextImp->finalizeDisableImpTracingWait(tracer);
+    ze_result_t result = pGlobalAPITracerContextImp->finalizeDisableImpTracingWait(tracer);
     if (result == ZE_RESULT_SUCCESS) {
         delete L0::APITracer::fromHandle(phTracer);
     }
@@ -72,7 +72,7 @@ ze_result_t APITracerImp::setEpilogues(zet_core_callbacks_t *pCoreCbs) {
 }
 
 ze_result_t APITracerImp::enableTracer(ze_bool_t enable) {
-    return PGLOBAL_APITracerContextImp->enableTracingImp(this, enable);
+    return pGlobalAPITracerContextImp->enableTracingImp(this, enable);
 }
 
 static std::mutex perThreadTracerDataMutex;
@@ -321,7 +321,7 @@ void *APITracerContextImp::getActiveTracersList() {
         // of tracer structure information from the threader enable/disable/destroy
         // thread to this tracing thread.  So it must use memory_order_acquire
         //
-        stableTracerArray = PGLOBAL_APITracerContextImp->activeTracerArray.load(std::memory_order_acquire);
+        stableTracerArray = pGlobalAPITracerContextImp->activeTracerArray.load(std::memory_order_acquire);
         myThreadPrivateTracerData.myThreadPublicTracerData->tracerArrayPointer.store(stableTracerArray, std::memory_order_relaxed);
         //
         // This read of active_tracer_array does NOT transfer any information
@@ -329,7 +329,7 @@ void *APITracerContextImp::getActiveTracersList() {
         // So it can use memory_order_relaxed.
         //
     } while (stableTracerArray !=
-             PGLOBAL_APITracerContextImp->activeTracerArray.load(std::memory_order_relaxed));
+             pGlobalAPITracerContextImp->activeTracerArray.load(std::memory_order_relaxed));
     return (void *)stableTracerArray;
 }
 

level_zero/experimental/source/tracing/tracing_imp.h

@@ -39,7 +39,7 @@ extern ze_gpu_driver_dditable_t driver_ddiTable;
 namespace L0 {
 
 extern thread_local ze_bool_t tracingInProgress;
-extern struct APITracerContextImp *PGLOBAL_APITracerContextImp;
+extern struct APITracerContextImp *pGlobalAPITracerContextImp;
 
 typedef struct tracer_array_entry {
     zet_core_callbacks_t corePrologues;
@@ -160,7 +160,7 @@ class APITracerCallbackDataImp {
 
 #define ZE_GEN_PER_API_CALLBACK_STATE(perApiCallbackData, tracerType, callbackCategory, callbackFunctionType)                               \
     L0::tracer_array_t *currentTracerArray;                                                                                                 \
-    currentTracerArray = (L0::tracer_array_t *)L0::PGLOBAL_APITracerContextImp->getActiveTracersList();                                     \
+    currentTracerArray = (L0::tracer_array_t *)L0::pGlobalAPITracerContextImp->getActiveTracersList();                                      \
     if (currentTracerArray) {                                                                                                               \
         for (size_t i = 0; i < currentTracerArray->tracerArrayCount; i++) {                                                                 \
             tracerType prologueCallbackPtr;                                                                                                 \
@@ -204,7 +204,7 @@ ze_result_t APITracerWrapperImp(TFunction_pointer zeApiPtr,
             callbacksEpilogs->at(i).current_api_callback(paramsStruct, ret, callbacksEpilogs->at(i).pUserData, &ppTracerInstanceUserData[i]);
     }
     L0::tracingInProgress = 0;
-    L0::PGLOBAL_APITracerContextImp->releaseActivetracersList();
+    L0::pGlobalAPITracerContextImp->releaseActivetracersList();
     return ret;
 }
 

level_zero/experimental/test/CMakeLists.txt

@@ -0,0 +1,7 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+add_subdirectories()

level_zero/experimental/test/unit_tests/CMakeLists.txt

@@ -0,0 +1,143 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+link_libraries(${ASAN_LIBS} ${TSAN_LIBS})
+
+set(TARGET_NAME ${TARGET_NAME_L0}_exp_tests)
+
+append_sources_from_properties(L0_CORE_ENABLERS NEO_CORE_SRCS_LINK)
+
+function(ADD_SUPPORTED_TEST_PRODUCT_FAMILIES_DEFINITION)
+  set(L0_TESTED_PRODUCT_FAMILIES ${ALL_TESTED_PRODUCT_FAMILY})
+  string(REPLACE ";" "," L0_TESTED_PRODUCT_FAMILIES
+         "${L0_TESTED_PRODUCT_FAMILIES}"
+  )
+  add_definitions(
+                  -DSUPPORTED_TEST_PRODUCT_FAMILIES=${L0_TESTED_PRODUCT_FAMILIES}
+  )
+endfunction()
+
+add_supported_test_product_families_definition()
+
+add_executable(
+               ${TARGET_NAME}
+               ${NEO_SOURCE_DIR}/level_zero/core/source/dll/disallow_deferred_deleter.cpp
+               ${NEO_SOURCE_DIR}/shared/test/unit_test/helpers/memory_management.h
+               ${NEO_SOURCE_DIR}/shared/test/unit_test/helpers/memory_management.cpp
+               ${NEO_SOURCE_DIR}/shared/test/unit_test/helpers/memory_leak_listener.h
+               ${NEO_SOURCE_DIR}/shared/test/unit_test/helpers/memory_leak_listener.cpp
+               ${L0_CORE_ENABLERS}
+)
+
+target_sources(
+               ${TARGET_NAME}
+               PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/main.cpp
+               ${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/mock.h
+               ${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/test_mode.h
+               ${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/ult_configuration.cpp
+               ${NEO_SOURCE_DIR}/level_zero/core/test/unit_tests/white_box.h
+               ${NEO_SHARED_TEST_DIRECTORY}/unit_test/tests_configuration.h
+)
+
+target_sources(
+               ${TARGET_NAME}
+               PRIVATE
+               ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/libult/create_command_stream.cpp
+               ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/libult/io_functions.cpp
+               $<TARGET_OBJECTS:${L0_MOCKABLE_LIB_NAME}>
+)
+
+if(UNIX)
+  target_sources(
+                 ${TARGET_NAME}
+                 PRIVATE
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/create_drm_memory_manager.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/drm_neo_create.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/options.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/linux/sys_calls_linux_ult.cpp
+  )
+else()
+  target_sources(
+                 ${TARGET_NAME}
+                 PRIVATE
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/create_wddm_memory_manager.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/options.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/sys_calls.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/ult_dxgi_factory.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/wddm_calls.cpp
+                 ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/os_interface/windows/wddm_create.cpp
+  )
+endif()
+
+set_target_properties(${TARGET_NAME} PROPERTIES FOLDER ${TARGET_NAME_L0})
+
+add_subdirectoriesl0(${CMAKE_CURRENT_SOURCE_DIR} "*")
+
+target_compile_definitions(
+                           ${TARGET_NAME}
+                           PRIVATE
+                           $<TARGET_PROPERTY:${L0_MOCKABLE_LIB_NAME},INTERFACE_COMPILE_DEFINITIONS>
+)
+
+target_include_directories(
+                           ${TARGET_NAME} BEFORE
+                           PRIVATE
+                           $<TARGET_PROPERTY:${TARGET_NAME_L0},SOURCE_DIR>/experimental
+                           ${NEO_SHARED_TEST_DIRECTORY}/unit_test/test_macros/header${BRANCH_DIR_SUFFIX}
+)
+
+if(UNIX)
+  target_include_directories(
+                             ${TARGET_NAME} BEFORE
+                             PRIVATE ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/linux
+  )
+else()
+  target_include_directories(
+                             ${TARGET_NAME} BEFORE
+                             PRIVATE ${COMPUTE_RUNTIME_DIR}/opencl/test/unit_test/windows
+  )
+endif()
+
+if(UNIX)
+  target_link_libraries(${TARGET_NAME} pthread rt)
+else()
+  target_link_libraries(${TARGET_NAME} dbghelp)
+endif()
+
+target_link_libraries(
+                      ${TARGET_NAME} ${NEO_STATICALLY_LINKED_LIBRARIES_MOCKABLE}
+                      compute_runtime_mockable_extra ${HW_LIBS_ULT} gmock-gtest
+)
+
+target_sources(${TARGET_NAME} PRIVATE $<TARGET_OBJECTS:mock_gmm>
+               $<TARGET_OBJECTS:${TARGET_NAME_L0}_mocks>
+)
+
+option(L0_ULT_VERBOSE "Use the default/verbose test output" OFF)
+if(NOT L0_ULT_VERBOSE)
+  set(L0_TESTS_LISTENER_OPTION "--disable_default_listener")
+else()
+  set(L0_TESTS_LISTENER_OPTION "--enable_default_listener")
+endif()
+
+if(MSVC)
+  set_target_properties(
+                        ${TARGET_NAME}
+                        PROPERTIES
+                        VS_DEBUGGER_COMMAND_ARGUMENTS
+                        "${L0_TESTS_FILTER_OPTION} --gtest_catch_exceptions=0 ${L0_TESTS_LISTENER_OPTION}"
+                        VS_DEBUGGER_WORKING_DIRECTORY "$(OutDir
+  )")
+  set(RUN_ULT_CMD $<TARGET_FILE:${TARGET_NAME}>)
+else()
+  set(RUN_ULT_CMD LD_LIBRARY_PATH=$<TARGET_FILE_DIR:${TARGET_NAME}>
+      $<TARGET_FILE:${TARGET_NAME}>
+  )
+endif()
+
+create_source_tree(${TARGET_NAME} ${L0_ROOT_DIR}/..)

level_zero/experimental/test/unit_tests/sources/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME}
+               PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+
+add_subdirectories()

level_zero/experimental/test/unit_tests/sources/tracing/CMakeLists.txt

@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(
+               ${TARGET_NAME}
+               PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_api_tracing_common.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_core_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_global_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_copy_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_device_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_driver_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_event_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_event_api_multi_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_fence_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_cmdlist_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_cmdqueue_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_barrier_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_image_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_memory_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_sampler_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_residency_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_module_api_tracing.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_module_api_multi_tracing.cpp
+)

level_zero/experimental/test/unit_tests/sources/tracing/test_api_tracing_common.h

@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/source/device/device_imp.h"
+#include "level_zero/core/source/driver/driver_handle_imp.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_cmdlist.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_driver.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_memory_manager.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_module.h"
+#include "level_zero/experimental/source/tracing/tracing.h"
+#include "level_zero/experimental/source/tracing/tracing_imp.h"
+#include <level_zero/zet_api.h>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <array>
+#include <iostream>
+
+using ::testing::_;
+using ::testing::Return;
+
+namespace L0 {
+
+extern struct APITracerContextImp *pGlobalAPITracerContextImp;
+
+namespace ult {
+template <typename TFunctionPointer, typename... Args>
+ze_result_t callHandleTracerRecursion(TFunctionPointer zeApiPtr, Args &&... args) {
+    ZE_HANDLE_TRACER_RECURSION(zeApiPtr, args...);
+    return ZE_RESULT_ERROR_UNKNOWN;
+}
+
+class ZeAPITracingCoreTestsFixture {
+  public:
+    ZeAPITracingCoreTestsFixture(){};
+
+  protected:
+    virtual void SetUp() { //NOLINT
+        driver_ddiTable.enableTracing = true;
+        myThreadPrivateTracerData.allocatePerThreadPublicTracerData();
+    }
+
+    virtual void TearDown() { //NOLINT
+        myThreadPrivateTracerData.freePerThreadPublicTracerData();
+        driver_ddiTable.enableTracing = false;
+    }
+};
+
+class zeAPITracingCoreTests : public ZeAPITracingCoreTestsFixture, public ::testing::Test {
+
+  protected:
+    void SetUp() override { //NOLINT
+        ZeAPITracingCoreTestsFixture::SetUp();
+    }
+
+    void TearDown() override { //NOLINT
+        ZeAPITracingCoreTestsFixture::TearDown();
+    }
+};
+
+class zeAPITracingRuntimeTests : public ZeAPITracingCoreTestsFixture, public ::testing::Test {
+
+  protected:
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+    zet_tracer_exp_handle_t apiTracerHandle;
+    zet_tracer_exp_desc_t tracerDesc;
+    int defaultUserData = 0;
+    void *userData;
+
+    void SetUp() override { //NOLINT
+        ze_result_t result;
+
+        ZeAPITracingCoreTestsFixture::SetUp();
+        userData = &defaultUserData;
+        tracerDesc.pUserData = userData;
+        result = zetTracerExpCreate(nullptr, &tracerDesc, &apiTracerHandle);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_NE(nullptr, apiTracerHandle);
+    }
+
+    void TearDown() override { //NOLINT
+        ze_result_t result;
+
+        result = zetTracerExpSetEnabled(apiTracerHandle, false);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpDestroy(apiTracerHandle);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        ZeAPITracingCoreTestsFixture::TearDown();
+    }
+
+    void setTracerCallbacksAndEnableTracer() {
+        ze_result_t result;
+        result = zetTracerExpSetPrologues(apiTracerHandle, &prologCbs);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        result = zetTracerExpSetEpilogues(apiTracerHandle, &epilogCbs);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        result = zetTracerExpSetEnabled(apiTracerHandle, true);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    }
+};
+
+class zeAPITracingRuntimeMultipleArgumentsTests : public ZeAPITracingCoreTestsFixture, public ::testing::Test {
+
+  protected:
+    zet_core_callbacks_t prologCbs0 = {};
+    zet_core_callbacks_t epilogCbs0 = {};
+    zet_core_callbacks_t prologCbs1 = {};
+    zet_core_callbacks_t epilogCbs2 = {};
+    zet_core_callbacks_t prologCbs3 = {};
+    zet_core_callbacks_t epilogCbs3 = {};
+    zet_tracer_exp_handle_t apiTracerHandle0;
+    zet_tracer_exp_handle_t apiTracerHandle1;
+    zet_tracer_exp_handle_t apiTracerHandle2;
+    zet_tracer_exp_handle_t apiTracerHandle3;
+    zet_tracer_exp_desc_t tracerDesc0;
+    zet_tracer_exp_desc_t tracerDesc1;
+    zet_tracer_exp_desc_t tracerDesc2;
+    zet_tracer_exp_desc_t tracerDesc3;
+    int defaultUserData0 = 1;
+    void *pUserData0;
+    int defaultUserData1 = 11;
+    void *pUserData1;
+    int defaultUserdata2 = 21;
+    void *pUserData2;
+    int defaultUserData3 = 31;
+    void *pUserData3;
+
+    void SetUp() override { //NOLINT
+        ze_result_t result;
+
+        ZeAPITracingCoreTestsFixture::SetUp();
+
+        pUserData0 = &defaultUserData0;
+        tracerDesc0.pUserData = pUserData0;
+        result = zetTracerExpCreate(nullptr, &tracerDesc0, &apiTracerHandle0);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_NE(nullptr, apiTracerHandle0);
+
+        pUserData1 = &defaultUserData1;
+        tracerDesc1.pUserData = pUserData1;
+        result = zetTracerExpCreate(nullptr, &tracerDesc1, &apiTracerHandle1);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_NE(nullptr, apiTracerHandle1);
+
+        pUserData2 = &defaultUserdata2;
+        tracerDesc2.pUserData = pUserData2;
+        result = zetTracerExpCreate(nullptr, &tracerDesc2, &apiTracerHandle2);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_NE(nullptr, apiTracerHandle2);
+
+        pUserData3 = &defaultUserData3;
+        tracerDesc3.pUserData = pUserData3;
+        result = zetTracerExpCreate(nullptr, &tracerDesc3, &apiTracerHandle3);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_NE(nullptr, apiTracerHandle3);
+    }
+
+    void TearDown() override { //NOLINT
+        ze_result_t result;
+        result = zetTracerExpSetEnabled(apiTracerHandle0, false);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpDestroy(apiTracerHandle0);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        result = zetTracerExpSetEnabled(apiTracerHandle1, false);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpDestroy(apiTracerHandle1);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        result = zetTracerExpSetEnabled(apiTracerHandle2, false);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpDestroy(apiTracerHandle2);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        result = zetTracerExpSetEnabled(apiTracerHandle3, false);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpDestroy(apiTracerHandle3);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        ZeAPITracingCoreTestsFixture::TearDown();
+    }
+
+    void setTracerCallbacksAndEnableTracer() {
+        ze_result_t result;
+
+        /* Both prolog and epilog, pass instance data from prolog to epilog */
+        result = zetTracerExpSetPrologues(apiTracerHandle0, &prologCbs0);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEpilogues(apiTracerHandle0, &epilogCbs0);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEnabled(apiTracerHandle0, true);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        /* prolog only */
+        result = zetTracerExpSetPrologues(apiTracerHandle1, &prologCbs1);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEnabled(apiTracerHandle1, true);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        /* epilog only */
+        result = zetTracerExpSetEpilogues(apiTracerHandle2, &epilogCbs2);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEnabled(apiTracerHandle2, true);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+        /* Both prolog and epilog, pass instance data from prolog to epilog */
+        result = zetTracerExpSetPrologues(apiTracerHandle3, &prologCbs3);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEpilogues(apiTracerHandle3, &epilogCbs3);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        result = zetTracerExpSetEnabled(apiTracerHandle3, true);
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    }
+
+    void validateDefaultUserDataFinal() {
+        EXPECT_EQ(defaultUserData0, 3);
+        EXPECT_EQ(defaultUserData1, 22);
+        EXPECT_EQ(defaultUserdata2, 42);
+        EXPECT_EQ(defaultUserData3, 93);
+    }
+};
+
+template <typename Tparams>
+void genericPrologCallbackPtr(Tparams params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+    EXPECT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    *val += 1;
+}
+
+template <typename Tparams>
+void genericEpilogCallbackPtr(Tparams params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+    EXPECT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(*val, 1);
+}
+
+template <typename THandleType>
+THandleType generateRandomHandle() {
+    return reinterpret_cast<THandleType>(static_cast<uint64_t>(rand()));
+}
+
+template <typename TSizeType>
+TSizeType generateRandomSize() {
+    return static_cast<TSizeType>(rand());
+}
+
+struct instanceDataStruct {
+    void *instanceDataValue;
+};
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_barrier_api_tracing.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendBarrierTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendBarrier =
+        [](ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    ze_event_handle_t hSignalEvent = nullptr;
+    uint32_t numWaitEvents = 0;
+
+    prologCbs.CommandList.pfnAppendBarrierCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendBarrierCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendBarrier_Tracing(nullptr, hSignalEvent, numWaitEvents, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryRangesBarrierTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier =
+        [](ze_command_list_handle_t hCommandList, uint32_t numRanges, const size_t *pRangeSizes, const void **pRanges,
+           ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    uint32_t numRanges = 1;
+    const size_t pRangeSizes[] = {1};
+    const void **pRanges = new const void *[1];
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryRangesBarrier =
+        [](ze_command_list_handle_t hCommandList, uint32_t numRanges, const size_t *pRangeSizes, const void **pRanges,
+           ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnAppendMemoryRangesBarrierCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryRangesBarrierCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryRangesBarrier_Tracing(nullptr, numRanges, pRangeSizes, pRanges, nullptr, 0, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    delete[] pRanges;
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_cmdlist_api_tracing.cpp

@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnCreate =
+        [](ze_context_handle_t hContext,
+           ze_device_handle_t hDevice,
+           const ze_command_list_desc_t *desc,
+           ze_command_list_handle_t *phCommandList) { return ZE_RESULT_SUCCESS; };
+    ze_command_list_desc_t desc = {};
+    ze_command_list_handle_t commandList = {};
+
+    prologCbs.CommandList.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListCreate_Tracing(nullptr, nullptr, &desc, &commandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCreateImmediateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnCreateImmediate =
+        [](ze_context_handle_t hContext,
+           ze_device_handle_t hDevice,
+           const ze_command_queue_desc_t *desc,
+           ze_command_list_handle_t *phCommandList) { return ZE_RESULT_SUCCESS; };
+    ze_command_queue_desc_t desc = {};
+    ze_command_list_handle_t commandList = {};
+
+    prologCbs.CommandList.pfnCreateImmediateCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnCreateImmediateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListCreateImmediate_Tracing(nullptr, nullptr, &desc, &commandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnDestroy =
+        [](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnReset =
+        [](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnResetCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnResetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListReset_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryPrefetchTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryPrefetch =
+        [](ze_command_list_handle_t hCommandList, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnAppendMemoryPrefetchCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryPrefetchCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryPrefetch_Tracing(nullptr, nullptr, 0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListCloseTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnClose =
+        [](ze_command_list_handle_t hCommandList) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnCloseCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnCloseCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListClose_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendQueryKernelTimestampsTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendQueryKernelTimestamps =
+        [](ze_command_list_handle_t hCommandList,
+           uint32_t numEvents,
+           ze_event_handle_t *phEvents,
+           void *dstptr,
+           const size_t *pOffsets,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandList.pfnAppendQueryKernelTimestampsCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendQueryKernelTimestampsCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendQueryKernelTimestamps_Tracing(nullptr, 1U, nullptr, nullptr, nullptr, nullptr, 1U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendWriteGlobalTimestampTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendWriteGlobalTimestamp =
+        [](ze_command_list_handle_t hCommandList,
+           uint64_t *dstptr,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandList.pfnAppendWriteGlobalTimestampCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendWriteGlobalTimestampCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendWriteGlobalTimestamp_Tracing(nullptr, nullptr, nullptr, 1U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_cmdqueue_api_tracing.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandQueue.pfnCreate =
+        [](ze_context_handle_t hContext,
+           ze_device_handle_t hDevice,
+           const ze_command_queue_desc_t *desc,
+           ze_command_queue_handle_t *phCommandQueue) { return ZE_RESULT_SUCCESS; };
+    ze_command_queue_desc_t desc = {};
+    ze_command_queue_handle_t commandQueue = {};
+
+    prologCbs.CommandQueue.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.CommandQueue.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandQueueCreate_Tracing(nullptr, nullptr, &desc, &commandQueue);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandQueue.pfnDestroy =
+        [](ze_command_queue_handle_t hCommandQueue) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandQueue.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.CommandQueue.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandQueueDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueExecuteCommandListsTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    uint32_t numCommandList = 0;
+    ze_command_list_handle_t phCommandLists = {};
+    ze_fence_handle_t hFence = nullptr;
+
+    driver_ddiTable.core_ddiTable.CommandQueue.pfnExecuteCommandLists =
+        [](ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists, ze_command_list_handle_t *phCommandLists,
+           ze_fence_handle_t hFence) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandQueue.pfnExecuteCommandListsCb = genericPrologCallbackPtr;
+    epilogCbs.CommandQueue.pfnExecuteCommandListsCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandQueueExecuteCommandLists_Tracing(nullptr, numCommandList, &phCommandLists, hFence);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandQueueSynchronizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandQueue.pfnSynchronize =
+        [](ze_command_queue_handle_t hCommandQueue, uint64_t timeout) { return ZE_RESULT_SUCCESS; };
+    uint64_t timeout = 100;
+
+    prologCbs.CommandQueue.pfnSynchronizeCb = genericPrologCallbackPtr;
+    epilogCbs.CommandQueue.pfnSynchronizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandQueueSynchronize_Tracing(nullptr, timeout);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_copy_api_tracing.cpp

@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopy =
+        [](ze_command_list_handle_t hCommandList,
+           void *dstptr,
+           const void *srcptr,
+           size_t size,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitevents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    size_t bufferSize = 4096u;
+    void *dst = malloc(bufferSize);
+    void *src = malloc(bufferSize);
+
+    prologCbs.CommandList.pfnAppendMemoryCopyCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryCopyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryCopy_Tracing(nullptr, dst, static_cast<const void *>(src), bufferSize, nullptr, 0U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(dst);
+    free(src);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryFillTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryFill =
+        [](ze_command_list_handle_t hCommandList,
+           void *ptr,
+           const void *pattern,
+           size_t patternSize,
+           size_t size,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    size_t bufferSize = 4096u;
+    void *dst = malloc(bufferSize);
+    int pattern = 1;
+
+    prologCbs.CommandList.pfnAppendMemoryFillCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryFillCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryFill_Tracing(nullptr, dst, &pattern, sizeof(pattern), bufferSize, nullptr, 0, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(dst);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyRegionTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyRegion =
+        [](ze_command_list_handle_t hCommandList,
+           void *dstptr,
+           const ze_copy_region_t *dstRegion,
+           uint32_t dstPitch,
+           uint32_t dstSlicePitch,
+           const void *srcptr,
+           const ze_copy_region_t *srcRegion,
+           uint32_t srcPitch,
+           uint32_t srcSlicePitch,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    size_t bufferSize = 4096u;
+    void *dst = malloc(bufferSize);
+    ze_copy_region_t dstRegion;
+    uint32_t dstPitch = 1;
+    void *src = malloc(bufferSize);
+    ze_copy_region_t srcRegion;
+    uint32_t srcPitch = 1;
+    uint32_t dstSlicePitch = 0;
+    uint32_t srcSlicePitch = 0;
+
+    prologCbs.CommandList.pfnAppendMemoryCopyRegionCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryCopyRegionCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryCopyRegion_Tracing(nullptr, dst,
+                                                         &dstRegion, dstPitch,
+                                                         dstSlicePitch,
+                                                         static_cast<const void *>(src),
+                                                         &srcRegion, srcPitch,
+                                                         srcSlicePitch,
+                                                         nullptr,
+                                                         0,
+                                                         nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(dst);
+    free(src);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopy =
+        [](ze_command_list_handle_t hCommandList,
+           ze_image_handle_t hDstImage,
+           ze_image_handle_t hSrcImage,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
+    ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
+
+    prologCbs.CommandList.pfnAppendImageCopyCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendImageCopyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendImageCopy_Tracing(nullptr, hDstImage, hSrcImage, nullptr, 0U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(hDstImage);
+    free(hSrcImage);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyRegionTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyRegion =
+        [](ze_command_list_handle_t hCommandList,
+           ze_image_handle_t hDstImage,
+           ze_image_handle_t hSrcImage,
+           const ze_image_region_t *pDstRegion,
+           const ze_image_region_t *pSrcRegion,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
+    ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
+
+    prologCbs.CommandList.pfnAppendImageCopyRegionCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendImageCopyRegionCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendImageCopyRegion_Tracing(nullptr, hDstImage, hSrcImage, nullptr, nullptr, nullptr, 0U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(hDstImage);
+    free(hSrcImage);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyToMemoryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyToMemory =
+        [](ze_command_list_handle_t hCommandList,
+           void *dstptr,
+           ze_image_handle_t hSrcImage,
+           const ze_image_region_t *pSrcRegion,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    ze_image_handle_t hSrcImage = static_cast<ze_image_handle_t>(malloc(1));
+    void *dstptr = malloc(1);
+
+    prologCbs.CommandList.pfnAppendImageCopyToMemoryCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendImageCopyToMemoryCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendImageCopyToMemory_Tracing(nullptr, dstptr, hSrcImage, nullptr, nullptr, 0U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(hSrcImage);
+    free(dstptr);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendImageCopyFromMemoryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendImageCopyFromMemory =
+        [](ze_command_list_handle_t hCommandList,
+           ze_image_handle_t hDstImage,
+           const void *srcptr,
+           const ze_image_region_t *pDstRegion,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    ze_image_handle_t hDstImage = static_cast<ze_image_handle_t>(malloc(1));
+    void *srcptr = malloc(1);
+
+    prologCbs.CommandList.pfnAppendImageCopyFromMemoryCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendImageCopyFromMemoryCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendImageCopyFromMemory_Tracing(nullptr, hDstImage, srcptr, nullptr, nullptr, 0U, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(hDstImage);
+    free(srcptr);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemAdviseTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemAdvise =
+        [](ze_command_list_handle_t hCommandList,
+           ze_device_handle_t hDevice,
+           const void *ptr,
+           size_t size,
+           ze_memory_advice_t advice) { return ZE_RESULT_SUCCESS; };
+    size_t bufferSize = 4096u;
+    void *ptr = malloc(bufferSize);
+
+    ze_memory_advice_t advice = ZE_MEMORY_ADVICE_SET_READ_MOSTLY;
+
+    prologCbs.CommandList.pfnAppendMemAdviseCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemAdviseCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemAdvise_Tracing(nullptr, nullptr, ptr, bufferSize, advice);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+
+    free(ptr);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendMemoryCopyFromContextTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendMemoryCopyFromContext =
+        [](ze_command_list_handle_t hCommandList,
+           void *dstptr,
+           ze_context_handle_t hContextSrc,
+           const void *srcptr,
+           size_t size,
+           ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents,
+           ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandList.pfnAppendMemoryCopyFromContextCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendMemoryCopyFromContextCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendMemoryCopyFromContext_Tracing(nullptr, nullptr, nullptr, nullptr, 0U, nullptr, 1u, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_core_api_tracing.cpp

@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+void OnEnterCommandListAppendLaunchFunction(
+    ze_command_list_append_launch_kernel_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    int a = 0;
+    a++;
+}
+void OnExitCommandListAppendLaunchFunction(
+    ze_command_list_append_launch_kernel_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    int a = 0;
+    a++;
+}
+
+void OnEnterCommandListCreateWithUserData(
+    ze_command_list_create_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *val);
+}
+void OnExitCommandListCreateWithUserData(
+    ze_command_list_create_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *val);
+}
+
+void OnEnterCommandListCloseWithUserData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *val);
+}
+void OnExitCommandListCloseWithUserData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *val);
+}
+
+void OnEnterCommandListCloseWithUserDataRecursion(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *val);
+    *val += 5;
+}
+void OnExitCommandListCloseWithUserDataRecursion(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *val = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(10, *val);
+    *val += 5;
+}
+
+void OnEnterCommandListCloseWithUserDataAndAllocateInstanceData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *userdata = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *userdata);
+    int *instanceData = new int;
+    ppTracerInstanceUserData[0] = instanceData;
+    *instanceData = 0x1234;
+}
+void OnExitCommandListCloseWithUserDataAndReadInstanceData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_NE(nullptr, pTracerUserData);
+    int *userdata = static_cast<int *>(pTracerUserData);
+    EXPECT_EQ(5, *userdata);
+    ASSERT_NE(nullptr, ppTracerInstanceUserData);
+    ASSERT_NE(nullptr, ppTracerInstanceUserData[0]);
+    int *instanceData = static_cast<int *>(ppTracerInstanceUserData[0]);
+    ASSERT_NE(nullptr, instanceData);
+    if (nullptr == instanceData)
+        return;
+    int data = *instanceData;
+    EXPECT_EQ(0x1234, data);
+    delete instanceData;
+}
+
+void OnEnterCommandListCloseWithoutUserDataAndAllocateInstanceData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_EQ(nullptr, pTracerUserData);
+    int *instanceData = new int;
+    ppTracerInstanceUserData[0] = instanceData;
+    *instanceData = 0x1234;
+}
+void OnExitCommandListCloseWithoutUserDataAndReadInstanceData(
+    ze_command_list_close_params_t *params,
+    ze_result_t result,
+    void *pTracerUserData,
+    void **ppTracerInstanceUserData) {
+    ASSERT_EQ(nullptr, pTracerUserData);
+    ASSERT_NE(nullptr, ppTracerInstanceUserData);
+    ASSERT_NE(nullptr, ppTracerInstanceUserData[0]);
+    int *instanceData = static_cast<int *>(ppTracerInstanceUserData[0]);
+    ASSERT_NE(nullptr, instanceData);
+    if (nullptr == instanceData)
+        return;
+    int data = *instanceData;
+    EXPECT_EQ(0x1234, data);
+    delete instanceData;
+}
+
+TEST(zeAPITracingCoreTestsNoSetup, WhenCreateTracerAndNoZetInitThenReturnFailure) {
+    ze_result_t result;
+
+    zet_tracer_exp_handle_t APITracerHandle;
+    zet_tracer_exp_desc_t tracer_desc;
+
+    result = zetTracerExpCreate(nullptr, &tracer_desc, &APITracerHandle);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCreateTracerAndsetCallbacksAndEnableTracingAndDisableTracingAndDestroyTracerThenReturnSuccess) {
+    ze_result_t result;
+
+    zet_tracer_exp_handle_t APITracerHandle;
+    zet_tracer_exp_desc_t tracer_desc;
+
+    result = zetTracerExpCreate(nullptr, &tracer_desc, &APITracerHandle);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    ASSERT_NE(nullptr, APITracerHandle);
+
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+
+    prologCbs.CommandList.pfnAppendLaunchKernelCb = OnEnterCommandListAppendLaunchFunction;
+    epilogCbs.CommandList.pfnAppendLaunchKernelCb = OnExitCommandListAppendLaunchFunction;
+
+    result = zetTracerExpSetPrologues(APITracerHandle, &prologCbs);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = zetTracerExpSetEpilogues(APITracerHandle, &epilogCbs);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = zetTracerExpSetEnabled(APITracerHandle, true);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = zetTracerExpSetEnabled(APITracerHandle, false);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = zetTracerExpDestroy(APITracerHandle);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOnePrologAndNoEpilogWithUserDataAndUserDataMatchingInPrologThenReturnSuccess) {
+    MockCommandList commandList;
+    ze_result_t result;
+    int user_data = 5;
+    ze_command_list_close_params_t tracerParams;
+    zet_core_callbacks_t prologCbs = {};
+
+    prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserData;
+
+    ze_command_list_handle_t command_list_handle = commandList.toHandle();
+    tracerParams.phCommandList = &command_list_handle;
+
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> prologCallbacks;
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> epilogCallbacks;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> prologCallback;
+    prologCallback.current_api_callback = prologCbs.CommandList.pfnCloseCb;
+    prologCallback.pUserData = &user_data;
+    prologCallbacks.push_back(prologCallback);
+    ze_pfnCommandListCloseCb_t apiOrdinal = {};
+
+    result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsWithUserDataAndUserDataMatchingInPrologAndEpilogThenReturnSuccess) {
+    MockCommandList commandList;
+    ze_result_t result;
+    int user_data = 5;
+    ze_command_list_close_params_t tracerParams;
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+
+    prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserData;
+    epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserData;
+
+    ze_command_list_handle_t command_list_handle = commandList.toHandle();
+    tracerParams.phCommandList = &command_list_handle;
+
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> prologCallbacks;
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> epilogCallbacks;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> prologCallback;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> epilogCallback;
+    prologCallback.current_api_callback = prologCbs.CommandList.pfnCloseCb;
+    epilogCallback.current_api_callback = epilogCbs.CommandList.pfnCloseCb;
+    prologCallback.pUserData = &user_data;
+    epilogCallback.pUserData = &user_data;
+    prologCallbacks.push_back(prologCallback);
+    epilogCallbacks.push_back(epilogCallback);
+    ze_pfnCommandListCloseCb_t apiOrdinal = {};
+
+    result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsWithUserDataAndInstanceDataUserDataMatchingInPrologAndEpilogThenReturnSuccess) {
+    MockCommandList commandList;
+    ze_result_t result;
+    int user_data = 5;
+    ze_command_list_close_params_t tracerParams;
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+
+    prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserDataAndAllocateInstanceData;
+    epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserDataAndReadInstanceData;
+
+    ze_command_list_handle_t command_list_handle = commandList.toHandle();
+    tracerParams.phCommandList = &command_list_handle;
+
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> prologCallbacks;
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> epilogCallbacks;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> prologCallback;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> epilogCallback;
+    prologCallback.current_api_callback = prologCbs.CommandList.pfnCloseCb;
+    epilogCallback.current_api_callback = epilogCbs.CommandList.pfnCloseCb;
+    prologCallback.pUserData = &user_data;
+    epilogCallback.pUserData = &user_data;
+    prologCallbacks.push_back(prologCallback);
+    epilogCallbacks.push_back(epilogCallback);
+    ze_pfnCommandListCloseCb_t apiOrdinal = {};
+
+    result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsWithInstanceDataThenReturnSuccess) {
+    MockCommandList commandList;
+    ze_result_t result;
+    ze_command_list_close_params_t tracerParams;
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+
+    prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithoutUserDataAndAllocateInstanceData;
+    epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithoutUserDataAndReadInstanceData;
+
+    ze_command_list_handle_t command_list_handle = commandList.toHandle();
+    tracerParams.phCommandList = &command_list_handle;
+
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> prologCallbacks;
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> epilogCallbacks;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> prologCallback;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> epilogCallback;
+    prologCallback.current_api_callback = prologCbs.CommandList.pfnCloseCb;
+    epilogCallback.current_api_callback = epilogCbs.CommandList.pfnCloseCb;
+    prologCallback.pUserData = nullptr;
+    epilogCallback.pUserData = nullptr;
+    prologCallbacks.push_back(prologCallback);
+    epilogCallbacks.push_back(epilogCallback);
+    ze_pfnCommandListCloseCb_t apiOrdinal = {};
+
+    result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingCoreTests, WhenCallingTracerWrapperWithOneSetOfPrologEpilogsWithRecursionHandledAndSuccessIsReturned) {
+    MockCommandList commandList;
+    ze_result_t result;
+    int user_data = 5;
+    ze_command_list_close_params_t tracerParams;
+    zet_core_callbacks_t prologCbs = {};
+    zet_core_callbacks_t epilogCbs = {};
+
+    prologCbs.CommandList.pfnCloseCb = OnEnterCommandListCloseWithUserDataRecursion;
+    epilogCbs.CommandList.pfnCloseCb = OnExitCommandListCloseWithUserDataRecursion;
+
+    ze_command_list_handle_t command_list_handle = commandList.toHandle();
+    tracerParams.phCommandList = &command_list_handle;
+
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> prologCallbacks;
+    std::vector<APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t>> epilogCallbacks;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> prologCallback;
+    APITracerCallbackStateImp<ze_pfnCommandListCloseCb_t> epilogCallback;
+    prologCallback.current_api_callback = prologCbs.CommandList.pfnCloseCb;
+    epilogCallback.current_api_callback = epilogCbs.CommandList.pfnCloseCb;
+    prologCallback.pUserData = &user_data;
+    epilogCallback.pUserData = &user_data;
+    prologCallbacks.push_back(prologCallback);
+    epilogCallbacks.push_back(epilogCallback);
+    ze_pfnCommandListCloseCb_t apiOrdinal = {};
+
+    result = callHandleTracerRecursion(zeCommandListClose, command_list_handle);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
+
+    result = APITracerWrapperImp(zeCommandListClose, &tracerParams, apiOrdinal, prologCallbacks, epilogCallbacks, *tracerParams.phCommandList);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    result = callHandleTracerRecursion(zeCommandListClose, command_list_handle);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
+
+    result = callHandleTracerRecursion(zeCommandListClose, command_list_handle);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    L0::tracingInProgress = 0;
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_device_api_tracing.cpp

@@ -0,0 +1,259 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGet =
+        [](ze_driver_handle_t hDriver, uint32_t *pCount, ze_device_handle_t *phDevices) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGet_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetProperties =
+        [](ze_device_handle_t hDevice, ze_device_properties_t *pDeviceProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetComputePropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetComputeProperties =
+        [](ze_device_handle_t hDevice, ze_device_compute_properties_t *pComputeProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetComputePropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetComputePropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetComputeProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetMemoryPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetMemoryProperties =
+        [](ze_device_handle_t hDevice, uint32_t *pCount, ze_device_memory_properties_t *pMemProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetMemoryPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetMemoryPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetMemoryProperties_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetCachePropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetCacheProperties =
+        [](ze_device_handle_t hDevice,
+           uint32_t *pCount,
+           ze_device_cache_properties_t *pCacheProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetCachePropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetCachePropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetCacheProperties_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetImagePropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetImageProperties =
+        [](ze_device_handle_t hDevice,
+           ze_device_image_properties_t *pImageProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetImagePropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetImagePropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetImageProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetSubDevicesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetSubDevices =
+        [](ze_device_handle_t hDevice,
+           uint32_t *pCount,
+           ze_device_handle_t *phSubdevices) { return ZE_RESULT_SUCCESS; };
+
+    uint32_t pcount = 1;
+
+    prologCbs.Device.pfnGetSubDevicesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetSubDevicesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetSubDevices_Tracing(nullptr, &pcount, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetP2PPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetP2PProperties =
+        [](ze_device_handle_t hDevice,
+           ze_device_handle_t hPeerDevice,
+           ze_device_p2p_properties_t *pP2PProperties) { return ZE_RESULT_SUCCESS; };
+
+    ze_device_p2p_properties_t pP2PProperties;
+
+    prologCbs.Device.pfnGetP2PPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetP2PPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetP2PProperties_Tracing(nullptr, nullptr, &pP2PProperties);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceCanAccessPeerTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnCanAccessPeer =
+        [](ze_device_handle_t hDevice,
+           ze_device_handle_t hPeerDevice,
+           ze_bool_t *value) { return ZE_RESULT_SUCCESS; };
+
+    ze_bool_t value;
+
+    prologCbs.Device.pfnCanAccessPeerCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnCanAccessPeerCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceCanAccessPeer_Tracing(nullptr, nullptr, &value);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetCacheConfigTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSetCacheConfig =
+        [](ze_kernel_handle_t hKernel,
+           ze_cache_config_flags_t flags) { return ZE_RESULT_SUCCESS; };
+
+    ze_cache_config_flags_t flags = {};
+
+    prologCbs.Kernel.pfnSetCacheConfigCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSetCacheConfigCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSetCacheConfig_Tracing(nullptr, flags);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetModulePropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetModuleProperties =
+        [](ze_device_handle_t hDevice,
+           ze_device_module_properties_t *pModuleProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetModulePropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetModulePropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetModuleProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetMemoryAccessPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetMemoryAccessProperties =
+        [](ze_device_handle_t hDevice,
+           ze_device_memory_access_properties_t *pMemAccessProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetMemoryAccessPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetMemoryAccessPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetMemoryAccessProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetCommandQueueGroupPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetCommandQueueGroupProperties =
+        [](ze_device_handle_t hDevice, uint32_t *pCount, ze_command_queue_group_properties_t *pCommandQueueGroupProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetCommandQueueGroupPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetCommandQueueGroupPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetCommandQueueGroupProperties_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetExternalMemoryPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetExternalMemoryProperties =
+        [](ze_device_handle_t hDevice, ze_device_external_memory_properties_t *pExternalMemoryProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetExternalMemoryPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetExternalMemoryPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetExternalMemoryProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingDeviceGetStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Device.pfnGetStatus =
+        [](ze_device_handle_t hDevice) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetStatusCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetStatusCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDeviceGetStatus_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_driver_api_tracing.cpp

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Driver.pfnGet =
+        [](uint32_t *pCount, ze_driver_handle_t *phDrivers) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Driver.pfnGetCb = genericPrologCallbackPtr;
+    epilogCbs.Driver.pfnGetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDriverGet_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Driver.pfnGetProperties =
+        [](ze_driver_handle_t hDriver, ze_driver_properties_t *properties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Device.pfnGetSubDevicesCb = genericPrologCallbackPtr;
+    epilogCbs.Device.pfnGetSubDevicesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDriverGetProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetApiVersionTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Driver.pfnGetApiVersion =
+        [](ze_driver_handle_t hDrivers, ze_api_version_t *version) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Driver.pfnGetApiVersionCb = genericPrologCallbackPtr;
+    epilogCbs.Driver.pfnGetApiVersionCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDriverGetApiVersion_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetIpcPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Driver.pfnGetIpcProperties =
+        [](ze_driver_handle_t hDrivers,
+           ze_driver_ipc_properties_t *pIpcProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Driver.pfnGetIpcPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Driver.pfnGetIpcPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDriverGetIpcProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingzeDriverGetExtensionPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Driver.pfnGetExtensionProperties =
+        [](ze_driver_handle_t hDrivers,
+           uint32_t *pCount,
+           ze_driver_extension_properties_t *pExtensionProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Driver.pfnGetExtensionPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Driver.pfnGetExtensionPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeDriverGetExtensionProperties_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_event_api_tracing.cpp

@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnCreate =
+        [](ze_event_pool_handle_t hEventPool, const ze_event_desc_t *desc, ze_event_handle_t *phEvent) { return ZE_RESULT_SUCCESS; };
+    ze_event_handle_t event = {};
+    ze_event_desc_t desc = {};
+
+    prologCbs.Event.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventCreate_Tracing(nullptr, &desc, &event);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnDestroy =
+        [](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Event.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostSignalTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnHostSignal =
+        [](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Event.pfnHostSignalCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnHostSignalCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventHostSignal_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostSynchronizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnHostSynchronize =
+        [](ze_event_handle_t hEvent, uint64_t timeout) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Event.pfnHostSynchronizeCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnHostSynchronizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventHostSynchronize_Tracing(nullptr, 1U);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventQueryStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnQueryStatus =
+        [](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Event.pfnQueryStatusCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnQueryStatusCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventQueryStatus_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventHostResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnHostReset =
+        [](ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Event.pfnHostResetCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnHostResetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventHostReset_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.EventPool.pfnCreate =
+        [](ze_context_handle_t hContext,
+           const ze_event_pool_desc_t *desc,
+           uint32_t numDevices,
+           ze_device_handle_t *phDevices,
+           ze_event_pool_handle_t *phEventPool) { return ZE_RESULT_SUCCESS; };
+    prologCbs.EventPool.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.EventPool.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventPoolCreate_Tracing(nullptr, nullptr, 1U, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.EventPool.pfnDestroy =
+        [](ze_event_pool_handle_t hEventPool) { return ZE_RESULT_SUCCESS; };
+    prologCbs.EventPool.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.EventPool.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventPoolDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolGetIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.EventPool.pfnGetIpcHandle =
+        [](ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t *phIpc) { return ZE_RESULT_SUCCESS; };
+    ze_ipc_event_pool_handle_t phIpc;
+
+    prologCbs.EventPool.pfnGetIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.EventPool.pfnGetIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventPoolGetIpcHandle_Tracing(nullptr, &phIpc);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolOpenIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.EventPool.pfnOpenIpcHandle =
+        [](ze_context_handle_t hDriver,
+           ze_ipc_event_pool_handle_t hIpc,
+           ze_event_pool_handle_t *phEventPool) { return ZE_RESULT_SUCCESS; };
+    ze_ipc_event_pool_handle_t hIpc = {};
+    ze_event_pool_handle_t phEventPool;
+
+    prologCbs.EventPool.pfnOpenIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.EventPool.pfnOpenIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventPoolOpenIpcHandle_Tracing(nullptr, hIpc, &phEventPool);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventPoolCloseIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.EventPool.pfnCloseIpcHandle =
+        [](ze_event_pool_handle_t hEventPool) { return ZE_RESULT_SUCCESS; };
+    prologCbs.EventPool.pfnCloseIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.EventPool.pfnCloseIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventPoolCloseIpcHandle_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+// Command List API with Events
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendSignalEventTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendSignalEvent =
+        [](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+    prologCbs.CommandList.pfnAppendSignalEventCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendSignalEventCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendSignalEvent_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendWaitOnEventsTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendWaitOnEvents =
+        [](ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t *phEvents) { return ZE_RESULT_SUCCESS; };
+
+    ze_event_handle_t phEvents = {};
+
+    prologCbs.CommandList.pfnAppendWaitOnEventsCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendWaitOnEventsCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendWaitOnEvents_Tracing(nullptr, 1, &phEvents);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendEventResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendEventReset =
+        [](ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandList.pfnAppendEventResetCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendEventResetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendEventReset_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingEventQueryKernelTimestampTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Event.pfnQueryKernelTimestamp =
+        [](ze_event_handle_t hEvent, ze_kernel_timestamp_result_t *dstptr) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Event.pfnQueryKernelTimestampCb = genericPrologCallbackPtr;
+    epilogCbs.Event.pfnQueryKernelTimestampCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeEventQueryKernelTimestamp_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+// See test_event_api_multi_tracing.cpp for more tests
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_fence_api_tracing.cpp

@@ -0,0 +1,857 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Fence.pfnCreate =
+        [](ze_command_queue_handle_t hCommandQueue, const ze_fence_desc_t *desc, ze_fence_handle_t *phFence) { return ZE_RESULT_SUCCESS; };
+    ze_fence_handle_t fence = {};
+    ze_fence_desc_t desc = {};
+
+    prologCbs.Fence.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Fence.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceCreate_Tracing(nullptr, &desc, &fence);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Fence.pfnDestroy =
+        [](ze_fence_handle_t hFence) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Fence.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Fence.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceHostSynchronizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize =
+        [](ze_fence_handle_t hFence, uint64_t timeout) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Fence.pfnHostSynchronizeCb = genericPrologCallbackPtr;
+    epilogCbs.Fence.pfnHostSynchronizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceHostSynchronize_Tracing(nullptr, 1U);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceQueryStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus =
+        [](ze_fence_handle_t hFence) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Fence.pfnQueryStatusCb = genericPrologCallbackPtr;
+    epilogCbs.Fence.pfnQueryStatusCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceQueryStatus_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingFenceResetTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Fence.pfnReset =
+        [](ze_fence_handle_t hFence) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Fence.pfnResetCb = genericPrologCallbackPtr;
+    epilogCbs.Fence.pfnResetCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceReset_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+struct {
+    ze_command_queue_handle_t hCommandQueue0;
+    ze_fence_desc_t desc0;
+    ze_fence_handle_t hFence0;
+    ze_command_queue_handle_t hCommandQueue1;
+    ze_fence_desc_t desc1;
+    ze_fence_handle_t hFence1;
+    ze_fence_handle_t hFenceAPI;
+    void *instanceData0;
+    void *instanceData3;
+} fence_create_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    fence_create_args.hCommandQueue0 = generateRandomHandle<ze_command_queue_handle_t>();
+    fence_create_args.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>();
+
+    // initialize user instance data
+    fence_create_args.instanceData0 = generateRandomHandle<void *>();
+    fence_create_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Fence.pfnCreate =
+        [](ze_command_queue_handle_t hCommandQueue, const ze_fence_desc_t *desc, ze_fence_handle_t *phFence) {
+            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;
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_create_args.hCommandQueue0, *params->phCommandQueue);
+            EXPECT_EQ(&fence_create_args.desc0, *params->pdesc);
+            EXPECT_EQ(&fence_create_args.hFence0, *params->pphFence);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            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;
+            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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(fence_create_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
+            EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
+            EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(fence_create_args.hFence1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(fence_create_args.hFence1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
+            EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
+            EXPECT_EQ(&fence_create_args.hFence1, *params->pphFence);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(fence_create_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Fence.pfnCreateCb =
+        [](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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);
+
+            ze_fence_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphFence;
+
+            ze_fence_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_fence_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            ASSERT_NE(nullptr, handle);
+            EXPECT_EQ(fence_create_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceCreate_Tracing(fence_create_args.hCommandQueue0, &fence_create_args.desc0, &fence_create_args.hFence0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(fence_create_args.hFence1, fence_create_args.hFenceAPI);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_fence_handle_t hFence0;
+    ze_fence_handle_t hFence1;
+    void *instanceData0;
+    void *instanceData3;
+} fence_destroy_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    fence_destroy_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize replacement argument set
+    fence_destroy_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize user instance data
+    fence_destroy_args.instanceData0 = generateRandomHandle<void *>();
+    fence_destroy_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Fence.pfnDestroy =
+        [](ze_fence_handle_t hFence) {
+            EXPECT_EQ(fence_destroy_args.hFence1, hFence);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_destroy_args.hFence0, *params->phFence);
+            *params->phFence = fence_destroy_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_destroy_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_destroy_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Fence.pfnDestroyCb =
+        [](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_destroy_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceDestroy_Tracing(fence_destroy_args.hFence0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_fence_handle_t hFence0;
+    uint64_t timeout0;
+    ze_fence_handle_t hFence1;
+    uint64_t timeout1;
+    void *instanceData0;
+    void *instanceData3;
+} fence_host_synchronize_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchronizeTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    fence_host_synchronize_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
+    fence_host_synchronize_args.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>();
+
+    // initialize user instance data
+    fence_host_synchronize_args.instanceData0 = generateRandomHandle<void *>();
+    fence_host_synchronize_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Fence.pfnHostSynchronize =
+        [](ze_fence_handle_t hFence, uint64_t timeout) {
+            EXPECT_EQ(fence_host_synchronize_args.hFence1, hFence);
+            EXPECT_EQ(fence_host_synchronize_args.timeout1, timeout);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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;
+            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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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);
+            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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
+            EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
+            EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
+            EXPECT_EQ(fence_host_synchronize_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Fence.pfnHostSynchronizeCb =
+        [](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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);
+            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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceHostSynchronize_Tracing(fence_host_synchronize_args.hFence0, fence_host_synchronize_args.timeout0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_fence_handle_t hFence0;
+    ze_fence_handle_t hFence1;
+    void *instanceData0;
+    void *instanceData3;
+} fence_query_status_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    fence_query_status_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize replacement argument set
+    fence_query_status_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize user instance data
+    fence_query_status_args.instanceData0 = generateRandomHandle<void *>();
+    fence_query_status_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Fence.pfnQueryStatus =
+        [](ze_fence_handle_t hFence) {
+            EXPECT_EQ(fence_query_status_args.hFence1, hFence);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_query_status_args.hFence0, *params->phFence);
+            *params->phFence = fence_query_status_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_query_status_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_query_status_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Fence.pfnQueryStatusCb =
+        [](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_query_status_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceQueryStatus_Tracing(fence_query_status_args.hFence0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_fence_handle_t hFence0;
+    ze_fence_handle_t hFence1;
+    void *instanceData0;
+    void *instanceData3;
+} fence_reset_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    fence_reset_args.hFence0 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize replacement argument set
+    fence_reset_args.hFence1 = generateRandomHandle<ze_fence_handle_t>();
+
+    // initialize user instance data
+    fence_reset_args.instanceData0 = generateRandomHandle<void *>();
+    fence_reset_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Fence.pfnReset =
+        [](ze_fence_handle_t hFence) {
+            EXPECT_EQ(fence_reset_args.hFence1, hFence);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_reset_args.hFence0, *params->phFence);
+            *params->phFence = fence_reset_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_reset_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(fence_reset_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Fence.pfnResetCb =
+        [](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(fence_reset_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeFenceReset_Tracing(fence_reset_args.hFence0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_global_api_tracing.cpp

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingInitTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Global.pfnInit = [](ze_init_flags_t flags) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Global.pfnInitCb = genericPrologCallbackPtr;
+    epilogCbs.Global.pfnInitCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeInit_Tracing(ZE_INIT_FLAG_GPU_ONLY);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_image_api_tracing.cpp

@@ -0,0 +1,605 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingImageGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Image.pfnGetProperties =
+        [](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) { return ZE_RESULT_SUCCESS; };
+    const ze_image_desc_t desc = {};
+    ze_image_properties_t pImageProperties = {};
+
+    prologCbs.Image.pfnGetPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Image.pfnGetPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageGetProperties_Tracing(nullptr, &desc, &pImageProperties);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingImageCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Image.pfnCreate =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) { return ZE_RESULT_SUCCESS; };
+    const ze_image_desc_t desc = {};
+    ze_image_handle_t phImage = {};
+
+    prologCbs.Image.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Image.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageCreate_Tracing(nullptr, nullptr, &desc, &phImage);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingImageDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Image.pfnDestroy =
+        [](ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
+    prologCbs.Image.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Image.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+// More complex tracing test.
+
+struct {
+    ze_device_handle_t hDevice0;
+    ze_image_desc_t desc0;
+    ze_image_properties_t ImageProperties0;
+    ze_device_handle_t hDevice1;
+    ze_image_desc_t desc1;
+    ze_image_properties_t ImageProperties1;
+    void *instanceData0;
+    void *instanceData3;
+} ImageGetProperties_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    ImageGetProperties_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
+
+    // initialize replacement argument set
+    ImageGetProperties_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
+
+    // initialize user instance data
+    ImageGetProperties_args.instanceData0 = generateRandomHandle<void *>();
+    ImageGetProperties_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Image.pfnGetProperties =
+        [](ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_properties_t *pImageProperties) {
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, hDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, desc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, pImageProperties);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageGetProperties_args.hDevice0, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc0, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties0, *params->ppImageProperties);
+            *params->phDevice = ImageGetProperties_args.hDevice1;
+            *params->pdesc = &ImageGetProperties_args.desc1;
+            *params->ppImageProperties = &ImageGetProperties_args.ImageProperties1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageGetProperties_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageGetProperties_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Image.pfnGetPropertiesCb =
+        [](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
+            EXPECT_EQ(&ImageGetProperties_args.ImageProperties1, *params->ppImageProperties);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageGetProperties_Tracing(ImageGetProperties_args.hDevice0, &ImageGetProperties_args.desc0, &ImageGetProperties_args.ImageProperties0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    ze_image_desc_t desc0;
+    ze_image_handle_t hImage0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    ze_image_desc_t desc1;
+    ze_image_handle_t hImage1;
+    ze_image_handle_t hImageAPI;
+    void *instanceData0;
+    void *instanceData3;
+} ImageCreate_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    ImageCreate_args.instanceData0 = generateRandomHandle<void *>();
+    ImageCreate_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Image.pfnCreate =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t *desc, ze_image_handle_t *phImage) {
+            EXPECT_EQ(ImageCreate_args.hContext1, hContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, hDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, desc);
+            EXPECT_EQ(&ImageCreate_args.hImage1, phImage);
+            EXPECT_EQ(ImageCreate_args.hImage1, *phImage);
+            ImageCreate_args.hImageAPI = generateRandomHandle<ze_image_handle_t>();
+            *phImage = ImageCreate_args.hImageAPI;
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            ASSERT_NE(nullptr, params);
+            ASSERT_NE(nullptr, params->phContext);
+            ASSERT_NE(nullptr, params->phDevice);
+            ASSERT_NE(nullptr, *params->phContext);
+            ASSERT_NE(nullptr, *params->phDevice);
+            EXPECT_EQ(ImageCreate_args.hContext0, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice0, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc0, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage0, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage0, handle);
+
+            *params->phContext = ImageCreate_args.hContext1;
+            *params->phDevice = ImageCreate_args.hDevice1;
+            *params->pdesc = &ImageCreate_args.desc1;
+            *params->pphImage = &ImageCreate_args.hImage1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageCreate_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            ASSERT_NE(nullptr, params);
+            ASSERT_NE(nullptr, params->phContext);
+            ASSERT_NE(nullptr, params->phDevice);
+            ASSERT_NE(nullptr, *params->phContext);
+            ASSERT_NE(nullptr, *params->phDevice);
+            EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage1, handle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage1, handle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage1, handle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage1, handle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageCreate_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Image.pfnCreateCb =
+        [](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
+            EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&ImageCreate_args.desc1, *params->pdesc);
+
+            ze_image_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphImage;
+
+            ze_image_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&ImageCreate_args.hImage1, pHandle);
+
+            ze_image_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(ImageCreate_args.hImage1, handle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageCreate_Tracing(ImageCreate_args.hContext0, ImageCreate_args.hDevice0, &ImageCreate_args.desc0, &ImageCreate_args.hImage0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_image_handle_t hImage0;
+    ze_image_handle_t hImage1;
+    void *instanceData0;
+    void *instanceData3;
+} ImageDestroy_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    ImageDestroy_args.hImage0 = generateRandomHandle<ze_image_handle_t>();
+
+    // initialize replacement argument set
+    ImageDestroy_args.hImage1 = generateRandomHandle<ze_image_handle_t>();
+
+    // initialize user instance data
+    ImageDestroy_args.instanceData0 = generateRandomHandle<void *>();
+    ImageDestroy_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Image.pfnDestroy =
+        [](ze_image_handle_t hImage) {
+            EXPECT_EQ(ImageDestroy_args.hImage1, hImage);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageDestroy_args.hImage0, *params->phImage);
+            *params->phImage = ImageDestroy_args.hImage1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageDestroy_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = ImageDestroy_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Image.pfnDestroyCb =
+        [](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeImageDestroy_Tracing(ImageDestroy_args.hImage0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_memory_api_tracing.cpp

@@ -0,0 +1,312 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocSharedTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Mem.pfnAllocShared =
+        [](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) { return ZE_RESULT_SUCCESS; };
+
+    ze_device_mem_alloc_desc_t deviceDesc;
+    ze_host_mem_alloc_desc_t hostDesc;
+    size_t size = 1024;
+    size_t alignment = 4096;
+    void *pptr = nullptr;
+
+    prologCbs.Mem.pfnAllocSharedCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnAllocSharedCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemAllocShared_Tracing(nullptr, &deviceDesc, &hostDesc, size, alignment, nullptr, &pptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocDeviceTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Mem.pfnAllocDevice =
+        [](ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t *deviceDesc, size_t size, size_t alignment, ze_device_handle_t hDevice, void **pptr) { return ZE_RESULT_SUCCESS; };
+
+    size_t size = 1024;
+    size_t alignment = 4096;
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    void *pptr = nullptr;
+
+    prologCbs.Mem.pfnAllocDeviceCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnAllocDeviceCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemAllocDevice_Tracing(nullptr, &deviceDesc, size, alignment, nullptr, &pptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemAllocHostTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnAllocHost =
+        [](ze_context_handle_t hContext, const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment, void **pptr) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+    size_t size = 1024;
+    size_t alignment = 4096;
+    ze_host_mem_alloc_desc_t hostDesc = {};
+    void *pptr = nullptr;
+
+    prologCbs.Mem.pfnAllocHostCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnAllocHostCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemAllocHost_Tracing(nullptr, &hostDesc, size, alignment, &pptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemFreeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnFree =
+        [](ze_context_handle_t hContext, void *ptr) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.Mem.pfnFreeCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnFreeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemFree_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetAllocPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnGetAllocProperties =
+        [](ze_context_handle_t hContext, const void *ptr, ze_memory_allocation_properties_t *pMemAllocProperties, ze_device_handle_t *phDevice) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.Mem.pfnGetAllocPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnGetAllocPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemGetAllocProperties_Tracing(nullptr, nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetAddressRangeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnGetAddressRange =
+        [](ze_context_handle_t hContext, const void *ptr, void **pBase, size_t *pSize) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.Mem.pfnGetAddressRangeCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnGetAddressRangeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemGetAddressRange_Tracing(nullptr, nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemGetIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnGetIpcHandle =
+        [](ze_context_handle_t hContext, const void *ptr, ze_ipc_mem_handle_t *pIpcHandle) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.Mem.pfnGetIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnGetIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemGetIpcHandle_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemOpenIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnOpenIpcHandle =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle, ze_ipc_memory_flags_t flags, void **pptr) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    ze_ipc_mem_handle_t ipchandle = {};
+
+    prologCbs.Mem.pfnOpenIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnOpenIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemOpenIpcHandle_Tracing(nullptr, nullptr, ipchandle, ZE_IPC_MEMORY_FLAG_TBD, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingMemCloseIpcHandleTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.Mem.pfnCloseIpcHandle =
+        [](ze_context_handle_t hContext, const void *ptr) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.Mem.pfnCloseIpcHandleCb = genericPrologCallbackPtr;
+    epilogCbs.Mem.pfnCloseIpcHandleCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeMemCloseIpcHandle_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingPhysicalMemCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.PhysicalMem.pfnCreate =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_physical_mem_desc_t *desc, ze_physical_mem_handle_t *phPhysicalMemory) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.PhysicalMem.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.PhysicalMem.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zePhysicalMemCreate_Tracing(nullptr, nullptr, nullptr, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingPhysicalMemDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.PhysicalMem.pfnDestroy =
+        [](ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMemory) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.PhysicalMem.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.PhysicalMem.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zePhysicalMemDestroy_Tracing(nullptr, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemFreeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnFree =
+        [](ze_context_handle_t hContext, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnFreeCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnFreeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemFree_Tracing(nullptr, nullptr, 1U);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemGetAccessAttributeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnGetAccessAttribute =
+        [](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t *access, size_t *outSize) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnGetAccessAttributeCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnGetAccessAttributeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemGetAccessAttribute_Tracing(nullptr, nullptr, 1U, nullptr, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemMapTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnMap =
+        [](ze_context_handle_t hContext, const void *ptr, size_t size, ze_physical_mem_handle_t hPhysicalMemory, size_t offset, ze_memory_access_attribute_t access) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnMapCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnMapCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemMap_Tracing(nullptr, nullptr, 1U, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemQueryPageSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnQueryPageSize =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t size, size_t *pagesize) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnQueryPageSizeCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnQueryPageSizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemQueryPageSize_Tracing(nullptr, nullptr, 1U, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemReserveTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnReserve =
+        [](ze_context_handle_t hContext, const void *pStart, size_t size, void **pptr) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnReserveCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnReserveCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemReserve_Tracing(nullptr, nullptr, 1U, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemSetAccessAttributeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnSetAccessAttribute =
+        [](ze_context_handle_t hContext, const void *ptr, size_t size, ze_memory_access_attribute_t access) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnSetAccessAttributeCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnSetAccessAttributeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemSetAccessAttribute_Tracing(nullptr, nullptr, 1U, ZE_MEMORY_ACCESS_ATTRIBUTE_NONE);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingVirtualMemUnmapTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    driver_ddiTable.core_ddiTable.VirtualMem.pfnUnmap =
+        [](ze_context_handle_t hContext, const void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
+    ze_result_t result;
+
+    prologCbs.VirtualMem.pfnUnmapCb = genericPrologCallbackPtr;
+    epilogCbs.VirtualMem.pfnUnmapCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeVirtualMemUnmap_Tracing(nullptr, nullptr, 1U);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_module_api_multi_tracing.cpp

@@ -0,0 +1,785 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+#include <string.h>
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    ze_module_desc_t desc0;
+    ze_module_handle_t hModule0;
+    ze_module_build_log_handle_t hBuildLog0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    ze_module_desc_t desc1;
+    ze_module_handle_t hModule1;
+    ze_module_build_log_handle_t hBuildLog1;
+    ze_module_handle_t hModuleAPI;
+    ze_module_build_log_handle_t hBuildLogAPI;
+    void *instanceData0;
+    void *instanceData3;
+} module_create_args;
+
+static void moduleCreateDescInitRandom(ze_module_desc_t *desc) {
+    uint8_t *ptr = (uint8_t *)desc;
+    for (size_t i = 0; i < sizeof(*desc); i++, ptr++) {
+        *ptr = generateRandomSize<uint8_t>();
+    }
+}
+
+static bool moduleCreateDescCompare(const ze_module_desc_t *phIpc0, const ze_module_desc_t *phIpc1) {
+    if (nullptr == phIpc0) {
+        return false;
+    }
+    if (nullptr == phIpc1) {
+        return false;
+    }
+    return (memcmp((void *)phIpc0, (void *)phIpc1, sizeof(ze_module_desc_t)) == 0);
+}
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    module_create_args.instanceData0 = generateRandomHandle<void *>();
+    module_create_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.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) {
+            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;
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule0, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule0, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog0, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.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;
+
+            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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule1, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule1, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule1, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule1, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule1, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule1, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.hBuildLog1, logHandle);
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule1, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule1, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Module.pfnCreateCb =
+        [](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            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));
+
+            ze_module_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphModule;
+
+            ze_module_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+            EXPECT_EQ(&module_create_args.hModule1, pHandle);
+
+            ze_module_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+            EXPECT_EQ(module_create_args.hModule1, handle);
+
+            ze_module_build_log_handle_t **ppLogHandle;
+            ppLogHandle = params->pphBuildLog;
+
+            ze_module_build_log_handle_t *pLogHandle;
+            ASSERT_NE(nullptr, ppLogHandle);
+            pLogHandle = *ppLogHandle;
+            EXPECT_EQ(&module_create_args.hBuildLog1, pLogHandle);
+
+            ze_module_build_log_handle_t logHandle;
+            logHandle = *pLogHandle;
+            ASSERT_NE(nullptr, logHandle);
+            EXPECT_EQ(module_create_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleCreate_Tracing(module_create_args.hContext0, module_create_args.hDevice0, &module_create_args.desc0, &module_create_args.hModule0, &module_create_args.hBuildLog0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_module_handle_t hModule0;
+    ze_module_handle_t hModule1;
+    void *instanceData0;
+    void *instanceData3;
+} module_destroy_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    module_destroy_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
+
+    // initialize replacement argument set
+    module_destroy_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
+
+    // initialize user instance data
+    module_destroy_args.instanceData0 = generateRandomHandle<void *>();
+    module_destroy_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Module.pfnDestroy =
+        [](ze_module_handle_t hModule) {
+            EXPECT_EQ(module_destroy_args.hModule1, hModule);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_destroy_args.hModule0, *params->phModule);
+            *params->phModule = module_destroy_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_destroy_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_destroy_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Module.pfnDestroyCb =
+        [](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_destroy_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleDestroy_Tracing(module_destroy_args.hModule0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+static constexpr size_t moduleGetNativeBinarySize0 = 64;
+static constexpr size_t moduleGetNativeBinarySize1 = 128;
+
+struct {
+    ze_module_handle_t hModule0;
+    size_t size0 = moduleGetNativeBinarySize0;
+    uint8_t moduleNativeBinary0[moduleGetNativeBinarySize0];
+    ze_module_handle_t hModule1;
+    size_t size1 = moduleGetNativeBinarySize1;
+    uint8_t moduleNativeBinary1[moduleGetNativeBinarySize1];
+    void *instanceData0;
+    void *instanceData3;
+} module_get_native_binary_args;
+
+static void module_get_native_binary_native_binary_init_random(uint8_t *binary, size_t size) {
+    uint8_t *ptr = binary;
+    for (size_t i = 0; i < size; i++) {
+        *ptr = generateRandomSize<uint8_t>();
+    }
+}
+
+static bool module_get_native_binary_native_binary_compare(uint8_t *binary0, uint8_t *binary1, size_t size) {
+    if (binary0 == nullptr) {
+        return false;
+    }
+    if (binary1 == nullptr) {
+        return false;
+    }
+    return (memcmp(static_cast<void *>(binary0), static_cast<void *>(binary1), size) == 0);
+}
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBinaryTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    module_get_native_binary_args.hModule0 = generateRandomHandle<ze_module_handle_t>();
+    module_get_native_binary_native_binary_init_random(module_get_native_binary_args.moduleNativeBinary0, moduleGetNativeBinarySize0);
+
+    // initialize replacement argument set
+    module_get_native_binary_args.hModule1 = generateRandomHandle<ze_module_handle_t>();
+    module_get_native_binary_native_binary_init_random(module_get_native_binary_args.moduleNativeBinary1, moduleGetNativeBinarySize1);
+
+    // initialize user instance data
+    module_get_native_binary_args.instanceData0 = generateRandomHandle<void *>();
+    module_get_native_binary_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary =
+        [](ze_module_handle_t hModule, size_t *pSize, uint8_t *pModuleNativeBinary) {
+            EXPECT_EQ(module_get_native_binary_args.hModule1, hModule);
+            EXPECT_EQ(&module_get_native_binary_args.size1, pSize);
+            EXPECT_EQ(*pSize, moduleGetNativeBinarySize1);
+            EXPECT_EQ(module_get_native_binary_args.moduleNativeBinary1, pModuleNativeBinary);
+            EXPECT_TRUE(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
+                                                                       pModuleNativeBinary, moduleGetNativeBinarySize0));
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_get_native_binary_args.hModule0, *params->phModule);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.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;
+
+            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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.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);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
+                                                                       *params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.moduleNativeBinary1,
+                                                                       *params->ppModuleNativeBinary, moduleGetNativeBinarySize1));
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
+            EXPECT_EQ(&module_get_native_binary_args.size1, *params->ppSize);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.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;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Module.pfnGetNativeBinaryCb =
+        [](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
+
+            size_t **ppSize;
+            ASSERT_NE(nullptr, params);
+            ppSize = params->ppSize;
+
+            size_t *pSize;
+            ASSERT_NE(nullptr, ppSize);
+            pSize = *ppSize;
+            EXPECT_EQ(&module_get_native_binary_args.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(module_get_native_binary_native_binary_compare(module_get_native_binary_args.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);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetNativeBinary_Tracing(module_get_native_binary_args.hModule0, &module_get_native_binary_args.size0, module_get_native_binary_args.moduleNativeBinary0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_module_api_tracing.cpp

@@ -0,0 +1,437 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnCreate =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t *pDesc, ze_module_handle_t *phModule, ze_module_build_log_handle_t *phBuildLog) { return ZE_RESULT_SUCCESS; };
+    ze_module_desc_t desc = {};
+    ze_module_handle_t phModule = {};
+    ze_module_build_log_handle_t phBuildLog = {};
+
+    prologCbs.Module.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleCreate_Tracing(nullptr, nullptr, &desc, &phModule, &phBuildLog);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnDestroy =
+        [](ze_module_handle_t hModule) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Module.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleBuildLogDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnDestroy =
+        [](ze_module_build_log_handle_t hModuleBuildLog) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.ModuleBuildLog.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.ModuleBuildLog.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleBuildLogDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleBuildLogGetStringTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.ModuleBuildLog.pfnGetString =
+        [](ze_module_build_log_handle_t hModuleBuildLog, size_t *pSize, char *pBuildLog) { return ZE_RESULT_SUCCESS; };
+
+    size_t pSize = {};
+    char pBuildLog = {};
+
+    prologCbs.ModuleBuildLog.pfnGetStringCb = genericPrologCallbackPtr;
+    epilogCbs.ModuleBuildLog.pfnGetStringCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleBuildLogGetString_Tracing(nullptr, &pSize, &pBuildLog);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetNativeBinaryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnGetNativeBinary =
+        [](ze_module_handle_t hModule, size_t *pSize, uint8_t *pModuleNativeBinary) { return ZE_RESULT_SUCCESS; };
+    size_t pSize = {};
+    uint8_t pModuleNativeBinary = {};
+
+    prologCbs.Module.pfnGetNativeBinaryCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnGetNativeBinaryCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetNativeBinary_Tracing(nullptr, &pSize, &pModuleNativeBinary);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetGlobalPointerTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnGetGlobalPointer =
+        [](ze_module_handle_t hModule, const char *pGlobalName, size_t *pSize, void **pPtr) { return ZE_RESULT_SUCCESS; };
+    const char pGlobalName = {};
+    size_t size;
+    void *pptr = nullptr;
+
+    prologCbs.Module.pfnGetGlobalPointerCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnGetGlobalPointerCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetGlobalPointer_Tracing(nullptr, &pGlobalName, &size, &pptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnCreate =
+        [](ze_module_handle_t hModule, const ze_kernel_desc_t *pDesc, ze_kernel_handle_t *phKernel) { return ZE_RESULT_SUCCESS; };
+    const ze_kernel_desc_t desc = {};
+    ze_kernel_handle_t phKernel = {};
+
+    prologCbs.Kernel.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelCreate_Tracing(nullptr, &desc, &phKernel);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnDestroy =
+        [](ze_kernel_handle_t hKernel) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetFunctionPointerTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnGetFunctionPointer =
+        [](ze_module_handle_t hModule, const char *pKernelName, void **pfnFunction) { return ZE_RESULT_SUCCESS; };
+    const char pKernelName = {};
+    void *pfnFunction = nullptr;
+
+    prologCbs.Module.pfnGetFunctionPointerCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnGetFunctionPointerCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetFunctionPointer_Tracing(nullptr, &pKernelName, &pfnFunction);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetGroupSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSetGroupSize =
+        [](ze_kernel_handle_t hKernel, uint32_t groupSizeX, uint32_t groupSizeY, uint32_t groupSizeZ) { return ZE_RESULT_SUCCESS; };
+    uint32_t groupSizeX = {};
+    uint32_t groupSizeY = {};
+    uint32_t groupSizeZ = {};
+
+    prologCbs.Kernel.pfnSetGroupSizeCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSetGroupSizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSetGroupSize_Tracing(nullptr, groupSizeX, groupSizeY, groupSizeZ);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSuggestGroupSizeTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSuggestGroupSize =
+        [](ze_kernel_handle_t hKernel, uint32_t globalSizeX, uint32_t globalSizeY, uint32_t globalSizeZ, uint32_t *groupSizeX, uint32_t *groupSizeY, uint32_t *groupSizeZ) { return ZE_RESULT_SUCCESS; };
+    uint32_t globalSizeX = {};
+    uint32_t globalSizeY = {};
+    uint32_t globalSizeZ = {};
+    uint32_t groupSizeX = {};
+    uint32_t groupSizeY = {};
+    uint32_t groupSizeZ = {};
+
+    prologCbs.Kernel.pfnSuggestGroupSizeCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSuggestGroupSizeCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSuggestGroupSize_Tracing(nullptr, globalSizeX, globalSizeY, globalSizeZ, &groupSizeX, &groupSizeY, &groupSizeZ);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetArgumentValueTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSetArgumentValue =
+        [](ze_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize, const void *pArgValue) { return ZE_RESULT_SUCCESS; };
+    uint32_t argIndex = {};
+    size_t argSize = {};
+    const void *pArgValue = nullptr;
+
+    prologCbs.Kernel.pfnSetArgumentValueCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSetArgumentValueCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSetArgumentValue_Tracing(nullptr, argIndex, argSize, &pArgValue);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnGetProperties =
+        [](ze_kernel_handle_t hKernel, ze_kernel_properties_t *pKernelProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnGetPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnGetPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelGetProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernel =
+        [](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchFuncArgs,
+           ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    const ze_group_count_t pLaunchFuncArgs = {};
+    ze_event_handle_t hSignalEvent = {};
+    uint32_t numWaitEvents = {};
+    ze_event_handle_t phWaitEvents = {};
+
+    prologCbs.CommandList.pfnAppendLaunchKernelCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendLaunchKernelCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendLaunchKernel_Tracing(nullptr, nullptr, &pLaunchFuncArgs, hSignalEvent, numWaitEvents, &phWaitEvents);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchKernelIndirectTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchKernelIndirect =
+        [](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchArgumentsBuffer,
+           ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    const ze_group_count_t pLaunchArgumentsBuffer = {};
+    ze_event_handle_t hSignalEvent = {};
+    uint32_t numWaitEvents = {};
+    ze_event_handle_t phWaitEvents = {};
+
+    prologCbs.CommandList.pfnAppendLaunchKernelIndirectCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendLaunchKernelIndirectCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendLaunchKernelIndirect_Tracing(nullptr, nullptr, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchMultipleKernelsIndirectTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchMultipleKernelsIndirect =
+        [](ze_command_list_handle_t hCommandList, uint32_t numKernels, ze_kernel_handle_t *phKernels,
+           const uint32_t *pNumLaunchArguments, const ze_group_count_t *pLaunchArgumentsBuffer, ze_event_handle_t hSignalEvent,
+           uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+    uint32_t numKernels = {};
+    ze_kernel_handle_t phKernels = {};
+    const uint32_t pNumLaunchArguments = {};
+    const ze_group_count_t pLaunchArgumentsBuffer = {};
+    ze_event_handle_t hSignalEvent = {};
+    uint32_t numWaitEvents = {};
+    ze_event_handle_t phWaitEvents = {};
+
+    prologCbs.CommandList.pfnAppendLaunchMultipleKernelsIndirectCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendLaunchMultipleKernelsIndirectCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendLaunchMultipleKernelsIndirect_Tracing(nullptr, numKernels, &phKernels, &pNumLaunchArguments, &pLaunchArgumentsBuffer, hSignalEvent, numWaitEvents, &phWaitEvents);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingCommandListAppendLaunchCooperativeKernelTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.CommandList.pfnAppendLaunchCooperativeKernel =
+        [](ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t *pLaunchFuncArgs, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.CommandList.pfnAppendLaunchCooperativeKernelCb = genericPrologCallbackPtr;
+    epilogCbs.CommandList.pfnAppendLaunchCooperativeKernelCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeCommandListAppendLaunchCooperativeKernel_Tracing(nullptr, nullptr, nullptr, nullptr, 1, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetKernelNamesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnGetKernelNames =
+        [](ze_module_handle_t hDevice, uint32_t *pCount, const char **pNames) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Module.pfnGetKernelNamesCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnGetKernelNamesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetKernelNames_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSuggestMaxCooperativeGroupCountTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSuggestMaxCooperativeGroupCount =
+        [](ze_kernel_handle_t hKernel, uint32_t *totalGroupCount) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnSuggestMaxCooperativeGroupCountCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSuggestMaxCooperativeGroupCountCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSuggestMaxCooperativeGroupCount_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetIndirectAccessTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnGetIndirectAccess =
+        [](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t *pFlags) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnGetIndirectAccessCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnGetIndirectAccessCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelGetIndirectAccess_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetNameTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnGetName =
+        [](ze_kernel_handle_t hKernel, size_t *pSize, char *pName) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnGetNameCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnGetNameCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelGetName_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelGetSourceAttributesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnGetSourceAttributes =
+        [](ze_kernel_handle_t hKernel, uint32_t *pSize, char **pString) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnGetSourceAttributesCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnGetSourceAttributesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelGetSourceAttributes_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingKernelSetIndirectAccessTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Kernel.pfnSetIndirectAccess =
+        [](ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t flags) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Kernel.pfnSetIndirectAccessCb = genericPrologCallbackPtr;
+    epilogCbs.Kernel.pfnSetIndirectAccessCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeKernelSetIndirectAccess_Tracing(nullptr, ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleDynamicLinkTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnDynamicLink =
+        [](uint32_t numModules, ze_module_handle_t *phModules, ze_module_build_log_handle_t *phLinkLog) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Module.pfnDynamicLinkCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnDynamicLinkCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleDynamicLink_Tracing(1U, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingModuleGetPropertiesTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Module.pfnGetProperties =
+        [](ze_module_handle_t hModule, ze_module_properties_t *pModuleProperties) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Module.pfnGetPropertiesCb = genericPrologCallbackPtr;
+    epilogCbs.Module.pfnGetPropertiesCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeModuleGetProperties_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_residency_api_tracing.cpp

@@ -0,0 +1,768 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnCreate = [](ze_driver_handle_t hContext, const ze_context_desc_t *desc, ze_context_handle_t *phContext) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextCreate_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnDestroy = [](ze_context_handle_t hContext) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextGetStatusTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnGetStatus = [](ze_context_handle_t hContext) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnGetStatusCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnGetStatusCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextGetStatus_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextSystemBarrierTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnSystemBarrier = [](ze_context_handle_t hContext, ze_device_handle_t hDevice) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnSystemBarrierCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnSystemBarrierCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextSystemBarrier_Tracing(nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextMakeMemoryResidentTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnMakeMemoryResidentCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnMakeMemoryResidentCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextMakeMemoryResident_Tracing(nullptr, nullptr, nullptr, 1024);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextEvictMemoryTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnEvictMemory = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnEvictMemoryCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnEvictMemoryCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextEvictMemory_Tracing(nullptr, nullptr, nullptr, 1024);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextMakeImageResidentTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnMakeImageResidentCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnMakeImageResidentCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextMakeImageResident_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingContextEvictImageTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Context.pfnEvictImage = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Context.pfnEvictImageCb = genericPrologCallbackPtr;
+    epilogCbs.Context.pfnEvictImageCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextEvictImage_Tracing(nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    void *ptr0;
+    size_t size0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    void *ptr1;
+    size_t size1;
+    void *instanceData0;
+    void *instanceData3;
+} MakeMemoryResident_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
+       WhenCallingContextMakeMemoryResidentTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    MakeMemoryResident_args.instanceData0 = generateRandomHandle<void *>();
+    MakeMemoryResident_args.instanceData3 = generateRandomHandle<void *>();
+
+    // arguments are expeted to be passed in from first prolog callback
+    driver_ddiTable.core_ddiTable.Context.pfnMakeMemoryResident =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) {
+            EXPECT_EQ(hContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(hDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(ptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(size, MakeMemoryResident_args.size1);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Allocate instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext0);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice0);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr0);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size0);
+            *params->phContext = MakeMemoryResident_args.hContext1;
+            *params->phDevice = MakeMemoryResident_args.hDevice1;
+            *params->pptr = MakeMemoryResident_args.ptr1;
+            *params->psize = MakeMemoryResident_args.size1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = MakeMemoryResident_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Allocate instance data and pass to corresponding epilog
+    //
+    prologCbs3.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = MakeMemoryResident_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    epilogCbs3.Context.pfnMakeMemoryResidentCb =
+        [](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
+            EXPECT_EQ(*params->pptr, MakeMemoryResident_args.ptr1);
+            EXPECT_EQ(*params->psize, MakeMemoryResident_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextMakeMemoryResident_Tracing(MakeMemoryResident_args.hContext0, MakeMemoryResident_args.hDevice0, MakeMemoryResident_args.ptr0, MakeMemoryResident_args.size0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    void *ptr0;
+    size_t size0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    void *ptr1;
+    size_t size1;
+    void *instanceData0;
+    void *instanceData3;
+} EvictMemory_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    EvictMemory_args.instanceData0 = generateRandomHandle<void *>();
+    EvictMemory_args.instanceData3 = generateRandomHandle<void *>();
+
+    driver_ddiTable.core_ddiTable.Context.pfnEvictMemory =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, void *ptr, size_t size) {
+            EXPECT_EQ(hContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(hDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(ptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(size, EvictMemory_args.size1);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(EvictMemory_args.hContext0, *params->phContext);
+            EXPECT_EQ(EvictMemory_args.hDevice0, *params->phDevice);
+            EXPECT_EQ(EvictMemory_args.ptr0, *params->pptr);
+            EXPECT_EQ(EvictMemory_args.size0, *params->psize);
+
+            *params->phContext = EvictMemory_args.hContext1;
+            *params->phDevice = EvictMemory_args.hDevice1;
+            *params->pptr = EvictMemory_args.ptr1;
+            *params->psize = EvictMemory_args.size1;
+
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = EvictMemory_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(*params->psize, EvictMemory_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(*params->psize, EvictMemory_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(*params->psize, EvictMemory_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Allocate instance data and pass to corresponding epilog
+    //
+    prologCbs3.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(*params->psize, EvictMemory_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = EvictMemory_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    epilogCbs3.Context.pfnEvictMemoryCb =
+        [](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
+            EXPECT_EQ(*params->pptr, EvictMemory_args.ptr1);
+            EXPECT_EQ(*params->psize, EvictMemory_args.size1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextEvictMemory_Tracing(EvictMemory_args.hContext0, EvictMemory_args.hDevice0, EvictMemory_args.ptr0, EvictMemory_args.size0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    ze_image_handle_t hImage0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    ze_image_handle_t hImage1;
+    void *instanceData0;
+    void *instanceData3;
+} MakeImageResident_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
+       WhenCallingContextMakeImageResidentTracingWrapperWithMultiplePrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    MakeImageResident_args.instanceData0 = generateRandomHandle<void *>();
+    MakeImageResident_args.instanceData3 = generateRandomHandle<void *>();
+
+    // arguments are expeted to be passed in from first prolog callback
+    driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) {
+            EXPECT_EQ(hContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(hDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(hImage, MakeImageResident_args.hImage1);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Allocate instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext0);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice0);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage0);
+            *params->phContext = MakeImageResident_args.hContext1;
+            *params->phDevice = MakeImageResident_args.hDevice1;
+            *params->phImage = MakeImageResident_args.hImage1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = MakeImageResident_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Allocate instance data and pass to corresponding epilog
+    //
+    prologCbs3.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = MakeImageResident_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    epilogCbs3.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
+            EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
+            EXPECT_EQ(*params->phImage, MakeImageResident_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextMakeImageResident_Tracing(MakeImageResident_args.hContext0, MakeImageResident_args.hDevice0, MakeImageResident_args.hImage0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    ze_image_handle_t hImage0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    ze_image_handle_t hImage1;
+    void *instanceData0;
+    void *instanceData3;
+} EvictImage_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
+       WhenCallingContextMakeImageResidentTracingWrapperWithMultiplefPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+
+    // 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>();
+
+    // 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>();
+
+    // initialize user instance data
+    EvictImage_args.instanceData0 = generateRandomHandle<void *>();
+    EvictImage_args.instanceData3 = generateRandomHandle<void *>();
+
+    // arguments are expeted to be passed in from first prolog callback
+    driver_ddiTable.core_ddiTable.Context.pfnMakeImageResident =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage) {
+            EXPECT_EQ(hContext, EvictImage_args.hContext1);
+            EXPECT_EQ(hDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(hImage, EvictImage_args.hImage1);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Allocate instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext0);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice0);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage0);
+            *params->phContext = EvictImage_args.hContext1;
+            *params->phDevice = EvictImage_args.hDevice1;
+            *params->phImage = EvictImage_args.hImage1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = EvictImage_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Allocate instance data and pass to corresponding epilog
+    //
+    prologCbs3.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = EvictImage_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    epilogCbs3.Context.pfnMakeImageResidentCb =
+        [](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
+            EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
+            EXPECT_EQ(*params->phImage, EvictImage_args.hImage1);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeContextMakeImageResident_Tracing(EvictImage_args.hContext0, EvictImage_args.hDevice0, EvictImage_args.hImage0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+} // namespace ult
+} // namespace L0

level_zero/experimental/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp

@@ -0,0 +1,429 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test_api_tracing_common.h"
+
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingSamplerCreateTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Sampler.pfnCreate = [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Sampler.pfnCreateCb = genericPrologCallbackPtr;
+    epilogCbs.Sampler.pfnCreateCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeSamplerCreate_Tracing(nullptr, nullptr, nullptr, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+TEST_F(zeAPITracingRuntimeTests, WhenCallingSamplerDestroyTracingWrapperWithOneSetOfPrologEpilogsThenReturnSuccess) {
+    ze_result_t result;
+    driver_ddiTable.core_ddiTable.Sampler.pfnDestroy = [](ze_sampler_handle_t hSampler) { return ZE_RESULT_SUCCESS; };
+
+    prologCbs.Sampler.pfnDestroyCb = genericPrologCallbackPtr;
+    epilogCbs.Sampler.pfnDestroyCb = genericEpilogCallbackPtr;
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeSamplerDestroy_Tracing(nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(defaultUserData, 1);
+}
+
+struct {
+    ze_context_handle_t hContext0;
+    ze_device_handle_t hDevice0;
+    ze_sampler_desc_t Desc0;
+    ze_sampler_handle_t hSampler0;
+    ze_context_handle_t hContext1;
+    ze_device_handle_t hDevice1;
+    ze_sampler_desc_t Desc1;
+    ze_sampler_handle_t hSampler1;
+    ze_sampler_handle_t hSamplerAPI;
+    void *instanceData0;
+    void *instanceData3;
+} sampler_create_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
+       WhenCallingSamplerCreateTracingWrapperWithTwoSetsOfPrologEpilogsCheckArgumentsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    sampler_create_args.hContext0 = generateRandomHandle<ze_context_handle_t>();
+    sampler_create_args.hDevice0 = generateRandomHandle<ze_device_handle_t>();
+    sampler_create_args.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
+
+    // initialize replacement argument set
+    sampler_create_args.hContext1 = generateRandomHandle<ze_context_handle_t>();
+    sampler_create_args.hDevice1 = generateRandomHandle<ze_device_handle_t>();
+    sampler_create_args.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
+
+    // initialize user instance data
+    sampler_create_args.instanceData0 = generateRandomHandle<void *>();
+    sampler_create_args.instanceData3 = generateRandomHandle<void *>();
+
+    // Arguments are expected to be passed in by the first prolog callback
+    driver_ddiTable.core_ddiTable.Sampler.pfnCreate =
+        [](ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t *pDesc, ze_sampler_handle_t *phSampler) {
+            EXPECT_EQ(sampler_create_args.hContext1, hContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, hDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, pDesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, phSampler);
+            EXPECT_EQ(sampler_create_args.hSampler1, *phSampler);
+            sampler_create_args.hSamplerAPI = generateRandomHandle<ze_sampler_handle_t>();
+            *phSampler = sampler_create_args.hSamplerAPI;
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Create instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_create_args.hContext0, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice0, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc0, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler0, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler0, handle);
+            *params->phContext = sampler_create_args.hContext1;
+            *params->phDevice = sampler_create_args.hDevice1;
+            *params->pdesc = &sampler_create_args.Desc1;
+            *params->pphSampler = &sampler_create_args.hSampler1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = sampler_create_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Create instance data and pass to corresponding epilog
+    //
+    prologCbs3.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = sampler_create_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Sampler.pfnCreateCb =
+        [](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
+            EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
+            EXPECT_EQ(&sampler_create_args.Desc1, *params->pdesc);
+            EXPECT_EQ(&sampler_create_args.hSampler1, *params->pphSampler);
+
+            ze_sampler_handle_t **ppHandle;
+            ASSERT_NE(nullptr, params);
+            ppHandle = params->pphSampler;
+
+            ze_sampler_handle_t *pHandle;
+            ASSERT_NE(nullptr, ppHandle);
+            pHandle = *ppHandle;
+
+            ze_sampler_handle_t handle;
+            ASSERT_NE(nullptr, pHandle);
+            handle = *pHandle;
+
+            EXPECT_EQ(sampler_create_args.hSampler1, handle);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeSamplerCreate_Tracing(sampler_create_args.hContext0, sampler_create_args.hDevice0, &sampler_create_args.Desc0, &sampler_create_args.hSampler0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(sampler_create_args.hSampler1, sampler_create_args.hSamplerAPI);
+    validateDefaultUserDataFinal();
+}
+
+struct {
+    ze_sampler_handle_t hSampler0;
+    ze_sampler_handle_t hSampler1;
+    void *instanceData0;
+    void *instanceData3;
+} sampler_destroy_args;
+
+TEST_F(zeAPITracingRuntimeMultipleArgumentsTests,
+       WhenCallingSamplerDestroyTracingWrapperWithTwoSetsOfPrologEpilogsCheckArgumentsThenReturnSuccess) {
+    ze_result_t result;
+
+    // initialize initial argument set
+    sampler_destroy_args.hSampler0 = generateRandomHandle<ze_sampler_handle_t>();
+
+    // initialize replacement argument set
+    sampler_destroy_args.hSampler1 = generateRandomHandle<ze_sampler_handle_t>();
+
+    // initialize user instance data
+    sampler_destroy_args.instanceData0 = generateRandomHandle<void *>();
+    sampler_destroy_args.instanceData3 = generateRandomHandle<void *>();
+
+    // Arguments are expected to be passed in by the first prolog callback
+    driver_ddiTable.core_ddiTable.Sampler.pfnDestroy =
+        [](ze_sampler_handle_t hSampler) {
+            EXPECT_EQ(sampler_destroy_args.hSampler1, hSampler);
+            return ZE_RESULT_SUCCESS;
+        };
+
+    //
+    // The 0th prolog replaces the orignal API arguments with a new set
+    // Allocate instance data, pass it to corresponding epilog.
+    //
+    prologCbs0.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_destroy_args.hSampler0, *params->phSampler);
+            *params->phSampler = sampler_destroy_args.hSampler1;
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 1);
+            *val += 1;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = sampler_destroy_args.instanceData0;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 0th epilog expects to see the API argument replacements
+    // Expect to receive instance data from corresponding prolog
+    //
+    epilogCbs0.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 2);
+            *val += 1;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData0);
+            delete instanceData;
+        };
+
+    //
+    // The 1st prolog sees the arguments as replaced by the 0th prolog.
+    // There is no epilog for this prolog, so don't allocate instance data
+    //
+    prologCbs1.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 11);
+            *val += 11;
+        };
+
+    //
+    // The 2nd epilog expects to see the API argument replacements
+    // There is no corresponding prolog, so there is no instance data
+    //
+    epilogCbs2.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 21);
+            *val += 21;
+        };
+
+    //
+    // The 3rd prolog expects to see the API argument replacements and doesn't modify them
+    // Allocate instance data and pass to corresponding epilog
+    //
+    prologCbs3.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 31);
+            *val += 31;
+            struct instanceDataStruct *instanceData = new struct instanceDataStruct;
+            instanceData->instanceDataValue = sampler_destroy_args.instanceData3;
+            *ppTracerInstanceUserData = instanceData;
+        };
+
+    //
+    // The 3rd epilog expects to see the API argument replacements
+    // Expect to see instance data from corresponding prolog
+    //
+    epilogCbs3.Sampler.pfnDestroyCb =
+        [](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
+            struct instanceDataStruct *instanceData;
+            EXPECT_EQ(result, ZE_RESULT_SUCCESS);
+            EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
+            ASSERT_NE(nullptr, pTracerUserData);
+            int *val = static_cast<int *>(pTracerUserData);
+            EXPECT_EQ(*val, 62);
+            *val += 31;
+            instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
+            EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData3);
+            delete instanceData;
+        };
+
+    setTracerCallbacksAndEnableTracer();
+
+    result = zeSamplerDestroy_Tracing(sampler_destroy_args.hSampler0);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    validateDefaultUserDataFinal();
+}
+
+} // namespace ult
+} // namespace L0